text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Compile-time рефлексия D
Доброго времени суток, хабр!
Сегодня поговорим о том, что делает метапрограммирование в D таким гибким и мощным — compile-time рефлексии. D позволяет программисту напрямую пользоваться информацией, которой оперирует компилятор, а не выводить её хитрыми способами. Так какую информацию позволяет получить компилятор и как её можно использовать?
Начнём с, наверное, самых частых в использовании, приёмов — выяснение валидности выражения:
```
__traits( compiles, a + b );
is( typeof( a + b ) );
```
И \_\_traits(compiles, expr) и is(typeof(expr)) ждут валидное, с точки зрения лексики, выражение expr (например, выражение 12thb не является валидным идентификатором, поэтому компилятор выдаст ошибку). Ведут себя они одинаково, но у них есть одно тонкое идейное различие — is(typeof(expr)) не проверяет возможность компиляции, а проверяет существование типа выражения. Следовательно, теоретически, возможна ситуация, когда тип может быть известен, но по каким-либо правилам данная конструкция не может быть скомпилирована. На практике я не встречал таких ситуаций (возможно, их **пока** нет в языке).
**Пример использования**Задача: создание функции, принимающей любые «похожие» на массивы объекты, содержащие «похожие» на числа элементы, возвращающей среднее значение (мат. ожидание).
Решение:
```
template isNumArray(T)
{
enum isNumArray = __traits(compiles,
{
auto a = T.init[0]; // opIndex с int аргументом
static if( !__traits(isArithmetic,a) ) // если тип не арифметический, то он должен
{
static assert( __traits( compiles, a=a+a ) ); // складываться
static assert( __traits( compiles, a=a-a ) ); // вычитаться
static assert( __traits( compiles, a=a*.0f ) ); // умножаться на float
}
auto b = T.init.length; // свойство length
static assert( is( typeof(b) : size_t ) );
});
}
auto mean(T)( T arr ) @property if( isNumArray!T )
in { assert( arr.length > 0 ); } body
{
// уверенно можно использовать конструкцию arr[index] и arr.length
// при этом элементы, возвращаемые arr[index] будут иметь необходимые операции
auto ret = arr[0] - arr[0]; // нейтральный элемент с точки зрения сложения (0)
foreach( i; 0 .. arr.length )
ret = ret + arr[i]; // мы не проверяли перегрузку опратора +=
return ret * ( 1.0f / arr.length );
}
```
Использование:
```
import std.string : format;
struct Vec2
{
float x=0, y=0;
// перегружаем операторы сложения и вычитания
auto opBinary(string op)( auto ref const Vec2 rhs ) const
if( op == "+" || op == "-" )
{ mixin( format( "return Vec2( x %1$s rhs.x, y %1$s rhs.y );", op ) ); }
// перегружаем оператор умножения
auto opBinary(string op)( float rhs ) const
if( op == "*" )
{ return Vec2( x * rhs, y * rhs ); }
}
struct Triangle
{
Vec2 p1, p2, p3;
// перегружаем такую форму var[index]
auto opIndex(size_t v)
{
switch(v)
{
case 0: return p1;
case 1: return p2;
case 2: return p3;
default: throw new Exception( "triangle have only three elements" );
}
}
static pure size_t length() { return 3; }
}
void main()
{
auto f = [ 1.0f, 2, 3 ];
assert( f.mean == 2.0f ); // с float числами
auto v = [ Vec2(1,6), Vec2(2,7), Vec2(3,5) ];
assert( v.mean == Vec2(2,6) ); // с массивом элементов user-defined типа
auto t = Triangle( Vec2(1,6), Vec2(2,7), Vec2(3,5) );
assert( t.mean == Vec2(2,6) ); // с user-defined типом
}
```
**Внимание**: не используйте код из примера (isNumArray), так как он не учитывает некоторых деталей (opIndex может возвращать константную ссылку, тогда не будут возможны операции присвоения).
#### Конструкция is(… )
Конструкция is имеет достаточно большой набор возможностей.
```
is( T ); // проверяет семантическую валидность T
```
Далее тип T во всех случаях проверяется на семантическую валидность.
```
is( T == Type ); // является ли тип T типом Type
is( T : Type ); // может ли тип T быть неявно приведён к типу Type
```
Существуют формы is, которые создают новые alias'ы
```
is( T ident );
```
В этом случае, при валидности типа T, будет создан alias на него под именем ident. Но интересней будет комбинировать такую форму с какой либо проверкой
```
is( T ident : Type );
is( T ident == Type );
```
**Пример**
```
void foo(T)( T value )
{
static if( is( T U : long ) ) // если тип T приводится к long
alias Num = U; // используем его
else
alias Num = long; // иначе long
}
```
Так же можно проверять чем является тип, выяснить его модификаторы
```
is( T == Specialization );
```
В этом случае Specialization это одно из возможных значений: struct, union, class, interface, enum, function, delegate, const, immutable, shared. Соответственно проверяется является ли тип T структурой, объединением, классом и т.д. И существует форма, комбинирующая проверку и объявление alias'а
```
is( T ident == Specialization );
```
Есть ещё один интересный приём — pattern-matching типов.
```
is( T == TypeTempl, TemplParams... );
is( T : TypeTempl, TemplParams... );
// с обявлением alias'ов
is( T ident == TypeTempl, TemplParams... );
is( T ident : TypeTempl, TemplParams... );
```
В этом случае TypeTempl — описание типа (составного), а TemplParams — элементы, из которых состоит TypeTempl.
**Пример**
```
struct Foo(size_t N, T) if( N > 0 ) { T[N] data; }
struct Bar(size_t N, T) if( N > 0 ) { float[N] arr; T value; }
void func(U)( U val )
{
static if( is( U E == S!(N,T), alias S, size_t N, T ) )
{
pragma(msg, "struct like Foo: ", E );
pragma(msg, "S: ", S.stringof);
pragma(msg, "N: ", N);
pragma(msg, "T: ", T);
}
else static if( is( U T : T[X], X ) )
{
pragma(msg, "associative array T[X]: ", U );
pragma(msg, "T(value): ", T);
pragma(msg, "X(key): ", X);
}
else static if( is( U T : T[N], size_t N ) )
{
pragma(msg, "static array T[N]: ", U );
pragma(msg, "T(value): ", T);
pragma(msg, "N(length): ", N);
}
else pragma(msg, "other: ", U );
pragma(msg,"");
}
void main()
{
func( Foo!(10,double).init );
func( Bar!(12,string).init );
func( [ "hello": 23 ] );
func( [ 42: "habr" ] );
func( Foo!(8,short).init.data );
func( 0 );
}
```
Вывод при компиляции
```
struct like Foo: Foo!(10LU, double)
S: Foo(ulong N, T) if (N > 0)
N: 10LU
T: double
struct like Foo: Bar!(12LU, string)
S: Bar(ulong N, T) if (N > 0)
N: 12LU
T: string
associative array T[X]: int[string]
T(value): int
X(key): string
associative array T[X]: string[int]
T(value): string
X(key): int
static array T[N]: short[8]
T(value): short
N(length): 8LU
other: int
```
#### Конструкция \_\_traits(keyWord, ...)
Большая часть \_\_traits, после ключегого слова, принимает выражение в качестве аргумента (или их список, разделённый запятыми), проверяет его результат на соответствие требованиям и возвращает булево значение, отражающее прохождение проверки. Выражения должны возвращать либо как таковой тип, либо значение типа. Другая часть принимает 1 аргумент и возвращает что-либо более информативное, нежели булево значение (в основном списки чего либо).
Проверяющие \_\_traits:
* compiles — валидно ли выражение
* isAbstractClass — абстрактные классы
* isArithmetic — арифметические типы (числа и перечисления)
* isAssociativeArray — ассоциативные массивы
* isFinalClass — финальные классы (от которых нельзя наследовать)
* isPOD — Plain Old Data — типы, которые можно инициализировать простым побайтным копированием (запрещены скрытые поля, деструкторы)
* isNested — вложенные типы (зависящие от контекста)
**Примеры**
```
class A { class B {} }
pragma(msg, __traits(isNested,A.B)); // true
```
```
void f1()
{
auto f2() { return 12; }
pragma(msg,__traits(isNested,f2)); // true
}
```
```
auto f1()
{
auto val = 12;
struct S { auto f2() { return val; } } // используется контекст f1
return S.init;
}
pragma(msg,__traits(isNested,typeof(f1()))); // true
```
* isFloating — числа с плавающей точкой (включая комплексные)
* isIntegral — целые числа
* isScalar — скалярные типы (числа, перечисления, указатели), хотя \_\_vector(int[4]) тоже является скалярным типом
* isStaticArray — статические массивы
* isUnsigned — целые беззнаковые числа
* isVirtualMethod — виртуальный метод (то что можно перегружить)
* isVirtualFunction — виртуальные функции (те, что лежат в таблице виртуальных функций)
* isAbstractFunction — абстрактная функция
* isFinalFunction — финальная функция
* isStaticFunction — статическая функция
* isOverrideFunction — перегруженная функция
* isRef — аргумент ссылка
* isOut — выходной аргумент ссылка
* isLazy — ленивый аргумент (вычисляемый по требованию)
* isSame — являются выражения одним и тем же
* hasMember — имеет ли класс/структура такое поле/метод, принимает первым аргументом тип (или объект типа), вторым строку с именем поля/метода
**Пример**
```
struct Foo { float value; }
pragma(msg, __traits(hasMember, Foo, "value")); // true
pragma(msg, __traits(hasMember, Foo, "data")); // false
```
**Про isFunction и разницу между isVirtualMethod и isVirtualFunction**Для наглядности написал небольшой тест, показывающий разницу
```
import std.stdio, std.string;
string test(alias T)()
{
string ret;
ret ~= is( typeof(T) == delegate ) ? "D " :
is( typeof(T) == function ) ? "F " : "? ";
ret ~= __traits(isVirtualMethod,T) ? "m|" : "-|";
ret ~= __traits(isVirtualFunction,T) ? "v|" : "-|";
ret ~= __traits(isAbstractFunction,T) ? "a|" : "-|";
ret ~= __traits(isFinalFunction,T) ? "f|" : "-|";
ret ~= __traits(isStaticFunction,T) ? "s|" : "-|";
ret ~= __traits(isOverrideFunction,T) ? "o|" : "-|";
return ret;
}
class A
{
static void stat() {}
void simple1() {}
void simple2() {}
private void simple3() {}
abstract void abstr() {}
final void fnlNOver() {}
}
class B : A
{
override void simple1() {}
final override void simple2() {}
override void abstr() {}
}
class C : B
{
final override void abstr() {}
}
interface I
{
void abstr();
final void fnl() {}
}
struct S { void func(){} }
void globalFunc() {}
void main()
{
A a; B b; C c; I i; S s;
writeln( " id T m|v|a|f|s|o|" );
writeln( "--------------------------" );
writeln( " lambda: ", test!(x=>x) );
writeln( " function: ", test!((){ return 3; }) );
writeln( " delegate: ", test!((){ return b; }) );
writeln( " s.func: ", test!(s.func) );
writeln( " global: ", test!(globalFunc) );
writeln( " a.stat: ", test!(a.stat) );
writeln( " a.simple1: ", test!(a.simple1) );
writeln( " a.simple2: ", test!(a.simple2) );
writeln( " a.simple3: ", test!(a.simple3) );
writeln( " a.abstr: ", test!(a.abstr) );
writeln( "a.fnlNOver: ", test!(a.fnlNOver) );
writeln( " b.simple1: ", test!(b.simple1) );
writeln( " b.simple2: ", test!(b.simple2) );
writeln( " b.abstr: ", test!(b.abstr) );
writeln( " c.abstr: ", test!(c.abstr) );
writeln( " i.abstr: ", test!(i.abstr) );
writeln( " i.fnl: ", test!(i.fnl) );
}
```
Результат
```
id T m|v|a|f|s|o|
--------------------------
lambda: ? -|-|-|-|-|-|
function: ? -|-|-|-|s|-|
delegate: D -|-|-|-|-|-|
s.func: F -|-|-|-|-|-|
global: F -|-|-|-|s|-|
a.stat: F -|-|-|-|s|-|
a.simple1: F m|v|-|-|-|-|
a.simple2: F m|v|-|-|-|-|
a.simple3: F -|-|-|-|-|-|
a.abstr: F m|v|a|-|-|-|
a.fnlNOver: F -|v|-|f|-|-|
b.simple1: F m|v|-|-|-|o|
b.simple2: F m|v|-|f|-|o|
b.abstr: F m|v|-|-|-|o|
c.abstr: F m|v|-|f|-|o|
i.abstr: F m|v|a|-|-|-|
i.fnl: F -|-|a|f|-|-|
```
isVirtualMethod возвращает true для всего, что можно перегрузить или уже было перегружено. Если функция не перегружалась, а изначально была final, она не будет виртуальным методом, но будет виртуальной функцией.
Насчёт знаков вопроса около лямбды и функции (литерал функционального типа) пояснить не могу, они по неведомой мне причине не прошли проверку ни на function ни на delegate.
Возвращающие что-либо:
* identifier — прнимает один аргумент, возвращает строку (аналогичен .stringof)
* getAliasThis — принимает тип или объект типа, если у типа есть alias this, возвращает их в качестве кортежа строк, иначе пустой кортеж (насколько я помню, сейчас поддерживается только один alias this для типа)
* getAttributes — принимает идентификатор, возвращает кортеж атрибутов, объявленных пользователем (UDA — user defined attributes)
**Пример**
```
enum Foo;
class Bar { @(42) @Foo void func() pure @nogc @property {} }
pragma(msg, __traits(getAttributes, Bar.func)); // tuple(42, (Foo)), @nogc и @property не входят в этот кортеж
@Foo float value;
pragma(msg, __traits(getAttributes, value)); // tuple((Foo)), работает не только с функциями
```
* getFunctionAttributes прнимает функцию, функциональный литерал, указатель на функцию, возвращает кортеж атрибутов в виде строк (UDA не входит сюда). Поддерживаются pure, nothrow, @nogc, @property, @system, @trusted, @safe и ref (если функция возвращает ссылку), для классов/структур так же есть const, immutable, inout и shared. Порядок следования зависит от реализации и на него нельзя полагаться.
**Пример**
```
enum Foo;
class Bar { @(42) @Foo void func() pure @nogc @property {} }
pragma(msg, __traits(getFunctionAttributes, Bar.func)); // tuple("pure", "@nogc", "@property", "@system")
```
* getMember — принимает те же аргументы, что и hasMember, эквивалентно записи через точку
**Пример**
```
class Bar { float value; }
Bar bar;
__traits(getMember, bar, "value") = 10; // тоже что и bar.value = 10;
```
* getOverloads — принимет класс/структуру/модуль и строку, совпадающую с именем функции внутри класса/структуры/модуля, возвращает кортеж всех перегрузок этой функции
**Пример**
```
import std.stdio;
class A
{
void foo( float ) {}
void foo( string ) {}
int foo( int ) { return 12; }
}
void main()
{
foreach( f; __traits(getOverloads, A, "foo") )
writeln( typeof(f).stringof );
}
```
Результат
```
void(float _param_0)
void(string _param_0)
int(int _param_0)
```
* getPointerBitmap — принимает тип, возвращает массив size\_t. Первое число это количество байт, занимаемое объектом этого типа, второе описывает расположение указателей, управляемых сборщиком мусора, внутри объекта такого типа
**Пример**
```
class A
{
// указатель на таблицу виртуальных функций, размер 1 слово, управляется GC: нет
// monitor, не отмечен, размер 1, управляется GC: нет
float val1; // размер 1, GC: нет
A val2; // размер 1, GC: да
void* val3; // размер 1, GC: да
void[] val4; // размер 2 {размер GC: нет,указатель GC: да}
void function() val5; // размер 1, GC: нет
void delegate() val6; // размер 2 {контекст GC: да,функция GC: нет}
}
enum bm = 0b101011000;
// ||||||||+- указатель на наблицу виртуальных функций
// |||||||+-- указатель на monitor
// ||||||+--- float val1
// |||||+---- A val2
// ||||+----- void* val3
// |||+------ void[] val4 размер
// ||+------- void[] val4 указатель
// |+-------- void function() val5 указатель
// +--------- void delegate() val6 контекст
// 0---------- void delegate() val6 указатель
static assert( __traits(getPointerBitmap,A) == [10*size_t.sizeof, bm] );
struct B { float x, y, z; }
static assert( __traits(getPointerBitmap,B) == [3*float.sizeof, 0] ); // в структуре B нет указателей, управляемых сборщиком мусора
```
* getProtection — принимает символ, возвращает строку, возможные варианты: «public», «private», «protected», «export» и «package»
* getVirtualMethods — принимает класс и строку с именем функции, работает практически как getOverloads, возвращает кортеж функций
* getVirtualFunctions — тоже, что и getVirtualMethods, за исключением того, что сюда входят final функции, которые ничего не перегружали
* getUnitTests — принимает класс/структуру/модуль, возвращает кортеж юниттестов как статических функций, UDA сохраняются
* parent — возвращает родительский символ, для переданного
**Пример**
```
import std.stdio;
struct B
{
float value;
void func() {}
}
alias F = B.func;
void main()
{
writeln( __traits(parent,writeln).stringof ); // module stdio
writeln( typeid( typeof( __traits(parent,F).value ) ) ); // float
}
```
* classInstanceSize — принимает класс, возвращает количество байт, занимаемое экземпляром класса
* getVirtualIndex — принимает функцию (метод класса), возвращает индекс (ptrdiff\_t) в таблице виртуальных функций класса. Если функция финальная и ничего не переопределяла вернёт -1
* allMembers — принимает тип и возвращает кортеж строк с именами всех полей и методов без повторений и встроенных свойств (sizeof, например), для классов включает так же поля и методы базовых классов
* derivedMembers — принимает тип и возвращает кортеж строк с именами всех полей и методов без повторений, без втроенных свойств и без полей и методов базовых классов (для классов)
#### Шаблонизация и ограничение сигнатуры
В простейшем исполнении шаблонная функция выглядит так
```
void func(T)( T val ) { ... }
```
Но так же у аргументов шаблонизации есть формы как и у конструкции is для проверки неявного приведения и даже для pattern-matching'а. Комбинируя это вместе с ограничениями сигнатуры можно создавать интересные комбинации перегруженных шаблонных функций:
```
import std.stdio;
void func(T:long)( T val ) { writeln( "number" ); }
void func(T: U[E], U, E)( T val ) if( is( E == string ) ) { writeln( "AA with string key" ); }
void func(T: U[E], U, E)( T val ) if( is( E : long ) ) { writeln( "AA with num key" ); }
void main()
{
func( 120 ); // number
func( ["hello": 12] ); // AA with string key
func( [10: 12] ); // AA with num key
}
```
#### Стандартная библиотека
В стандартной библиотеке по многим пакетам раскиданны template'ы, помогающие проверить поддерживает ли тип какое-либо поведение (например, необходимое для работы с функциями из этого пакета). Но есть пара пакетов, которые не реализуют какой-то специальный функционал, а предоставляют удобные обёртки над встроенными \_\_traits и дополнительные алгоритмы проверок соответствия.
* [std.traits](http://dlang.org/phobos/std_traits.html) — включает множество проверок и обёрток
* [std.typetuple](http://dlang.org/phobos/std_typetuple.html) — шаблоны для работы с кортежами типов
#### Итог
Комбинируя все эти подходы можно создавать невообразимо сложные и гибкие метапрограммные конструкции. Пожалуй в языке D реализована одна из самых гибких моделей метапрограммирования. Но всегда помните, что кто-то может потом читать этот код (может даже Вы сами) и разобраться в таких конструкциях будет очень проблематично. Всегда старайтесь соблюдать чистоту и больше комментируйте сложные моменты. | https://habr.com/ru/post/261349/ | null | ru | null |
# Выключка по ширине, или Убей «text-align: justify;»
Надеюсь этой записью открыть серию статей, посвящённых типографике в целом и веб-типографике в частности.
Логически следующая статья будет посвящена использованию разнообразных пробелов и разделительных интервалов (такой заказ был в комментариях к [статье о тире и дефисах](http://habrahabr.ru/blog/typography/36267.html) пользователя [besisland](https://habrahabr.ru/users/besisland/)).
Итак, тезис статьи: **«до тех пор, пока браузеры не имеют возможности динамически расставлять переносы в словах, вебмастеры должны забыть выключку по ширине как страшный сон»**.
Это значит, что нужно забыть CSS-конструкцию «`text-align: justify;`» и, если вы этого до сих пор не сделали, то выжечь калёным железом все воспоминания об «`align="justify"`».
Инь и ян типографики: ширина пробелов и правый край
---------------------------------------------------
Как показывает практика, неравномерность ширины межсловных пробелов в тексте отрицательно влияет на удобочитаемость уже в пределах одного абзаца (я подчёркиваю, именно «межсловных»).
Ровный правый край блока текста улучшает удобочитаемость на объёмах от половины стандартной страницы (при средней ширине строки), и только в случае однородности пробелов.
Таким образом, равномерность ширины пробелов на обычно коротких текстах в Интернете является гораздо более важной, чем выравнивание правого края.
На протяжении исторического развития публикации книг (от рукописей до компьютерных текстовых процессоров) внешний вид полосы текста зависел от двух параметров:
* подвижность литер, то есть, наличие обратной связи: можно ли исправлять уже написанный/набранный текст;
* возможность переноса части слова на новую строку, в ручном режиме либо автоматически.
В случае, если хотя бы одна из этих возможностей отсутствует, то одновременно невозможно удовлетворить требованию равномерности ширины пробелов и выравнивания правого края.
Рукописи и ксилография
----------------------
Подвижности литер нет (что написал, заново переписывать только с чистого листа, либо вырезать на новой деревяшке), возможность переноса — в «ручном» режиме.
При наличии равномерных пробелов (а для старых рукописей — при полном их отсутствии) обычно виден рваный правый край (хотя, кое-где он — почти ровный, в зависимости от почерка писца).* [Письмо](http://habrastorage.org/storage/851771cc/03d2b2dc/7924f4d9/89d967b5.jpg) из архива Диоскурида, военачальника Гераклеополиса, II в. до н.э.
* [Папирус](http://habrastorage.org/storage/6a6856e6/79fdb641/43390dc2/c142bf27.jpg) из Оксиринха, около II—I вв. до н.э.
* [Синайский кодекс](http://habrastorage.org/storage/0b83ffed/ec56711e/09ac2d7c/e55a1092.jpg), IV в.
* [Житие св. Кентигерна](http://habrastorage.org/storage/539fa3d2/6251f7d6/c8f551e4/09d98227.jpg), XII в.
Типографская печать (ручной набор, монотипы, линотипы)
------------------------------------------------------
Есть и подвижность литер (поподробнее о разгонке мы поговорим в будущей статье о пробелах), и возможность переноса в «ручном» режиме.
Одновременная равномерность пробелов и правого края стала достижима с самого начала книгопечатания, чем значительно улучшила читаемость книг.* [Библия](http://habrastorage.org/storage/e25e6ac2/aa850ca2/92de5be1/b78ef8ed.jpg) издания Гутенберга, XV в.
* [«Апостол»](http://habrastorage.org/storage/bc5dcfa3/b877c47b/9e71c455/9ca81d6d.jpg) издания Ивана Фёдорова, XVI в.
* [«Древо познания»](http://habrastorage.org/storage/cf8fd391/ef86f36f/293db3b1/63fecdcd.jpg) Раймунда Луллия, XVI в.
Печатная машинка
----------------
Снова нет подвижности литер, но переносы можно расставлять вручную.
При одинаковых пробелах имеем рваный правый край. Однако, при подготовке «самиздатовских» книг на печатной машинке многие пытались выравнивать правый край засчёт удвоения межсловных пробелов (множество примеров см. в библиотеке Мошкова). На мой взгляд, выглядит не ахти, особенно если учесть, что избавиться от «дорожек» и «лесенок» из пробелов внутри абзаца при такой вёрстке достаточно сложно.* [«Лекции о Гоголе…»](http://habrastorage.org/storage/79562087/46e868cf/d508d0b7/4d78e27a.jpg) Н. К. Кульмана
* [Текст рассказа «None Sing So Wildly»](http://habrastorage.org/storage/fab3f01c/29b51e51/79e48fde/af01dcf2.jpg) американского писателя Джеймса Джонса
* [Текст повести «The Devil’s Dream»](http://habrastorage.org/storage/9989f880/835f3b91/a00ab3c3/2ac2368d.jpg) Ли Маршалл Смит
* [«Свет угасшей звезды»](http://habrastorage.org/storage/b204d000/e862ab8f/4b14f330/fc73be41.jpg) Александра Бушкова
Современные текстовые процессоры
--------------------------------
Пытаются автоматически имитировать типографский процесс. Есть подвижность литер и возможность как автоматической расстановки переносов, так и ручной. Как ни удивительно, но даже в MS Word можно добиться приличного вида блока текста, выключенного по ширине, если в тексте расставить переносы.
Без переносов текст ужасен.
Браузеры
--------
Первый в истории тип носителя, имеющий подвижность литер, но не имеющий возможности расстановки переносов. Помимо этого, строка может иметь практически любую ширину (ведь хорошие дизайнеры предусматривают возможное изменение размера шрифта пользователем!).Теперь, чтобы совместить равномерность пробелов и выравнивание по ширине, браузеры практически должны стать интерактивными текстовыми процессорами: либо автоматически расставляя переносы в реальном времени на произвольных объёмах текста, либо адекватно обрабатывая «мягкие переносы» `` так же в реальном времени.
До тех пор, пока этого не произошло, в плане типографики браузер недалеко ушёл от печатной машинки. Осознавая как этот факт, так и тот факт, что в недалёком будущем технологии разовьются до нормальной обработки переносов, дизайнер должен временно отказаться от CSS-конструкции «`text-align: justify;`». Надеюсь, что от кода вида «`p align="justify"`» вы уже давно отказались, потому что [он является не рекомендуемым](http://www.w3.org/TR/html401/present/graphics.html#h-15.1.2) (deprecated) в HTML 4.01 и может в следующих версиях стандарта перейти в разряд «устаревшего» (obsolete).
И последний, самый сильный аргумент
-----------------------------------
Хабрахабр не использует выключку по ширине! :) | https://habr.com/ru/post/20653/ | null | ru | null |
# Нюансы коммерческой разработки на WordPress
Доброго времени суток, уважаемый читатель. Судьба сложилась так, что я один из тех, кто отвечает за разработку проектов интернет-агентства в любимом, для меня, городе Хабаровск. И хотел бы поведать о том, как мы сохраняем должное качество продукта для клиентов, при условии довольно низких бюджетов, в сравнении с центральной частью России, что сказывается на требованиях к скорости сборки проекта. И цель моя — сократить издержки на разработку и дальнейшее обслуживание, что выливается в необходимость как можно быстрей сделать сайт с как можно большим количеством редактируемых в админ-панели элементов.
По большей части информация будет «технического плана», касательно CMS Worpdress, «по верхушкам». Я рассказываю лишь про наш путь, для кого использование технологий, путей, приемов etc. вопрос религии — просьба воздержаться от холиваров. Приступим.
Для начала небольшое отступления. В общей своей массе, у нас именно, проекты делятся на несколько типов по принципу разработки:
* HTML шаблон с themeforest -> сборка на CMS;
* Дизайн -> верстка -> сборка на CMS;
* Разработка индивидуальных решений.
Сразу оговорюсь, что рассматривать в этой статье я буду только первых два пункта, ибо обобщить третий мне представляется довольно сложной задачей, т.к. *любимые/самые лучшие/все остальные плохие* технологии у каждого свои и в небольших городах бывает сложно найти разработчика хорошего уровня на RoR/Flask и иже с ними. И пробегусь по ним обзорно. Если возникнет интерес к этой теме — почему бы и не быть развернутой статье-туториалу «Как собрать сайт на WP за 4-8 часов, которым клиент будет доволен».
#### Почему Wordpress?
Низкие бюджеты и желание привносить в мир меньше энтропии обосновало выбор. Более подробно:
* Удобство админ-панели для клиентов. Я серьезно, после введения этой CMS все обучение заказчиков свелось к тому, что мы высылаем пароль администратора. Воспоминания о записи видео “Как создать новость”, “Как поменять телефон на сайте” перестали мне сниться.
* Скорость сборки сайта. Около 4-8 часов на проект это здорово. Конкурентное преимущество.
* Кривая обучения разработчиков для сборки проектов. Пока мой рекорд — 1.5 недели обучения с нуля (то есть аббревиатура HTML кажется заклинанием, вызывающим Сатану) до полноценной сборки сайта за срок, который меня устраивает.
* Красивые графики для клиентов с рейтингом CMS :)
* Freeware, нет необходимости приобретать лицензии.
И да, я не буду стучаться в вашу дверь с брошюрой в руках и говорить “Не хотите ли вы поговорить о WP?”. Просто мы используем эту CMS и об этом и есть заметка. Фактически здесь монолог в печатном формате, который я произношу всем новым веб-мастерам, приходящим к нам.
#### Какие нюансы следует учитывать при верстке проекта?
Считаю, что задумываться о нюансах сборки сайта следует уже на данном этапе. Здесь собрано немного общих и частных рекомендаций, возможно очевидных, исходящих из набора плагинов и сниппетов, которые использую я.
Шаблон должен легко разделяться на “шапку сайта”, собственно контент и “подвал”. Если необходимо скрывать некоторые элементы шапки/подвала — WP предоставляет довольно много замечательных функций-условий. (**is front page(), is\_404()** etc.). Если необходимо изменять внешний вид — CSS умеет, **body\_class()** имеется.
Когда верстаются различные меню, которые будут управляться через Внешний вид -> меню сайта, необходимо придерживаться следующей структуры:
```
* Пункт меню
* Пункт меню
+ Пункт меню
+ Пункт меню
* Пункт меню
```
Из нюансов здесь важно то, что подменю должны иметь css класс **sub-menu**. Это избавит вас от необходимости писать кастомный волкер при сборке сайта, для функции **wp\_nav\_menu($args)**;.
Буду как капитан очевидность, но все динамические позиции в верстке должны быть либо отдельным элементов (если телефон, то, к примеру **+ 7 XXX XXX** etc. без извращений), для дальнейшей замены плейсхолдера, либо быть похожи на следующую логическую структуру:
> Верстка до списка
>
> Верстка элемента списка
>
> …
>
> Верстка элемента списка
>
> Верстка после списка
Обязательно создать отдельное правило в CSS для контента, который клиенты вставляют через wysiwyg в админ-панели. Что-то вроде этого (пусть это будет LESS):
```
.user-content{
...
a{
&:hover{ ... };
&:active{ ... };
&:focus{ ... };
}
p{ ... }
table{
thead {
...
th { ... }
}
tbody {
tr{
...
td{ ... }
}
}
}
h1, h2, h3, h4, h5, h6, h7{ … }
h1{ ... }
...
h7{ ... }
ul{
...
li{
...
}
}
img{ … }
}
```
В дальнейшем убережет от звонков вида “Почему я вставила картинку и у меня все поехало!”
Если у вас есть на сайте галереи изображений (по три в ряд, по шесть в ряд etc.), то необходимо привести верстку этих галерей в верстку, которую генерирует WP шорткодом gallery. Или переопределить этот шорткод и сделать верстку просто придерживаясь правила “Верстка до списка, Верстка элемента списка, Верстка после списка”, если функционал WP по части количества колонок и прочего избыточен.
Верстка постраничной навигации, генерируемая WP, принимает примерно следующий вид:
```
[Предыдущая страница](#)
[1](#)
2
[3](#)
[Следующая страница](#)
```
Верстка «хлебных крошек» тривиальна. Либо ul li список, либо , разделенный " >> " и иже с ними.
Еще хочу сказать, что весь блок вышесказанного умещается в одну фразу — верстайте, стилизуя разметку, которую генерирует WP/плагины/сниппеты-функции и будет счастье.
#### Получили набор html/css/js файлов, что дальше?
В данный момент времени практика такова, что мы имеем репозиторий, который называем kosher\_wordpress, дабы на каждом проекте не устанавливать кучу плагинов каждый раз снова. Что в нем имеется и что, по моему мнению, на данный момент достаточно:
* Самая свежая версия WP.
* Не дефлотный пароль на администраторе ;).
* Билдер новых типов постов с кастомными полями из админ панели. Мы используем [Magic fields 2](https://wordpress.org/plugins/magic-fields-2/). Используется для создания элементов вида Список элементов -> Отдельная страница элемента. Шаблоны вида **archive-$type.php** и **single-$type.php**, или вывод, используя WP\_Query.
* Билдер новых полей для таксономии, использую [Tax-Meta-Class](https://github.com/bainternet/Tax-Meta-Class)
* Кастомизатор для экранов редактирования. Использую [Advanced СustomFields](http://www.advancedcustomfields.com/). Незаменим для следующего кейса. Имеется шаблон контактов, к примеру **tpl-contacts.php**, с прописанным внутри **Template Name: Шаблон страницы контактов**. И необходимо, чтобы при выборе этого шаблона в админ-панели, на странице редактирования контактов, появлялись дополнительные поля, такие как координаты карты, привязанная форма обратной связи etc. И тут он нам и помогает.
* Билдер форм перезвона, обратной связи, заказа, etc. [Contact Form 7](https://wordpress.org/plugins/contact-form-7/)
* Билдер глобальных настроек сайта. Используется для телефонов в шапке, соц.сетей и прочей информации такого типа. **Theme Options**.
* **Functions.php** с функциями, покрывающими практически весь оставшийся функционал:
+ Поддержка меню темой. **register\_nav\_menus();**
+ Поддержка миниатюр у постов. **add\_theme\_support ('post-thumbnails');**
+ Ресайз изображений, с поддержкой из меньшего->большее и кешированием. **resize\_image( $attach\_id = null, $img\_url = null, $width, $height, $crop = false )**
+ Генератор хлебных крошек. **the\_breadcrumb()**.
+ Генератор постраничной навигации. **wp\_corenavi($wp\_query)**
+ Кастомный волкер для wp\_nav\_menu() для расширения. **class My\_Walker extends Walker Nav Menu { *оригинальный код WP* }**
+ Задел для изменения шорткода галереи. **remove\_shortcode('gallery', 'gallery\_shortcode');add\_shortcode('gallery', 'my\_gallery\_shortcode');function my\_gallery\_shortcode($attr) {}**
+ Генератор постраничной навигации. **wp\_corenavi($wp\_query)**
* Файлик со сниппетами, для напоминания.
И вся сборка проекта сводится к следующему:
* Создание virtual host на компьютере
* git clone ...
* Импорт бд, ввод трех SQL команд, для того, чтобы сказать WP, какой у нас сейчас текущий URL ([gist](https://gist.github.com/tw3eX/8552746))
* Копирования сниппетов со второго монитора и наполнение верстки смыслом.
* Деплой на сервер и чашка кофе
Примерное содержание файлика со сниппетами:
```
php
/*
* Template Name: Шаблон главной
*/
?
php
/*
* Выше сниппет для кастомной темы на страницу.
*/
?
php
/*
* Инклуд файла header.php
*/
get_header();
?
php
/*
* Вывод контента страницы
*/
?
php if (have_posts()) : ?
php while (have_posts()) : the_post(); ?
php
/*
* Получение текущей миниатюры в главном цикле и ресайз ее, юрл изображения хранится в $image['url']
*/
$url = wp_get_attachment_url(get_post_thumbnail_id($post-ID));
$image = vt_resize(null, $url, 220, 220, true);
if (!$image['url']) $image['url'] = 'http://placehold.it/220x220&text=NO IMAGE';
?>
php the_title(); ?
php the_content(); ?
php endwhile; ?
php else: ?
php \_e('Sorry, no posts matched your criteria.'); ?
php endif; ?
php
/*
* Пример запроса WP_Query с паджинацией
*/
?
php
/* Берем текущую страницу и создаем параметры запроса*/
$paged = (get_query_var('paged')) ? get_query_var('paged') : 1;
$args = array(
'post_type' = 'news',
'posts_per_page' => '3',
'paged' => $paged
);
/* Делаем инстанс WP_Query */
$the_query = new WP_Query($args);
?>
php if ($the_query-have_posts()) : ?>
php while ($the_query-have_posts()) : $the_query->the_post(); ?>
php
/*
* Получение текущей миниатюры в кастомном запросе и ресайз ее, юрл изображения хранится в $image['url']
*/
$url = wp_get_attachment_url(get_post_thumbnail_id($the_query-post->ID));
$image = vt_resize(null, $url, 220, 220, true);
if (!$image['url']) $image['url'] = 'http://placehold.it/220x220&text=NO IMAGE';
?>
php echo $image['url']; ?
php
/*
* Вывод заголовка и контента, с читать далее (в визуальном редакторе тег more).
* Если не работает, то после $the_query-the_post(); выше втыкаем global $more;$more=0;
* Или с настройками WP шаманим по части вывода анонсов.
*/
?>
php the_title(); ?
php the_content('Читать далее...'); ?
php endwhile; ?
php
/*
* Показываем паджинацию
*/
wp_corenavi($the_query);
?
php
/*
* Сбрасываем запрос
*/
wp_reset_postdata();
?
php else: ?
php \_e('Sorry, no posts matched your criteria.'); ?
php endif; ?
php
/*
* Инклуд файла footer.php
*/
get_footer();
?
```
По данному алгоритму собрал за последний год уже более сотни сайтов, в среднем по времени уходит от 1 до 3 рабочих дней, в зависимости от сложности дизайна и различных моушен-эффектов. Сама сборка занимает около 4-8 часов. Возможно это и не результат, но сравнивать мне пока не с чем, буду благодарен диалогу. | https://habr.com/ru/post/252393/ | null | ru | null |
# COVID-19: как перестать читать новости и начать анализировать данные
Привет, Хабр! Где-то месяц назад у меня появилось чувство постоянного беспокойства. Я стал плохо есть, еще хуже спать и постоянно читать-смотреть-слушать тонну новостей о пандемии. Исходя из них коронавирус то ли захватывал, то ли освобождал нашу планету, являлся то ли заговором ~~масонов~~ мировых правительств, а то ли местью панголина, вирус то ли угрожал всем и сразу, а то ли персонально мне и моему коту…
Сотни статей, постов в соцсетях, youtube-telegram-instagram-tik-tok (да уж простите) контента разной степени содержательности (и сомнительности) не приводили меня ни к чему, кроме уже описанного на Хабре [разрушения мозга](https://habr.com/ru/post/496998/) и еще большему чувству беспокойства.
Но в один день я ~~купил гречки~~ решил со всем этим нужно покончить. Как можно скорее!
**UPD**: добавил секцию 'Результат'.
> ### Минутка заботы от НЛО
>
>
>
> В мире официально объявлена пандемия COVID-19 — потенциально тяжёлой острой респираторной инфекции, вызываемой коронавирусом SARS-CoV-2 (2019-nCoV). На Хабре много информации по этой теме — всегда помните о том, что она может быть как достоверной/полезной, так и наоборот.
>
>
>
> #### Мы призываем вас критично относиться к любой публикуемой информации
>
>
>
> **Официальные источники*** [Cайт Министерства здравоохранения РФ](https://covid19.rosminzdrav.ru/)
> * [Cайт Роспотребнадзора](https://www.rospotrebnadzor.ru/about/info/news_time/news_details.php?ELEMENT_ID=13566)
> * [Сайт ВОЗ (англ)](https://www.who.int/emergencies/diseases/novel-coronavirus-2019)
> * [Сайт ВОЗ](https://www.who.int/ru/emergencies/diseases/novel-coronavirus-2019)
> * Сайты и официальные группы оперативных штабов в регионах
>
>
>
> Если вы проживаете не в России, обратитесь к аналогичным сайтам вашей страны.
>
> Мойте руки, берегите близких, по возможности оставайтесь дома и работайте удалённо.
>
>
>
> Читать публикации про: [коронавирус](https://habr.com/ru/search/?target_type=posts&q=%5B%D0%BA%D0%BE%D1%80%D0%BE%D0%BD%D0%B0%D0%B2%D0%B8%D1%80%D1%83%D1%81%5D&order_by=date) | [удалённую работу](https://habr.com/ru/search/?target_type=posts&q=%5B%D1%83%D0%B4%D0%B0%D0%BB%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F%20%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%B0%5D&order_by=date)
Мне нужен был план действий чуть более осмысленный, чем тот, который у меня был до этого.
Все что мне нужно было это найти данные. Достоверные, полные, актуальные.
К моей радости это оказалось сделать значительно легче, чем представлялось мне, когда я осознал эту задачу.
Мой план:
* [+] найти достоверные, полные, актуальные данные о распространении COVID-19 в машиночитаемом формате, [1, 3]
* [+] читать статьи, в которых ни слова (почти) про COVID-19, а вместо этого описана «математика» распространения вирусных заболеваний,
* [+] участвовать в соревнованиях, где участники пытаются предсказать скорость распространения коронавируса [2],
* [+] сделать пару совершенно провальных попыток почитать релевантные исследования в области современно биологии и медицины,
* [-] перестать сраться в комментах к постам по COVID-19 в соцсетях,
* [+] собирать полученные знания в github репозиторий, открытый миру [3].
По прошествии месяца со дня формирования плана я выявил у него минимум один несомненный плюс – он оказался исполнимым. Но этот пост не о том, как пользоваться поисковой строкой для поиска нужного материала, а о том, что было дальше после реализации плана.
Вскоре я занялся анализом сложившейся ситуации. Ну как занялся – мне пришлось – стало ясно, что очень часто подходы, которые применяются меня не устраивали по ряду причин, о которых ниже.
**Код для загрузки данных**Загружаем данные о распространении COVID-19:
```
#'
#' Load COVID-19 spread: infected, recovered, and fatal cases
#' Source: https://github.com/CSSEGISandData/COVID-19/tree/master/csse_covid_19_data/csse_covid_19_time_series
#'
load_covid_spread <- function() {
require(dplyr)
require(data.table)
require(purrr)
require(tidyr)
load_time_series <- function(.case_type) {
path_pattern <- "https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_%s_global.csv"
fread(sprintf(path_pattern, .case_type)) %>%
rename(country = `Country/Region`) %>%
select(-c(`Province/State`, Lat, Long)) %>%
group_by(country) %>%
summarise_if(is.numeric, sum) %>%
ungroup %>%
gather(key = "date", value = "n", -country) %>%
mutate(date = mdy(date))
}
dt <- load_time_series("confirmed") %>% rename(confirmed_n = n) %>%
inner_join(
load_time_series("recovered") %>% rename(recovered_n = n),
by = c("country", "date")
) %>%
inner_join(
load_time_series("deaths") %>% rename(deaths_n = n),
by = c("country", "date")
)
stopifnot(nrow(dt) > 0)
return(dt)
}
spread_raw <- load_covid_spread()
spread_raw %>% sample_n(10)
```
Загружаем данные о популяции стран:
```
#'
#' Load countries stats
#' Source: https://ods.ai/competitions/sberbank-covid19-forecast
#'
load_countries_stats <- function() {
require(dplyr)
require(magrittr)
dt <- fread("https://raw.githubusercontent.com/codez0mb1e/covid-19/master/data/countries.csv")
dt %<>%
select(-c(iso_alpha2, iso_numeric, name, official_name))
stopifnot(nrow(dt) > 0)
return(dt)
}
countries_raw <- load_countries_stats()
countries_raw %>% sample_n(10)
```
Предобработка данных:
```
data <- spread_raw %>%
# add country population
inner_join(
countries_raw %>% transmute(ccse_name, country_iso = iso_alpha3, population) %>% filter(!is.na(country_iso)),
by = c("country" = "ccse_name")
) %>%
# calculate active cases
mutate(
active_n = confirmed_n - recovered_n - deaths_n
) %>%
# calculate cases per 1M population
mutate_at(
vars(ends_with("_n")),
list("per_1M" = ~ ./population*1e6)
)
## Calculte number of days since...
get_date_since <- function(dt, .case_type, .n) {
dt %>%
group_by(country) %>%
filter_at(vars(.case_type), ~ . > .n) %>%
summarise(since_date = min(date))
}
data %<>%
inner_join(
data %>% get_date_since("confirmed_n", 0) %>% rename(since_1st_confirmed_date = since_date),
by = "country"
) %>%
inner_join(
data %>% get_date_since("confirmed_n_per_1M", 1) %>% rename(since_1_confirmed_per_1M_date = since_date),
by = "country"
) %>%
inner_join(
data %>% get_date_since("deaths_n_per_1M", .1) %>% rename(since_dot1_deaths_per_1M_date = since_date),
by = "country"
) %>%
mutate_at(
vars(starts_with("since_")),
list("n_days" = ~ difftime(date, ., units = "days") %>% as.numeric)
) %>%
mutate_at(
vars(ends_with("n_days")),
list(~ if_else(. > 0, ., NA_real_))
)
```
Настройки для графиков:
```
theme_set(theme_minimal())
lab_caption <- paste0(
"Data source: Novel Coronavirus (COVID-19) Cases provided by Johns Hopkins University Center for Systems Science. \n",
sprintf("Last updated: %s. ", format(max(data$date), '%d %B, %Y')),
"Source code: github.com/codez0mb1e/covid-19"
)
filter_countries <- function(dt) dt %>% filter(country_iso %in% c("KOR", "ITA", "RUS", "CHN", "USA"))
```
Абсолютные числа
----------------
*Проблема*: абсолютное количество случаев заболевания как ключевой показатель.
*Мотивация*: если брать абсолютное количество заболевших, то деревня, в которой из 100 человек заболело 50, в сотни раз лучше Рима (к примеру) в смысле эпидемиологической обстановки.
*Решение*: отображать долю населения страны (города), которая имеет заболевание.
Проведем эксперимент: построим графики зависимости количества инфицированных по времени.
**Код построения графика**
```
ggplot(data %>% filter_countries, aes(x = date)) +
geom_col(aes(y = confirmed_n), alpha = .9) +
scale_x_date(date_labels = "%d %b", date_breaks = "7 days") +
facet_grid(country ~ .) +
labs(x = "", y = "# of cases",
title = "COVID-19 Spread (over time)",
caption = lab_caption) +
theme(plot.caption = element_text(size = 8))
```
В странах, где не набралось большого количества заболевших по сравнению с США, невозможно разобрать ничего: ни роста, ни падения, ни уж в тем более, переломных моментов в пандемии населения страны. Прологарифмируем количество заболевших, в надежде увидеть что-то, но станет, как будто у всех около 100K заболеваний.
**Код построения графика**
```
ggplot(data %>% filter_countries, aes(x = date)) +
geom_col(aes(y = confirmed_n), alpha = .9) +
scale_x_date(date_labels = "%d %b", date_breaks = "7 days") +
scale_y_log10() +
facet_grid(country ~ .) +
labs(x = "", y = "# of cases",
title = "COVID-19 Spread (over time)",
caption = lab_caption) +
theme(plot.caption = element_text(size = 8))
```
Теперь то же самое, только с количеством заболевших на 1 миллион населения.
**Код построения графика**
```
ggplot(data %>% filter_countries, aes(x = date)) +
geom_col(aes(y = confirmed_n_per_1M), alpha = .9) +
scale_x_date(date_labels = "%d %b", date_breaks = "7 days") +
facet_grid(country ~ .) +
labs(x = "", y = "# of cases per 1M",
subtitle = "Infected cases per 1 million popultation",
title = "COVID-19 Spread (over time)",
caption = lab_caption) +
theme(plot.caption = element_text(size = 8))
```
И в логарифмической шкале:
**Код построения графика**
```
ggplot(data %>% filter_countries, aes(x = date)) +
geom_col(aes(y = confirmed_n_per_1M), alpha = .9) +
scale_x_date(date_labels = "%d %b", date_breaks = "7 days") +
scale_y_log10() +
facet_grid(country ~ .) +
labs(x = "", y = "# of cases per 1M",
subtitle = "Infected cases per 1 million popultation",
title = "COVID-19 Spread (over time)",
caption = lab_caption) +
theme(plot.caption = element_text(size = 8))
```
Я думаю, не надо указывать насколько лучше стали видны «тихие» гавани и страны, где с эпидемиологической обстановкой не так спокойно.
Точка отсчета
-------------
*Проблема*: при сравнении эпидемиологической обстановки использовать дату обнаружения вируса в стране (или еще хуже в Китае) в качестве точки отсчета.
*Мотивация*: эффект низкой базы (был один заболевший, стало 3, рост +200%); пропускаем момент, когда эпидемия в стране приняла характер пандемии.
*Решение*: используем даты, когда >1 инфицированного на миллион населения страны, >0.1 погибшего на миллион населения, как точки отчета.
Аналогично посмотрим на динамику увеличения количества случаев заболевания, начиная с первого обнаруженного случая.
**Код построения графика**
```
ggplot(
data %>% filter_countries %>% filter(!is.na(since_1st_confirmed_date_n_days)),
aes(x = since_1st_confirmed_date_n_days)
) +
geom_col(aes(y = confirmed_n), alpha = .9) +
scale_y_log10() +
facet_grid(country ~ .) +
labs(x = "# of days since 1st infected case", y = "# of cases",
subtitle = "Infected cases since 1st infected case",
title = "COVID-19 Spread",
caption = lab_caption) +
theme(plot.caption = element_text(size = 8))
```
И динамику увеличения количества заболевших на 1 миллион населения, начиная с момента, когда у нас появился минимум 1 инфицированный на миллион населения.
**Код построения графика**
```
ggplot(
data %>% filter_countries %>% filter(!is.na(since_1_confirmed_per_1M_date_n_days)),
aes(x = since_1_confirmed_per_1M_date_n_days)
) +
geom_col(aes(y = confirmed_n_per_1M), alpha = .9) +
scale_y_log10() +
xlim(c(0, 55)) +
facet_grid(country ~ .) +
labs(x = "# of days since 1 infected cases per 1M", y = "# of cases per 1M",
title = "COVID-19 Spread",
subtitle = "Since 1 infected cases per 1 million popultation",
caption = lab_caption) +
theme(plot.caption = element_text(size = 8))
```
Китай и Южная Корея значительно присели, виден рост заболевших в России и тренды на «успокоение» ситуации в Италии и США.
Кого считаем
------------
*Проблема*: для решения задачи «когда это все закончится» строим прогноз на количестве инфицированных.
*Мотивация*: выздоровевшие пациенты и умершие уже никого не заразят, никто из-за них уже не ляжет в больницу.
*Решение*: строим прогнозы на количестве активных случаев (инфицированные случаи минус сумма смертельных случаев и вылеченных).
Построим график, где отобразим случаи заражения, выздоровления, смертельные случаи и количество активных случаев (синяя линия).
**Код построения графика**
```
plot_data <- data %>%
filter_countries %>%
filter(!is.na(since_1_confirmed_per_1M_date_n_days)) %>%
mutate(
confirmed_n_per_1M = confirmed_n_per_1M,
recovered_n_per_1M = -recovered_n_per_1M,
deaths_n_per_1M = -deaths_n_per_1M
) %>%
select(
country, since_1_confirmed_per_1M_date_n_days, ends_with("_n_per_1M")
) %>%
gather(
key = "case_state", value = "n_per_1M", -c(country, since_1_confirmed_per_1M_date_n_days, active_n_per_1M)
)
ggplot(plot_data, aes(x = since_1_confirmed_per_1M_date_n_days)) +
geom_col(aes(y = n_per_1M, fill = case_state), alpha = .9) +
geom_line(aes(y = active_n_per_1M), color = "#0080FF", size = .25) +
scale_fill_manual(element_blank(),
labels = c("confirmed_n_per_1M" = "Infected cases", "recovered_n_per_1M" = "Recovered cases", "deaths_n_per_1M" = "Fatal cases"),
values = c("confirmed_n_per_1M" = "grey", "recovered_n_per_1M" = "gold", "deaths_n_per_1M" = "black")) +
xlim(c(0, 55)) +
facet_grid(country ~ ., scales = "free") +
labs(x = "# of days since 1 infected cases per 1M", y = "# of cases per 1M",
title = "COVID-19 Spread by Countries",
subtitle = "Active cases trend since 1 infected cases per 1 million popultation. \nBlue line - infected cases minus recovered and fatal.\nNegative values indicate recovered and fatal cases.",
caption = lab_caption) +
theme(
legend.position = "top",
plot.caption = element_text(size = 8)
)
```
Из графика очевидно, насколько важна информация о количестве активных случаев для полного понимания развития эпидемиологической обстановки в соответствующей стане.
Все это было давно
------------------
*Проблема*: количество инфицированных случаев сегодня лишь фиксирование факта того, что было минимум неделю назад (скорее всего около 10 дней назад [я не знаю, как посчитать эту цифру]).
*Решение*: моделирование на данных недельной давности, проверка предсказания на сегодня; поиск инсайтов (например, отношение количества обнаруженных в день кейсов к количеству сделанных в этот день тестов). Простого решения, наверное, здесь нет.
Попробуем с помощью авторегрессионной модели ARIMA заглянуть на неделю вперед:
**Моделирование с помощью ARIMA**
```
forecast_cases <- function(.country, .after_date, .forecast_horizont, .fun, ...) {
dt <- data %>%
# filter rows and cols
filter(
country == .country &
date < .after_date
) %>%
# convert to time-series
arrange(date) %>%
select(active_n_per_1M)
dt %>%
ts(frequency = 7) %>%
# ARIMA model
.fun(...) %>%
# forecast
forecast(h = .forecast_horizont)
}
forecast_horizont <- 7
after_date <- max(data$date) + days()
countries_list <- c("Belgium", "France", "Italy", "Netherlands", "Norway", "Portugal", "Spain", "Switzerland", "US", "Russia", "China", "Korea, South")
pred <- countries_list %>%
map_dfr(
function(.x) {
m <- forecast_cases(.x, after_date, forecast_horizont, auto.arima)
n_days_max <- max(data[data$country == .x, ]$since_1_confirmed_per_1M_date_n_days, na.rm = T)
tibble(
country = rep(.x, forecast_horizont),
since_1_confirmed_per_1M_date_n_days = seq(n_days_max + 1, n_days_max + forecast_horizont, by = 1),
pred = m$mean %>% as.numeric %>% round %>% as.integer,
data_type = "Forecast"
)
}
)
plot_data <- data %>%
filter(country %in% countries_list) %>%
transmute(
country, active_n_per_1M, since_1_confirmed_per_1M_date_n_days,
data_type = "Historical data"
) %>%
bind_rows(
pred %>% rename(active_n_per_1M = pred)
) %>%
mutate(
double_every_14d = (1 + 1/14)^since_1_confirmed_per_1M_date_n_days, # double every 2 weeks
double_every_7d = (1 + 1/7)^since_1_confirmed_per_1M_date_n_days, # double every week
double_every_3d = (1 + 1/3)^since_1_confirmed_per_1M_date_n_days, # double every 3 days
double_every_2d = (1 + 1/2)^since_1_confirmed_per_1M_date_n_days # double every 2 days
)
active_n_per_1M_last <- plot_data %>%
group_by(country) %>%
arrange(desc(since_1_confirmed_per_1M_date_n_days)) %>%
filter(row_number() == 1) %>%
ungroup
plot_data %<>%
left_join(
active_n_per_1M_last %>% transmute(country, active_n_per_1M_last = active_n_per_1M, since_1_confirmed_per_1M_date_n_days),
by = c("country", "since_1_confirmed_per_1M_date_n_days")
)
```
**Код построения графика**
```
ggplot(plot_data, aes(x = since_1_confirmed_per_1M_date_n_days)) +
geom_line(aes(y = double_every_7d), linetype = "dotted", color = "red", alpha = .65) +
geom_line(aes(y = double_every_3d), linetype = "dotted", color = "red", alpha = .75) +
geom_line(aes(y = double_every_2d), linetype = "dotted", color = "red", alpha = .85) +
geom_line(aes(y = active_n_per_1M, color = country, linetype = data_type), show.legend = T) +
geom_text(aes(y = active_n_per_1M_last + 20, label = country, color = country),
hjust = 0.5, vjust = 0, check_overlap = T, show.legend = F, fontface = "bold", size = 3.6) +
annotate(geom = "text", label = "Cases double \n every 2 days", x = 17, y = 1550, vjust = 0, size = 3.1) +
annotate(geom = "text", label = "...every 3 days", x = 25, y = 1800, vjust = 0, size = 3.1) +
annotate(geom = "text", label = "...every week", x = 50, y = 1500, vjust = 0, size = 3.1) +
scale_linetype_manual(values = c("longdash", "solid")) +
xlim(c(10, 55)) +
ylim(c(0, max(plot_data$active_n_per_1M))) +
labs(x = "# of days since 1 infected cases per 1M", y = "# of cases per 1M",
title = "COVID-19 Spread by Countries",
subtitle = "Active cases trend since 1 infected cases per 1 million popultation.",
caption = lab_caption) +
theme(
legend.position = "bottom",
legend.title = element_blank(),
plot.caption = element_text(size = 8)
)
```
Удивительный перелом в борьбе с COVID-19 демонстрирует Швейцария и Бельгия, в Португалии дела обстоят не сильно лучше, чем в США, у России есть плохой шанс расти быстрее, чем многие европейцы, которые показаны на графике.
Заключение
----------
Не умаляю значения использования абсолютных величин количества заболевших, а также дат на графиках, но для понимания динамики развития заболевания в конкретном регионе плотность активных заболевших, а также выбор правильной даты отсчета, является критичной.
*Без учета размера популяции* региона мы будем видеть просто страны с большим населением и пропускать локальные очаги вспышек инфекций. *Без учета количества активных заболеваний* (а не просто всех инфицированных) в топах возможно будут регионы, которые уже справились со вспышкой (как Китай). *Неправильный выбор точки (даты) отсчета* для сравнения эпидемиологической обстановки между странами также будет давать ложное преставление относительно течения заболеваний в сравниваемых регионах.
Результат
---------
Сравним 2 подхода для оценки и предсказания развития эпидемиологической обстановки в стране.
**Количество заболевших по времени** (наивный подход):
**Код построения графика**
```
ggplot(data %>% filter(country %in% countries_list), aes(x = date)) +
geom_line(aes(y = confirmed_n, color = country), show.legend = T) +
scale_x_date(date_labels = "%d %b", date_breaks = "7 days") +
labs(x = "", y = "# of cases",
title = "COVID-19 Spread by Country",
subtitle = "Infected cases over time",
caption = lab_caption) +
theme(
legend.position = "bottom",
legend.title = element_blank(),
plot.caption = element_text(size = 8)
)
```
**Плотность заболевших в популяции к количеству дней после 1 случая заражения на 1 млн населения** (подход, описанный в данном посте):
*Выбор за Вами!*
**Воспроизвести результат**, поэкспериментировать с другими странами, покопаться в исходниках можно [здесь](https://github.com/codez0mb1e/covid-19/blob/master/src/covid-19-yaaa.Rmd).
### References
1. [COVID-19 Data Repository by Johns Hopkins CSSE](https://github.com/CSSEGISandData/COVID-19), GitHub.
2. Соревнования по прогнозированию: [Kaggle COVID19 Global Forecasting](https://www.kaggle.com/c/covid19-global-forecasting-week-4), [Sberbank COVID-19 Forecast](https://ods.ai/competitions/sberbank-covid19-forecast).
3. [Код, материалы, первоисточники поста](https://github.com/codez0mb1e/covid-19/), GitHub.
*Берегите себя!* | https://habr.com/ru/post/497340/ | null | ru | null |
# Unity Editor Adventures: Сериализованная Матрёшка
### Краткое вступление
Как правило, для того чтобы добраться до интересующего нас поля сериализованного свойства, мануальная терапия советует нам использовать метод FindPropertyRelative(), в который прокидывается название переменной.
По определённым причинам такой подход не всегда удобен. Причины могут быть самыми разнообразными. Например, название переменной может смениться, нам кровь из носу нужен доступ к несериализованному свойству, нам необходимо иметь доступ к геттерам-сеттерам или вообще методам сериализованного объекта. Не будем задавать вопросов «зачем вам это вообще нужно» и «почему вы не могли обойтись традиционными путями». Положим, нужно – и всё тут.
Итак, давайте же разберёмся как из сериализованного свойства получить объект, с которым мы работаем, а также все его родительские объекты, и не навернуться по дороге сериализации, полной подводных камней.
**Внимание.** Данная статья подразумевает, что вы уже умеете работать с UnityEditor’ом, хотя бы раз писали кастомные PropertyDrawer’ы и хотя бы в общих чертах понимаете, чем сериализованное свойство отличается от сериализованного объекта.
### Путь сериализации
Для начала расставим все точки над O.
В самом примитивном случае у нас есть некий класс-наследник от MonoBehaviour, и у него есть некое поле, принадлежащее сериализованному классу, очевидно не являющемуся наследником от священной юнитевской коровы а.к.а. UnityEngine.Object.
```
public class ExamplePulsar : MonoBehaviour
{
...
[Space][Header("Example Sandbox Inspector Field")]
public SandboxField sandboxField;
...
}
```
В коде выше SandboxField – это класс с аттрибутом Serializable.
Получить доступ к хозяйскому MonoBehaviour’у не составляет проблем:
```
UnityEngine.Object serializationRoot = property.serializedObject.targetObject;
```
По желанию можно взять его через as, но нам сейчас это не нужно. Нас интересует само сериализованное поле, чтобы его отрисовать со всем блекджеком как на рисунке ниже.
Путь сериализации мы можем взять следующим образом:
```
string serializationPath = property.propertyPath;
```
В нашем случае путь сериализации будет состоять из одного нашего поля и вернёт “sandboxField”, от которого нам пока что ни холодно, ни жарко, поскольку для первого уровня вложенности нам необходимо знать только имя переменной (которое, впрочем, нам и вернули).
Обратите внимание, родительского MonoBehaviour в пути нет. Сейчас это неважно, но станет важно, когда мы начнём разбирать матрёшку, выглядящую примерно вот так:
> nestedClassVariable.exampleSandboxesList.Array.data[0].evenMoreNested.Array.data[0]
Чтобы не навернуться впоследствии, когда свойства будут вложенными, загодя сделаем следующее:
```
string[] path = property.propertyPath.Split('.');
```
Теперь мы имеем все узлы пути сериализации. Но в самом примитивном случае нам нужен только нулевой узел. Возьмём его:
```
string pathNode = path[0];
```
Включим немного рефлексии и получим отсюда само поле:
```
Type objectType = serializationRoot.GetType();
FieldInfo objectFieldInfo = objectType.GetField(pathNode);
object field = objectFieldInfo.GetValue(serializationRoot);
```
Оставим за кадром вопрос быстродействия этой затеи. Для небольшого количества таких полей и малой вложенности затраты на рефлексию будут существенно меньше, чем на всё то, что происходит под капотом UnityEditor’a за время отрисовки. Если хотите пруфов – на гитхабе у разрабов Unity есть такая интересная штука, UnityCsReference, посмотрите на досуге, как реализована отрисовка ObjectField, например.
Собственно, на этом ~~ещё не (ха-ха)~~ всё. Мы получили поле, мы довольны, мы можем творить с ним что вздумается и даже попытаться написать собственный UnityEvent со всеми кнопочками и важными действиями, затрагивающими исключительно наше поле, независимо от того, на каком объекте оно висит.
По крайней мере, пока оно висит в корне этого объекта, всё будет хорошо, а вот дальше – уже не очень. Вниз по пути сериализации нас ждут массивы и всякие списки, чьё главное желание – подгадить нам в тапки, своевременно изменив количество элементов в большую сторону. Но чёрт бы с этим, нам бы сначала подкопаться под сам массив.
**Наша цель – устойчивость к вот таким матрёшкам**
Если бы у нас в пути сериализации не было массивов, задача решалась бы тривиально: мы бы в цикле перебирали узлы сериализации, пока не дошли бы до конца цепочки. Что-то вроде нижеследующего кода:
```
object currentObject = serializationRoot;
for (int i = 0; i < directSearchDepth; i++)
{
string pathNode = path[i];
Type objectType = currentObject.GetType();
FieldInfo objectFieldInfo = objectType.GetField(pathNode);
object nextObject = objectFieldInfo.GetValue(currentObject);
currentObject = nextObject;
}
return currentObject;
```
Здесь у нас ждут сразу две неприятные новости. Начну со второй.
Шаг со взятием nextObject может внезапно нам вернуть null вместо ожидаемого объекта. Обычно это случается, когда мы впервые создаём родительский объект в инспекторе, и путь сериализации уже существует, а соответствующее ему поле – нет (это нам ещё дальше доставит приятностей).
На этот случай нам неплохо бы сразу дописать выход из метода с возвращением null:
```
object nextObject = objectFieldInfo.GetValue(currentObject);
if (nextObject == null) return null;
currentObject = nextObject;
```
«Погодите! – скажете вы. – А что делать тогда в OnGUI, если нам вернули нуль?»
Ответ: ничего. В буквальном смысле ничего. Просто сделать return и таким образом пропустить этот шаг отрисовки, дождавшись, пока поле создастся. Ничего страшного от этого не произойдёт.
```
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
SandboxField sandboxField = GetTarget(property);
if (sandboxField == null) return;
…
}
```
здесь GetTarget() – соответствующая функция, берущая сериализованный объект из проперти.
Кстати, я посоветую брать интересующее нас поле не здесь, а в GetPropertyHeight. Это понадобится на тот случай, если мы будем писать сворачивающиеся-разворачивающиеся поля с разным размером в зависимости от содержимого. GetPropertyHeight() вызывается до OnGUI(), так что если мы возьмём поле там и запишем его в поле нашего PropertyDrawer’a, то нам не придётся брать его повторно в OnGUI.
Обратите внимание, что экземпляр кастомного PropertyDrawer’a создается один для отрисовки всех в данный момент видимых сериализованных свойств, и в него по очереди сверху-вниз кидаются новые свойства. Это стоит учесть, чтобы не напортачить с вычислением высоты очередного свойства, иначе можете получить неприятную ситуацию, когда у вас по нажатию на foldout разворачивается не то поле, которое вы ожидаете.
Также всю мишуру, которая отвечает за отображение поля в редакторе и которую вы хотите сериализовать, сериализовать вам стоит на стороне сериализуемого класса, а не PropertyDrawer’a, а для верности – обнести скобками условной компиляции, чтобы весь этот испанский стыд не попытался пойти в билд:
```
[Serializable]
public class SandboxField
{
…
#if UNITY_EDITOR
public bool editorFoldout;
#endif
…
}
```
Ещё один подводный камень, который нас здесь поджидает: все созданные через эдитор поля плевать хотели на конструктор класса и на значения по умолчанию, заданные в классе. Если вы сделаете, например, вот так (пример из моего проекта, где это было значение узлов водяной поверхности):
```
[SerializeField]private int m_nodesPerUnit = 5;
```
Это значение будет проигнорировано сериализацией в упор, как только вы добавите новый элемент в список. Звать на помощь конструктор не менее бесполезно: всё, что вы там понаписали, будет проигнорировано. Новый объект гол как сокол, все его значения – действительно значения по умолчанию, вот только не те, которые вы хотите там увидеть, а всякие null, false, 0, Color.clear и прочие непотребные вещи.
**Костыль в мясо**
Есть тривиальный костыль. Создаём класс NonUnitySerializableClass, от которого наследуем все наши сериализованные плюшки. В самом классе делаем виртуальную функцию, DefaultEditorObject(), которую при необходимости перегружаем.
Дальше пишем что-то вроде:
```
public abstract class NonUnitySerializableClass
{
protected virtual void DefaultEditorObject()
{
// virtually do nothing
}
[SerializeField]private bool validated = false;
public void EditorCreated(bool force = false)
{
if (validated && !force) return;
DefaultEditorObject();
validated = true;
}
public NonUnitySerializableClass()
{
EditorCreated(true);
}
}
```
В дальнейшем просто переписываем по необходимости для наследников DefaultEditorObject(), чтобы задать дефолтные значения, а к EditorCreated стучимся при валидации полученного поля.
Результат починки: адекватная обработка значений только что созданного объекта.
Вернёмся к нашим баранам, а точнее – массивам. Другая проблема, которая может возникнуть на ещё более раннем этапе, кроется вот в этой строчке:
```
FieldInfo objectFieldInfo = objectType.GetField(pathNode);
```
Правая часть может вернуть нам нуль, если напорется на массив в пути сериализации (причём массивом “Array” будет любой объект IList). Неприятно.
Что делать? ~~Постараться не попадать в такие ситуации~~ писать обработчик:
```
for (int i = 0; i < pathNode.Length; i++)
{
string pathNode = path[i];
Type objectType = currentObject.GetType();
FieldInfo objectFieldInfo = objectType.GetField(pathNode);
if (objectFieldInfo == null)
{
if (pathNode == "Array")
{
i++;
string nextNode = path[i];
string idxstr = nextNode.Substring(nextNode.IndexOf("[") + 1);
idxstr = idxstr.Replace("]", "");
int arrayNumber = Convert.ToInt32(idxstr);
IList collection = currentObject as IList;
if (collection.Count <= arrayNumber) return null;
currentObject = collection[arrayNumber];
}
else
{
throw new NotImplementedException("Данный случай не обрабатывается");
}
}
else // штатный режим, перебираем объекты в иерархии дальше
{
object nextObject = objectFieldInfo.GetValue(currentObject);
if (nextObject == null) return null;
currentObject = nextObject;
}
}
return currentObject;
```
Да, мы можем даже здесь впаяться в неприятную ситуацию, когда путь сериализации уже имеет, например, элемент data[0] или data[1], а массив его ещё не реализовал. Например, мы создали пустой список List. Мы задаём ему N элементов – и без этой красивой строчки:
```
if (collection.Count <= arrayNumber) return null;
```
…получаем кучу исключений в мурчало. А всего-то надо было пропустить шаг отрисовки, дождавшись, пока будут созданы интересующие нас поля.
Мне пока не попадались другие случаи, когда objectFieldInfo == null, но при этом узел сериализации не обозначен как Array, поэтому на такую гипотетическую исключительную ситуацию стоит выкидывание страшного исключения – чтобы впоследствии его расколупать.
В общем и целом, мы получили более-менее рабочую функцию, позволяющую извлечь поле по его сериализованному свойству. В дальнейшем эту функцию можно модифицировать, заставив извлекать все объекты в пути сериализации, а также искать ближайшего «родителя», включая или исключая массивы по пути.
**Лайфхак для отрисовки вложенных свойств**
Чтобы отрисовать свойства с учётом смещения из-за вложенности списка, можно вместо Rect position использовать Rect indentedPosition = EditorGUI.IndentedRect(position). Обратите внимание только на то, что если вы будете рисовать внутренние поля через EditorGUI, вам необходимо будет использовать исходный position свойства, а если вы будете рисовать через GUI – тогда вам понадобится indentedPosition. Не используйте EditorGUILayout внутри OnGUI, ничего хорошего из этого не выйдет (чаще всего не выходит, во всяком случае).
Если вам необходимо рисовать поле, ссылающееся на MonoScript соответствующего класса (класса самого сериализуемого объекта или класса-рисовашки, не суть важно), желательно кешировать его в static-поле, чтобы не лезть постоянно в AssetDatabase, поскольку это затратно по ресурсам и при *очень* большом количестве свойств может привести к заметным тормозам редактора.
Спасибо за внимание. | https://habr.com/ru/post/502836/ | null | ru | null |
# Новые баги utorrent или что для нас готовят программисты Bittorrent
Многие пользователи utorrent переходят на новые версии программы по привычке или до того момента пока у них не перестаёт что-то работать. Кто-то остановился на 2.2.1 или 2.0.4 как последних более-менее стабильных, а кто-то по сей день верен 1.8.2 и даже 1.7.7. Чем же так пугает и привлекает третья версия utorrent? Попробуем проследить и разобраться в изменениях которые были и тех, что ожидают нас в будущем.
##### Эволюция utorrent
Первый мой установленный utorrent был 1.8.2. Как раз то время когда в этих клиентах начинали прикручивать magnet-ссылки. Возможно, ошибки которые допустили программисты utorrent при добавлении этой функции, оказались слишком заметны пользователям 1.7.7 и 1.8.2. Можно сказать, с этого момента стали применяться во многом противоречивые подходы к созданию программы.
Потом разработчики пытались довести до ума альфа версию 1.9, которая имела много новшеств. Из заметных такие как: поддержка udp трекеров, новый utp протокол, приложения, работа дополнительных параметров в магнет-ссылке. Но в стабильный релиз ушла версия 2.0, которую достаточно долго пытались подлатать до версии 2.2.1.
И вот тут начинается самое интересное. С версии 3.0 в программу приходят радикальные изменения, к ним нас подготавливали специальными альфа версиями utorrent под названиями «Falcon» и «Griffin». Но большинство из нас заметило только огромное количество глюков и проблемы в работе жёсткого диска. По этому продолжительное время многие справедливо отказывались переходить с 2.2.1 на 3.х. А нового в 3.х было много:
Достаточно интересной была технология под названием DNA. Под это название пытались впихнуть сразу две задумки:
1. Загрузка файлов через p2p с помощью специальных файлов, которые запускались на компьютере без торрент-клиента, либо их можно было запустить в самом utorrent, при этом в главном окне utorrent появлялся синий значёк DNA (к сожалению скриншот не сохранился). Такие специальные файлы предлагал загрузить своим клиентам например сайт ASUS в разделе загрузок драйверов. Запустив их, пользователь потом мог скачать сами файлы драйверов через p2p.
2. Просмотр видео в встроенном на http странице плеере с частичной подгрузкой из p2p.
Магнет-ссылки понимали новые дополнительные параметры ws (веб-сид) и fl (загрузка торрент-файла по прямой http ссылке)
В клиент был встроен механизм стриминга медиа файлов, когда можно было качать и одновременно смотреть фильм.
Многие провайдеры дождались включённой по умолчанию опции isp.bep22
Кроме работы ip-фильтра в клиенте, юзеры получили возможность создать специальный файл диапазонов приоритетных IP, к которым utorrent подключается в певую очередь. Тем самым, многим получилось значительно повысить скорость загрузки.
Просмотр «рейтингов» и «комментариев».
И наконец, многими забытая, но по сей день ещё работающая возможность передачи файлов друзьям или знакомым из торрент-клиента через специальный прокси-сервер по http протоколу. Который кстати, можно использовать и в качестве прокси веб-сида.
Достаточно лишь перетянуть любой файл или папку в окошко программы и utorrent создаст специальную ссылку на http страничку, с которой ваш знакомый не догадывающийся о существовании торрентов и p2p сможет скачать с вашего компьютера файлы даже если вы оба будете за NAT провайдера. К сожалению, судя по всему, скоро разработчики удалят эту настройку из программы, потому как в новых версиях utorrent она работает только под танцы с бубном. Но кто всё ещё хочет вернуть её работоспособность в свой utorrent 3.x измените следующие параметры в **скрытых** настройках программы.
Нажав и не отпуская SHIFT и F2 зайдите в Настройки----Дополнительно. В самом низу списка найдите и измените значения в строках:
webui.raptor\_host — raptor.utorrent.com
webui.raptor\_port — 80
webui.raptor\_secure — false
webui.talon\_host — remote.utorrent.com
webui.talon\_port — 80
webui.talon\_secure — false
В настройке Удалённый доступ обязательно придумать и вписать имя и пароль, без них работать не будет!
Последующие версии до 3.3.2 включительно можно назвать работой над ошибками. И всё в итоге было бы хорошо со стабильностью программы в будущем… если бы не новые идеи и вместе с ними новый utorrent 3.4
##### Utorrent 3.4 — забытая революция ?
Думаете после неудач с DNA и raptor.utorrent.com разработчики закинули планы по интеграции торрента и веб в долгий ящик? Как бы не так! Всё начинается по новому кругу. На этот раз utorrent должен превратиться в файловый http сервер, но конечно же со своими p2p особенностями.
*Небольшое отступление перед продолжением.
Вы должны понимать, что компания Bittorrent — это коммерческая организация, которой уже давно не интересна децентрализация p2p. Многие фичи в программе исчезают и появляются, а большинство из нас о их существовании даже и не догадывается. Все стремления в разработке utorrent направлены на зарабатывание денег. По этой причине не ожидайте ничего хорошего в новых билдах программы. С огромной вероятностью, всё о чём будет написано ниже, в utorrent 3.5 будет убрано или радикально переделано, то есть пользоваться этим уже вы не сможете.*
Из мелких заметных изменений в utorrent 3.4.2 для меня, наверное, будет работа с https веб-сидами (таки Dropbox по прежнему ещё раздаёт некоторые мои торренты на рутрекере) и неотключаемая реклама Pro версии.
Самое интересное скрыто от наших глаз, но если потянуть за «верёвочку», то можно найти и «пощупать» то, что для нас делается сейчас и может быть будет работать в следующих версиях программы.
Первая подсказка спрятана в настройке **Playback**
Дальше нашлась опция копирования ссылки файла
**Copy Stream URL**
Скопированная ссылка получилась такого вида
```
http://pairing:1B40250178C560733172CE3C811A4ACA831D6FB8@127.0.0.1:15906/proxy?sid=2&file=0&token=1B40250178C560733172CE3C811A4ACA831D6FB8&pairing=1B40250178C560733172CE3C811A4ACA831D6FB8&service=STREAMING">
```
Вставив эту ссылку в свой браузер — получите проигрывание файла встроенным плеером браузера, либо просто скачивание его в папку загрузок.
В этой ссылке есть несколько параметров связанных с настройками utorrent
webui.allow\_pairing
webui.proxy\_auth
webui.token\_auth
Но так как половина параметров в ссылке не работает (всё что связано с хешами), можно укоротить её до
```
http://127.0.0.1:15906/proxy?sid=2&file=0
```
Если это вставить в браузер, произойдёт то же самое что и с полной ссылкой. Работающие параметры ссылки:
sid= номер торрента (может быть любым, выдаётся utorrent при добавлении торрента).
file= номер файла ( вроде как постоянный, назначается по положению в колонке Путь)
15906 — выбранный порт в настройках utorrent
Вот тут возникает вопрос: «А что с этим всем можно сделать ?» Пока наверно, получится только немного пофантазировать и поэкспериментировать. В принципе можете сами поиграться с этими настройками и посмотреть как они работают. Вот например как можно использовать этот встроенный в программу http-сервер:
##### Передача файлов на прямую по http
Для этого у вас должен быть белый статический или динамический IP в интернете или хотя бы в локальной сети, а так же проброшен порт указанный в настройках utorrent. В скопированных ссылках 127.0.0.1 нужно заменить на ваш интернет или локальный IP.
```
http://44.0.5.15:15906/proxy?sid=2&file=0
```
В зависимости от того собираетесь ли вы передавать файлы всем или избранным, можете включить или отключить в настройках опцию webui.proxy\_auth. Если будет включено, перед открытием страницы utorrent может попросить пройти авторизацию. По этому в начале не забудьте вписать имя и пароль в настройках **Веб-интерфейса** utorrent (гостевой логин не работает)
**авторизация**
Если webui.proxy\_auth будет отключён, контент станет доступен всем без выскакивающего окошка авторизации.
##### Последовательная загрузка и просмотр медиа файлов торрента
Как вы уже вначале догадались, название самой опции «Copy Stream URL» и все скопированные ссылки с IP 127.0.0.1 сделаны только для воспроизведения загружаемого контента на этом же компьютере. Однако зачем разработчикам пришлось делать так сложно (со встроенным http сервером) не совсем понятно…
Интересен сам механизм работы клиента по таким ссылкам. К примеру, вы скачиваете торрент-файл с трекера и запустив его в utorrent ставите задание на остановку (не загружаете), затем копируте ссылку Copy Stream URL какого-нибудь файла из списка и вставляете эту ссылку в свой браузер. Как только браузер переходит по ссылке в utorrent запускается процесс последовательной загрузки частей только этого файла, с постепенной передачей его браузеру. Если в браузере остановить загрузку и/или вообще закрыть программу браузера, utorrent так же отреагирует остановкой задания.
##### база сайта или каталога в p2p сети
Новые возможности utorrent были замечены и The Pirate Bay [www.piratebayuk.co.uk/setup.php](http://www.piratebayuk.co.uk/setup.php) Но как-то всё сложно у них там с юзабельнстью получается.
> Step 2. Install and configure xampp
>
> Download and Install xampp. (Visit the Xampp homepage here). Once Installed go to: Start->All Programs->Apache Friends->XAMPP->XAMPP Control Panel. Then complete the following operations:
К сожалению utorrent работает не совсем как веб-сервер, а скорее как файловый http сервер. Соответственно он может подгружать только файлы из p2p сети, затем браузер забирает из utorrent эти файлы и показывает их на своей странице. В добавок ко всему, загруженный торрент с файлами, на разных utorrent будет иметь различный sid=, но file= должны быть одинаковы так как названия и количество фалов в торренте у всех будет одинаковое.
Для того что-бы перенести сайт в торренты, необходимо сделать механизм глобальной правки sid= в ссылках в виде юзер-скрипта или расширения в браузере, который установит каждый юзер. А так же в торрент-файле необходимо будет поместить невероятно огромную кучу html страничек на каждую раздачу. Другое дело, если на компьютер пользователя будет установлена специальная программа для просмотра, умеющая работать по ссылкам utorrent. В настройках программы пользователь смог бы указать свой sid= торрента. Отображение онлайн раздач на трекере и в специальной программе может быть примерно одинаковым как по виду так и по содержимому. Общий вес загруженных пользователем файлов такого архива будет существенно меньше, чем если бы скачивался весь архив целиком. Юзер не должен и не будет качать/хранить на компьютере темы, которые ему не интересны. А вот раздавать сохранённые у себя части тем которые ему интересны он может.
Содержимое ахива сайта можно разбить на несколько торрент-файлов, а не пихать всё в один. Так в главном торрент-файле будет файл/файлы со всеми ссылками «карты сайта», остальные торрент-файлы будут относиться к определённой категории и хранить в себе как файлы с ссылками на файлы описания (скриншоты, текст, магнет-ссылки и пр.) так и к примеру файлы постеров и скриншотов (хотя, опять же их можно выделить в отдельный торрент-файл(ы), с возможностью указать дополнительные sid= ).
Ах мечты, мечты…
##### Автоматическое обновление торрент-файлов
К сожалению, эта тема раскрыта и исследована не полностью, так как мои знания в программировании примерно равны нулю.
Может быть, кто-нибудь из вас сможет исследовать эту тему и выяснит как должен работать этот механизм. Буду благодарен, если вы поделитесь своими мыслями по этому поводу.
В utorrent 3.4 была добавлена возможность автоматического обновления задания в клиенте. Так скачав с трекера торрент-файл какого-нибудь сериала, в дальнейшем можно не следить за выходом новых серий и обновлением раздачи на форуме, а сразу получать обновлённый торрент и новые серии.
В процессе создания торрент-файла (специальной программой) или в **Свойствах торрента** задания utorrent прописывается http ссылка обновления торрент-файла.
После перезапуска клиента, возле задания появится синяя «точка», означающая что utorrent периодически опрашивает сайт на предмет загрузки нового торрент-файла.
В самом utorrent можно посмотреть ленту обновлений по каждому торренту (дата и файлы)
Разработчики utorrent опубликовали специальный мануал [bittorrent.org/beps/bep\_0039.html](http://bittorrent.org/beps/bep_0039.html)
Так же получилось раздобыть их экспериментальный торрент-файл, который внутри содержит соответсвующие записи в секции info.
**внутренности**
На момент когда я достал этот торрент-файл, по ссылке обновления загружалось
```
{
"message": "no update",
"success": true
}
```
В переписке с разработчиком utorrent получилось вытянуть только это
> For the torrent to be updatable, it has to have either a «collections» key or «similar» key or both, and torrent downloaded by the update-url must be signed by the original torrent's originator.
>
>
>
> «collections» key or «similar» key is described in:
>
> [www.bittorrent.org/beps/bep\_0038.html](http://www.bittorrent.org/beps/bep_0038.html)
>
>
>
> update-url is described in:
>
> [www.bittorrent.org/beps/bep\_0039.html](http://www.bittorrent.org/beps/bep_0039.html)
>
>
>
> the signing is described in:
>
> [www.bittorrent.org/beps/bep\_0035.html](http://www.bittorrent.org/beps/bep_0035.html)
>
>
>
> thanks,
>
>
>
> -Jeanette
##### Другие не исследованные настройки utorrent 3.4.х
Одной из интересных опций наверно будет vpn.dark\_mode. Если её включить, клиент теряет обычную связь с трекерами и пирами. Что собственно и должно происходить для того, что бы «не палить» IP. Если логически развивать мысль дальше, работать это должно примерно как remote.utorrent.com, с той лишь разницей, что некий сервер должен быть одновременно прокси-сервером и ретрекером. То есть, при включении этой опции utorrent должен качать/раздавать только через этот сервер. При этом другие пиры должны так же, по идее, включить эту опцию.
Однако экспериментально заставить работать эту опцию у меня не получилось.
Загадочной и пугающей настройкой является distributed\_share.enable и связанные с ней скрытые настройки (SHIFT+F2). Есть подозрение, что в Bittorrent делают некое подобие социальной сети с элементами p2p… | https://habr.com/ru/post/251625/ | null | ru | null |
# Боль и слёзы в Svelte 3
#### Вместо предисловия
Статья будет полезна тем, кто так-же как и Мы решил попробовать [Svelte](http://svelte.dev) в живом проекте. В нашу небольшую компанию пришёл заказ на разработку веб-админки для сервиса с бекэндом на Mongodb Stitch. В последние пару лет frontend Мы пишем на React или Vue (в зависимости от размера проекта и нужен ли ReactNative), но наслышав о красотах Svelte мы решили попробовать его, чтобы понять для себя так ли он хорош. И может нам тоже стоит дальше использовать его вместо Vue или React?..
### Кто такой Svelte?
Если в двух словах — это новый js фреймворк (но он таким себя не считает), который убийца React и Vue, и бла, бла, бла… В своей статье я хочу рассмотреть Svelte не какой он классный «под капотом», а с точки зрения удобства его использования в реальном проекте.
Мы не делаем машины, мы на них ездим и у нас есть злые заказчики с еще не менее злыми сроками.
### Tutorial
Первое с чего Вы начинаете знакомство с новым языком или фреймворков — это туториал на сайте. У Svelte это [Svelte.dev/Tutorial](https://svelte.dev/tutorial).
К сожаление часть туториалов просто не работает на сайте в превью, при этом не совсем понятно работает ли оно в реальности или нет. Приходится тратить время и проверять самому вручную, так как не понятно устарел ли туториал или что-то пошло не так на сайте Svelte. И на это реально тратится очень много времени.
### UI Kit и Стили
Поиски UI Kit для Svelte были отдельной болью для всех нас. Хотелось воскликнуть: «Хоть Material, Bootstrap… хоть что нибудь...».
Были найдены только [sveltematerialui.com](https://sveltematerialui.com/) и [svelteui.js.org](https://svelteui.js.org), которые в данный момент выглядели очень сыро.
При простом импорте из него, при сборке вывалилась ошибка из самого пакета, решать ошибки ui kit времени не было.
Пробежав быстро по документации я решил от него отказаться в пользу «Ванилла» импорта из CDN.
В проекте хотелось использовать Material UI, так как возможно админка будет использоваться и с мобильного устройства, а Material очень хорошо для этого подходит (на мой взгляд он даже хуже смотрится на десктопе).
Использование JS без UI Kit вернуло меня мысленно на 10 лет назад ) Паровозы классов и добрая ностальгия ).
Из-за того, что Svelte работает с DOM «по другому» в MaterialUI начали вылазить всякие гадости, связанные с тем как отображаются UI компоненты которые добавляются через js в dom. Например простой спиннер отображается через раз:
После долгих поисков что же пошло не так, выяснилось что спиннер в Material UI, добавляется через JS после того, как документ готов (onLoad) но после этого события Svelte запускает своё добавление в DOM и JS скрипт Material просто его не видит так как событие было раньше.
Лечить это пришлось добавлением в родительский компонент Svelte:
```
afterUpdate(() => {
componentHandler.upgradeDom();
});
```
### Стилизация
Со стилями все предельно ясно, мы запихиваем все стили как в Vue. Вы пишете стиль и все в порядке, и потом пишете компонент UI (так как у Вас нет UIKit) который должен принимать параметры props, например width и height, и логично делаете это так:
```
export let width = '20px';
export let height = '20px';
.loader {
width: { width },
height: { height },
}
```
А… нет, в стиле у Вас не получится вставлять переменные. Из этой ситуации Вы можете выкрутиться через «ReactWay» и делать динамические стили в «script» как переменные или функции с возвратом стиля.
В итоге у нас опять каша, часть стиля в *style* часть в *script*. Чистый код получится только в том случае если у Вас нет параметров в стилях или у Вас только динамические параметры и они только в *script*.
### Routing и роутеры
Без нормального роутера Вы не сможете сделать даже one page app.
React, Vue при скалфолдинге 'Hello World' проекта уже идут с роутером в коробке (или можно его выбрать). Но как и всё в Svelte — это дается не просто.
Нужно выбрать роутер самому, да и еще между очень похожими решениями. По правде говоря пока есть всего два роутера [github.com/EmilTholin/svelte-routing](https://github.com/EmilTholin/svelte-routing) и [github.com/kazzkiq/svero](https://github.com/kazzkiq/svero).
Оба очень похожи но я выбрал первый, выбирал по количеству звезд (да я знаю, я ужасный человек).
Итак начнем его встраивать в наш MDL.
Обернем всё в и Добавим для ссылок из навигации.
Переходим в превью и смотрим, что получилось.
А получилось то, что детские болезни Svelte продолжаются и в нельзя передавать классы. Возник резонный вопрос а как Вы его будете стилизировать?
Видимо это все еще в issues для роутера.
К счастью Мы можем привязать к роутеру наш обычный *a href=‘’* указав [use:link](https://github.com/EmilTholin/svelte-routing#link-1) за что отдельная благодарность.
### Ошибки
В отличии от React который просто не даст Вам создать bundle и будет сильно «кричать» об ошибке, Svelte отлично соберёт всё с ошибкой. При этом если Вы забыли что-то npm install'нуть или export'ануть, все отлично соберется и просто покажет белый экран (Кстати говоря так было в первых версиях React).
В React и Vue, Мы привыкли видеть такие ошибки еще на этапе билда или линта.
В итоге Вам придется отлавливать ошибки и в двух местах. Справедливости ради — это есть в React и Vue, но гораздо реже и такие явные ошибки ловятся еще на стадии линта.
### Svelte просто необходим naming convention
C этой проблемой Вы будете сталкиваться довольно часто — с отсутствием конвенции по наименованию.
Например, вернемся к роутеру.
Есть вот такой импорт:
```
import { Router, link, Link ,Route } from "svelte-routing";
```
Что из этого *Link* и *link*? Даже в таком маленьком проекте как у меня, уже возникла путаница с отсутствием конвенций имен в проектах используемых в Svelte.
Конечно это должно было выглядеть в глазах ReactМэна вот так:
```
import { Router, useLink, LinkComponent ,RouteComponent } from "svelte-routing";
```
В Svelte есть подобие *ref* как в react’е, это ссылка на элемент dom или компонент.
Официальный туториал гласит нам сделать это так:
```
let dialog;
```
А если у Вас будет 15 переменных в компоненте?
```
let loading;
let pins;
let dialog;
let stitch;
```
Где и что из этого действительно переменные, а где ссылки на компоненты или элементы?
Я бы изменил туториал и сделал примеры более правильными с точки зрения новичков и их конвенции переменных (см Туториал React для хорошего примера). Если Вы даёте делать винегрет переменных, было бы неплохо чтобы *linter* или *bundler* ругался на такой винегрет, как например, это сделано у golang.
```
let dialogElement;
```
Еще один пример «из жизни», когда Вы получаете какие-то данные в функции компонента и эти данные нужно отправить в Ваш *View*, где к части елемента UI у Вас прикручена какая-то переменная. И выглядит это у нас (вернее у нашего программиста) вот так:
```
async function ReloadPins() {
loading = true;
pins = await getAllPins();
status = 0;
}
```
Когда я открыл его код, мне сразу «стало понятно», что здесь переменная которая *state* и какая из них привязана к нашему *UI*.
Шучу, конечно же ничего не ясно. Причем даже не понятно меняется состояние или это просто вспомогательная переменная. В React это решается state, который хоть как-то вносит ясности.
### Что где изменилось и кто это сделал ?
Переменные внутри Svelte компонента — глобальные и меняются они везде (привет Angular).
Но есть и хорошая новость, они глобальны внутри одного компонента (пока Angular), поэтому это изменение всех и всеми не так уж и страшно внутри одного компонента.
При этом Вы экономите время на «красоте» кода и не размышляете, что Вам сделать *state* переменной, а что оставить внутри функции (привет React) — у Вас все и везде.
В итоге Вы быстро пишете компоненты но понять, что написал джуниор в этом «винегрете» через несколько дней когда он сам уже забыл (иногда даже как его зовут) бывает очень сложно. Из-за этого будет невозможно понять что внутри без четкой организации кода внутри проекта или команды.
### Привязываем Stitch
Stitch — отличная штука и я обязательно расскажу о ней подробнее, и сравню с аналогами, померяем тесты в продакшене в своей следующей статье, а сейчас все таки больше про Svelte.
Чтобы использовать Stitch Вам придется пойти по «Ванильному» пути и вставить:
```
```
Так как при использовании *npm* и нормального *import* пакета, начинается проблема с ошибкой *buffer*.
Не знаю связанно ли это со сборщиком Svelte или самим Stitch, или еще c чем-то, но времени ковырять у меня не было и пришлось просто добавить *script* с импортом, после чего всё успешно заработало.
Это основные проблемы с которыми мы столкнулись при работе со Svelte. И сказать честно — в общем нам не понравилось, причём никому…
Что в итоге:
### Для чего Вам пригодится Svelte ?
* Если Вы работаете один и Вам срочно нужно сделать MVP или небольшую админку. С большой админкой будут проблемы так как при написании нового кода Вы забудете старый или нужно обязательно писать само-документированный код, так как Svelte не «заставляет» Вас это делать.
* Если размер bundle Вам очень важен. Например, Вы делаете веб-app для страны в которой всё еще нет 3G или интернет очень медленный и очень дорогой. В большей части мира дорогие программисты, а не интернет, поэтому размер bundle в разумных пределах не будет актуальной проблемой в 99% случаев.
* Если Вы только начинаете учиться писать на JS и делать фронтенд Svelte даст Вам всю свободу «выстрелить в ногу», в соседа по парте или устроить массовую стрельбу по ногам. На самом деле Вам не нужно будет учить JSX или долго разбираться в конвенциях кода, Вы сразу можете сделать Ваш первый фронтенд проект и увидеть, что у Вас уже что-то получилось и что-то даже работает.
Исходя из последнего я совсем не понимаю зачем мэйнтэйнеры Svelte собираются делать поддержку TypeScript? Мы же любим Svelte как раз за «стрельбу по ногам» и TypeScript на мой взгляд это как вседорожные гусеницы для спорткара Svelte. И знаете, поработав со Svelte, я понял на сколько сильно за последние годы изменился JS, и что он совсем уже не JS.
Svelte даёт возможность поработать в еще том, старом и ламповом JS, без PropTypes, Flow и TypeScript.
### Что мне понравилось?
* Хорошо читаемые if/else, чего нет в Vue. Я бы очень хотел увидеть что-то похожее в Vue.
* Можно создавать свои [event](https://svelte.dev/tutorial/component-events) в компонентах и избавиться от передачи в child коллбэков функции, для коммуникации между child > parent.
### Почему не стоит использовать Svelte ?
* Нет ни одного полностью рабочего UI Kit. Трудно представить себе web app без UIKit, написать самим UI Kit могут позволить себе только крупные проекты, для которых как раз Svelte мало подходит. Прикручивание чего-то ванильного переходит в создание своих UI компонентов (своего UI Kit) или в борьбу с ошибками и «паровозами» классов.
* Не явность части простых ошибок, и отлова их только на этапе тестирования.
* Если Вы собрались делать мульти-платформенное приложение (а сейчас везде mobile first), Вам придется все переписывать на ReactNative или допиливать руками сгенерированный NativeScript (есть генератор NS из Svelte). Справедливости ради у Vue с мобильной разработкой тоже всё не очень хорошо, но она есть и кое-как рабочая.
* Вам придётся позаботиться о написании очень четкой конвенции кода для своих разработчиков в проекте, так как туториал и примеры не сделаны для командной разработки. | https://habr.com/ru/post/469361/ | null | ru | null |
# Основные принципы настройки Garbage Collection с нуля
В данной статье я бы не хотел заострять внимание на принципе работы сборщика мусора — об этом прекрасно и наглядно описано здесь: [habrahabr.ru/post/112676](http://habrahabr.ru/post/112676/). Хочется больше перейти к практическим основам и количественным характеристикам по настройке Garbage Collection в JVM — и попытаться понять насколько это может быть эффективным.
#### Количественные характеристики оценки эффективности GC
Рассмотрим следующие показатели:
* **Пропускная способность** Мера, определяющая способность приложения работать в пиковой нагрузке не зависимо от пауз во время сборки и размера необходимой памяти
* **Время отклика** Мера GC, определяющая способность приложения справляться с числом остановок и флуктуаций работы GC
* **Размер используемой памяти** Размер памяти, который необходим для эффективной работы GC
Как правило, перечисленные характеристики являются компромиссными и улучшение одной из них ведёт к затратам по остальным. Для большинства приложений важны все три характеристики, но зачастую одна или две имеют большее значение для приложения — это и будет отправной точкой в настройке.
#### Основные принципы настройки GC
Рассматривают три основных фундаментальных правила по пониманию настройки GC:
* Необходимо стремиться к тому, чтобы максимальное количество объектов очищалось при работе малого GC(minor grabage collection). Этот принцип позволяет уменьшить число и частоту работы полного сборщика мусора(full garbage collection) — чья работа является основной причиной больших задержек в приложении
* Чем больше памяти выделено приложению, тем лучше работает сборка мусора и тем лучше достигаются количественные характеристики по пропускной способности и времени отклика
* Эффективно настроить можно только 2 из 3 количественных характеристик — пропускная способность, время отклика, размер выделенной памяти — под эффективным значением размера необходимой памяти понимается её минимизация
Рассмотрим пример простого приложения(которое, к примеру, может эмулировать работу вэб-приложения, в ходе которого идёт обращение к БД и накопление возвращаемого результат), в котором в несколько потоков идёт обращение к методу makeObjects(), в ходе которого в цикле непрерывно формируется объект, занимающий определённый объём в куче, затем с ним происходят какие-либо вычисления — делается задержка, ссылка на объект при этом не утекает из метода и по его завершению GC может понять, что данный объект подлежит очистке.
```
package ru.skuptsov;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class MemoryConsumer implements Runnable {
private static final int OBJECT_SIZE = 1024 * 1024;
private static final int OBJECTS_NUMBER = 8;
private static final int ADD_PROCESS_TIME = 1000;
private static final int NUMBER_OF_REQUEST_THREADS = 50;
private static final long EXPERIMENT_TIME = 30000;
private static volatile boolean stop = false;
public static void main(String[] args) throws InterruptedException {
start();
Thread.sleep(EXPERIMENT_TIME);
stop();
}
private static void start() {
ExecutorService execService = Executors.newCachedThreadPool();
for (int i = 0; i < NUMBER_OF_REQUEST_THREADS; i++)
execService.execute(new MemoryConsumer());
}
private static void stop() {
stop = true;
}
@Override
public void run() {
while (true && !stop) {
makeObjects();
}
}
private void makeObjects() {
List objectList = new ArrayList();
for (int i = 0; i < OBJECTS\_NUMBER; i++) {
objectList.add(new byte[OBJECT\_SIZE]);
}
try {
Thread.sleep(ADD\_PROCESS\_TIME);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
```
Эксперимент длится некоторое время, далее для оценки эффективности будем использовать общее время задержки, вызванное сборщиком мусора. Задержка необходима для того, чтобы после финальной маркировки объектов на удаление не появилась ссылка на очищаемый объект. О том, что существует jvm, которая может помечать и очищать объекты не вызывая «stop-the-world» паузу и как функционируют различные типы GC — подробно описано здесь [habrahabr.ru/post/148322](http://habrahabr.ru/post/148322/) — мы не рассматриваем такой вариант.
Запускать эксперимент мы будем на:
```
C:\>java -XX:+PrintCommandLineFlags -version
-XX:MaxHeapSize=4290607104 -XX:ParallelGCThreads=8 -XX:+PrintCommandLineFlags -XX:-UseLargePagesIndividualAllocation -XX:+UseParallelGC
java version "1.6.0_16"
Java(TM) SE Runtime Environment (build 1.6.0_16-b01)
Java HotSpot(TM) 64-Bit Server VM (build 14.2-b01, mixed mode)
```
Для которого по умолчанию включен режим — server и UseParallelGC(многопоточная работа фазы малой сборки мусора)
Для оценки общей величины паузы сборщика мусора можно запускать в режиме:
```
java -XX:+PrintGCTimeStamps -XX:+PrintGCDetails -verbose:gc -Xloggc:gc.log ru.skuptsov.MemoryConsumer
```
И суммировать задержку по логу gc.log:
```
0.167: [Full GC [PSYoungGen: 21792K->13324K(152896K)] [PSOldGen: 341095K->349363K(349568K)] 362888K->362687K(502464K) [PSPermGen: 2581K->2581K(21248K)], 0.0079385 secs] [Times: user=0.01 sys=0.00, real=0.01 secs]
```
Где real=0.01 secs — реальное время, затраченное на сборку.
А можно воспользоваться утилитой VisualVm, с установленным плагином VisualGC, в котором наглядно можно наблюдать распределение памяти по различным областям GC(Eden, Survivor1, Survivor2, Old) и видеть статистику по запуску и длительности сборки мусора.
#### Определение размера необходимой памяти
Для начала мы должны запустить приложение с возможно большим размером памяти, чем это это реально необходимо приложению. Если мы не знаем изначально, сколько будет занимать наше приложение в памяти — можно запустить приложение без указания -Xmx и -Xms и HotSpot VM сама выберет размер памяти. Если при старте приложения мы получим OutOfMemory(Java heap space или PermGen space), то мы можем итеративно увеличивать размер доступной памяти(-Xmx или -XX:PermSize) до тех пор пока ошибки не уйдут.
Следующим шагом будет вычисление размера долго-живущих живых данных — это размер old и permanent областей кучи после фазы полной сборки мусора. Этот размер — примерный объём памяти, необходимый для функционирования приложения, для его получения можно посмотреть на размер областей после серии полной сборки. Как правило размер необходимой памяти для приложения -Xms и -Xmx в 3-4 раза больше, чем объём живых данных. Так, для лога, указанного выше — величина old области после фазы полной сборки мусора — 349363K. Тогда предлагаемое значение -Xmx и -Xms ~ 1400 Мб. -XX:PermSize and -XX:MaxPermSize — в 1.5 раз больше, чем PermGenSize после фазы полной сборки мусора — 13324K ~ 20 Мб. Размер young generation принимаю равным 1-1.5 размера объёма живых данных ~ 525 Мб. Тогда получаем строку запуска jvm с такими параметрами:
```
java -Xms1400m -Xmx1400m -Xmn525m -XX:PermSize=20m ru.skuptsov.MemoryConsumer
```
В VisualVm получаем такую картину:
Всего за 30 сек эксперимента было произведено 54 сборки — 31 малых и 23 полных — с общим временем остановки 3,227c. Данная величина задержки может не удовлетворять необходимым требованиям — посмотрим, сможем ли мы улучшить ситуацию без изменения кода приложения.
#### Настройка допустимого времени отклика
Следующие параметры необходимо замерять и учитывать при настройке времени отклика:
* Измерение длительности малой сборки мусора
* Измерение частоты малой сборки мусора
* Измерение длительности худшего случая полной сборки мусора
* Измерение частоты худшего случая полной сборки мусора
##### Корректировка размера young и old generation
Время, необходимое для осуществления фазы малой сборки мусора, напрямую зависит от числа объектов в young generation, чем меньше его размер — тем меньше длительность, но при этом возрастает частота, т.к. область начинает чаще заполняться. Попробуем уменьшить время каждой малой сборки, уменьшив размер young generation, сохранив при этом размер old generation. Примерно можно оценить, что каждую секунду мы должны очищать в young generation 50потоков\*8объектов\*1Мб~ 400Мб. Запустим с параметрами:
```
java -Xms1275m -Xmx1275m -Xmn400m -XX:PermSize=20m ru.skuptsov.MemoryConsumer
```
В VisualVm получаем такую картину:
На общее время работы малой сборки мусора мы повлиять не смогли — 1,533с — увеличилась частота малых сборок, но общее время ухудшилось — 3,661 из-за того, что увеличилась скорость заполнения old generation и увеличилась частота вызова полной сборки мусора. Чтобы побороть это — попробуем увеличить размер old generation — запустим jvm с параметрами:
```
java -Xms1400m -Xmx1400m -Xmn400m -XX:PermSize=20m ru.skuptsov.MemoryConsumer
```
Общая пауза теперь улучшилась и составляет 2,637 с а общее значение необходимой для приложения памяти при этом уменьшилось — таким образом итеративно можно найти правильный баланс между old и young generation для распределения времени жизни объектов в конкретном приложении.
Если время задержки по-прежнему нас не устраивает — можно перейти к concurrent garbage collector, включив опцию -XX:+UseConcMarkSweepGC — алгоритм, который будет пытаться выполнять основную работу по маркировке объектов на удаление в отдельном потоке параллельно потокам приложения.
##### Настройка Concurrent garbage collector
ConcMarkSweep GC требует более внимательной настройки, — одной из основных целей является уменьшение количества stop-the-world пауз при отсутствии достаточного места в old generation для расположения объектов — т.к. эта фаза занимает в среднем больше времени, чем фаза полной сборки мусора при throughput GC. Как результат — может увеличиться длительность худшего случая сборки мусора, необходимо избегать частых переполнений old generation. Как правило, — при переходе на ConcMarkSweep GC рекомендуют увеличить размер old generation на 20-30% — запустим jvm с параметрами:
```
java -Xms1680m -Xmx1680m -Xmn400m -XX:+UseConcMarkSweepGC -XX:PermSize=20m ru.skuptsov.MemoryConsumer
```
Общая пауза сократилась до 1,923 с.
##### Корректировка размера survivor
Снизу под графиком вы видите распределение объёма памяти приложения по числу переходов между стадиями Eden, Survivor1 и Survivor2 перед тем как они попадут в Old Generation. Дело в том, что один из способов уменьшения числа переполнений old generation в ConcMarkSweep GC — предотвратить прямое перетекание объектов из young generation напрямую в old — минуя survivor области.
Для слежения за распределением объектов по этапам можно запустить jvm с параметром -XX:+PrintTenuringDistribution.
В gc.log можем наблюдать:
```
Desired survivor size 20971520 bytes, new threshold 1 (max 4)
- age 1: 40900584 bytes, 40900584 total
```
Общее размер survivor объектов — 40900584, CMS по умолчанию использует 50% барьер заполненности области survivor. Таким образом получаем размер области ~ 80 Мб. При запуске jvm он задаётся параметром -XX:SurvivorRatio, который определяется из формулы:
```
survivor space size = -Xmn/(-XX:SurvivorRatio= + 2)
```
Получаем
```
java -Xms1680m -Xmx1680m -Xmn400m -XX:SurvivorRatio=3 -XX:+UseConcMarkSweepGC -XX:PermSize=20m ru.skuptsov.MemoryConsumer
```
Желая оставить размер eden space тем же — получаем:
```
java -Xms1760m -Xmx1760m -Xmn480m -XX:SurvivorRatio=5 -XX:+UseConcMarkSweepGC -XX:PermSize=20m ru.skuptsov.MemoryConsumer
```
Распределение стало лучше, но общее время сильно не изменилось в силу специфики приложения, дело в том, что после частых малых сборок мусора размер выживших объектов всегда больше, чем доступный размер областей survivor, поэтому в нашем случае мы можем пожертвовать правильным распределением в угоду размера eden space:
```
java -Xms1760m -Xmx1760m -Xmn480m -XX:SurvivorRatio=100 -XX:+UseConcMarkSweepGC -XX:PermSize=20m ru.skuptsov.MemoryConsumer
```
#### Итог
В результате мы сумели сократить размер общей паузы с 3,227 с до 1,481 с на 30 с эксперимента, немного увеличив при этом общее потребление памяти. Много это или мало — зависит от конкретной специфики, в частности, учитывая тенденцию к уменьшению стоимости физической памяти и принцип максимизации используемой памяти — всё равно важно найти баланс между различными областями GC и процесс этот, скорее, творческий, чем научный. | https://habr.com/ru/post/223401/ | null | ru | null |
# Как я начал сходить с ума от программирования
Всем привет, меня зовут Артур, и мне 15 лет. С программированием я познакомился ещё в возрасте 12 лет, но начал изучать только с 14, потому что у меня в данный промежуток времени не было компьютера. Тогда я читал про программирование, и узнал о таком языке, как Python. «Хм, что за язык такой интересный?» — подумал я. Посмотрел пример программы «hello world» и был немного удивлен:
```
print("hello world")
```
Тогда я был знаком только с Си и думал, что он самый лёгкий из всех языков. Где точка с запятой, где int main? Решил попробовать. Искал хорошие учебники около двух дней. Наткнулся на Марка Лутца (эх, как же я пожалел об этом...), этот учебник был не для новичков, поэтому половину прочитанного из книги я просто не понимал, но основы языка по первой части, все же, дошли до меня, хотя я даже не дошел до классов. Я всегда записывал важную информацию в тетрадь.
В конце учебника я вообще перестал понимать, о чём идёт речь и забросил обучение.
Нашел другой прекрасный учебник, называется «Изучаем Python. Программирование игр, визуализация данных, веб-приложения». В этом учебнике после Лутца я начал понимать всё. Там я выучил основы, понял принципы ООП, но когда пришло время практики (мне нужно было создать сайт по инструкции на Django), я понял, что ещё многое нужно подучить, так как результат меня не очень порадовал, и в это время я нашел учебник от Head First, который был тоже достаточно хорош, нестандартной подачи информации.
Я дошел до темы базы данных, научился писать сайты на Flask. После решил показать своим одноклассникам свои умения (они не верили тому, что я начинающий программист), на что получил ответы такого типа:
«Python? Ха-ха-ха, его все знают!», «Ты реально ничего не умеешь!», «Какой же ты программист, ты даже не умеешь ддосить и взламывать сайты».
Вот с этого все и началось…
Меня их слова, на тот момент, очень сильно разозлили, так как программист не должен уметь взламывать сайты, его работа — писать программы. Но тогда я задумался: «А почему я пишу именно на Python? Есть же другие языки программирования, а вдруг есть лучше?»,
а затем: «А может лучше научится создавать сайты (фронтенд)?». Тогда я начал с учебника Head First, про HTML, CSS. Я прочитал весь учебник, но пропускал некоторые темы, так как эта информация, в данное время, устаревшая и неактуальная. Далее я прошел первый бесплатный курс, так как возможности платить за все курсы у меня нет. Поэтому, я начал искать сливы курсов…
Таким образом, я прошел курс по верстке, и сверстал один сайт с достаточно классной анимацией. Но это занятие не принесло мне никакого удовольствия, для меня верстать страницы на чистом HTML и CSS — сущий ад. Стало грустно, ведь я столько времени потратил на изучение… Вдруг, я наткнулся на С# — серьезный язык программирования, на котором можно писать программы под Windows, сайты и многое другое. Меня он очень сильно заинтересовал даже простым синтаксисом.
Я скачал один курс, начал его проходить, познакомился с одним человеком в соц.сети. Оказалось, мы живём с ним в одном городе, ему 21 год, и он пишет на С#. Мы с часто с ним советовались насчёт моего выбора в программировании: я уже выучил LINQ, ООП, начал делать десктопные приложения… Но вдруг, я прочитал про Unity. Узнал, что его основной язык — это C#, и я подумал: «Ого, это же так круто! Почему бы не рассмотреть подробнее?». Я забросил мой прошлый курс, так и не закончив его, и, нашел курс по созданию игр на Unity. Изучение было очень сложным, я терялся в 3D пространстве, но спустя неделю уже начал разрабатывать простую игрушку. Так, я занимался Unity около месяца, но когда дошел до UI, эта тема показалась мне очень скучной. У меня было много ошибок, которые я пытался исправить сутками. После, Unity без причины перестала запускаться, и мой проект удалился. Я пришел в ярость и удалил его. Затем, подумал: «Я уже попробовал несколько сфер, но ни одна мне не понравилась. Почему?».
И тогда я решил попробовать программирование под Android, нашел курс (в котором были основы Java, а после — создание приложений). Прошел почти весь курс, но в изучении появились проблемы. Именно на тот момент я понял, что уже не могу контролировать свои интересы. У меня быстро пропадал интерес к одной сфере и также быстро появлялся новый. После программирования под Android, я уже перепробовал и «Ruby», и «Go», и «Flutter». Затем я просто на просто забросил всё изучение.
Я заметил, что в мое поведение поменялось, многое изменилось. Меня начали раздражать малейшие детали, которые находились в кривом положении. В моем доме все стояло по своим местам, все было идеально, по полочкам, в компьютере все точно по пикселям. А если что-то хоть немного сдвинется, я начинал злиться до тряски и не мог успокоиться, пока каждый предмет не будет находиться в идеально ровном положении. Я замкнулся в себе, появились проблемы с формулировкой речи, мое настроение менялось чуть ли не каждый час.
На протяжении этого времени мысли были только о программировании, день изо дня я решал, какой же язык и какую сферу мне выбрать, при этом каждый день мои интересы менялись по нескольку раз, но за компьютер я так и не садился, потому что хотел найти язык, который будет устраивать меня по всем параметрам, и только тогда сесть за изучение. Ближе к сентябрю эти проблемы только усилились, я продолжал думать на выбором сферы. Вчера утром я хотел разрабатывать на С#, к вечеру выбрал Flutter, пообещал себе, что это будет окончательный выбор, но сегодня утром я сильно захотел разрабатывать фронтенд, а сейчас захотел написать обо всем этом на Хабре, надеясь, что мне кто нибудь даст совет и поможет… | https://habr.com/ru/post/518504/ | null | ru | null |
# Интерактивная 3D-инсталляция по мотивам «Звёздных войн»
Где-то в далёкой-далёкой галактике (хотя и в нашей тоже) неофициально день «Звёздных войн» 4 мая отмечается. Не случайно он выбран, из фильма цитата тому подтверждение «May the Force be with you» («Да пребудет с тобой Сила»), как намёк звучит она для поклонников «May the fourth be with you». В посте этом поздравить хотим хабровчан, на тёмную сторону перешедших. Рассказать хотим про 3D-инсталяции создание. Интерактивная будет она и тематическая.
Введение
--------
#### Предыстория
На этот проект меня вдохновила моя жена, когда мы вместе ходили по магазинам перед Рождеством. Как раз вышел очередной эпизод «Звёздных войн», и полки в магазинах ломились от игрушек из этого фильма. Жена окликнула меня и спросила, не закончился ли ещё конкурс Hackster на тему «Звёздных войн». Она сказала, что увидела несколько интересных вещей, из которых можно было бы собрать что-нибудь классное.
В итоге мы купили несколько игрушек и придумали забавную интерактивную инсталляцию на стену.
За основу мы взяли небольшую панель, разместив на ней звуковую карту и, конечно, лампочки, чтобы было много света. Также мы установили датчик движения и ультразвуковой датчик расстояния для обнаружения людей поблизости. Датчик освещенности тоже присутствует.
Наша панель — интерактивная, она реагирует на человека, стоящего перед ней или проходящего мимо. Глаза Дарта Вейдера загораются красным, активация и деактивация светового меча сопровождаются звуками, которые всем знакомы с детства. Звезда Смерти также используется как ночной светильник. Она включается в темноте, когда срабатывает датчик движения. Наконец, иногда Дарт Вейдер разговаривает.
Происходит это спонтанно, но не постоянно. Основная идея — это должно случаться, «когда меньше всего ждёшь». Таким образом Дарт Вейдер уже напугал нескольких членов нашей семьи.
Для управления инсталляцией также можно использовать универсальное приложение Windows 10 и облачный веб-интерфейс API Particle.io.
Вот так это выглядит сейчас (панель целиком (**122 х 91 см**)).
#### Конструктивное исполнение
Инсталляция состоит из четырёх модулей, которые взаимодействуют с помощью шины **I2C**. Главный контроллер реализован на базе платформы Particle Photon, он отвечает за опрос датчиков, управление другими платами и коммуникации через облако. Есть ещё три вспомогательных контроллера на базе **Adafruit Trinket Pro 5V**, они управляют световым мечом, Звездой Смерти, глазами Дарта Вейдера и звуковыми эффектами.
Благодаря белой светодиодной подсветке Звезда Смерти становится отличным ночным светильником. В глазах Дарта Вейдера установлены светодиодные модули Adafruit NeoPixel Jewels (по семь светодиодов NeoPixels в каждом). Световой меч — это **100** светодиодов RGBW NeoPixels (кусок ленты со **144** светодиодами на метр). В шлеме Дарта Вейдера (в прорези для рта) и в Звезде Смерти установлено по динамику.
Процесс сборки
--------------
#### Панель
Фанера обычно продается в листах размером **122 х 244 см**, я обрезал её до **122 х 91 см**. Чтобы отделка смотрелась чисто и аккуратно, были выбраны листы более высокого качества. Тем не менее любую фанеру необходимо предварительно слегка обработать по краям и на лицевой стороне. Для этого я использовал наждачную бумагу зернистостью 220. После чего протёр обработанные поверхности смоченной тряпкой и дал им полностью высохнуть.
Свою панель мы покрыли краской **Glidden Blue Grey Sky (30BB 32/067)**.
#### Рамка
Рамка сделана из сосновой рейки размером **2,5 х 5 см (1,9 к 4,45 см)**. Пазы получились **122** и **91 см** для длинной и короткой сторон соответственно. По краям реек добавлены срезы под углом **45°**, чтобы получить рамку для полноценного подрамника.
Подготовив рейки и плотно посадив их на место с каждой стороны доски, необходимо окончательно закрепить их с помощью клея для дерева и угловых зажимов. Склеиваем края таким образом, чтобы смежные стороны находились под прямым углом.
Чтобы усилить рамку, я использовал **8** проволочных гвоздей **# 18 x 3/4"** (по **2** шт. на каждый угол). Нужно просверлить направляющее отверстие для каждого гвоздя, иначе мы рискуем расколоть древесину. Кончик гвоздя необходимо утопить с помощью небольшого пробойника.
После того как клей высохнет, заполняем углы деревянной шпатлевкой, чтобы избавиться от зазоров. Также необходимо зашпаклевать места, где были вбиты гвозди.
Перед покраской пройдёмся по всей поверхности рамки наждачкой, а затем протрём обработанные поверхности смоченной тряпкой и полностью высушим.
Рамку мы покрыли краской **Glidden Grey Metal (00NN 10/000)**.
#### Крепление рамки
Рамка крепится к панели с помощью небольших латунных шарниров, которые продаются в любом хозяйственном магазине. Незначительное перекрытие спереди можно устранить с помощью большой палочки для перемешивания краски толщиной около **4–5 мм**. Далее переворачиваем панель лицевой стороной вниз и подкладываем палочку, чтобы добиться желаемой высоты. Закрепим шарниры на панели с помощью прилагаемых шурупов. Направляющее отверстие необходимо просверлить для каждого шурупа, иначе рискуем расколоть древесину. Важно соблюдать осторожность и каждый раз оставлять зазор с лицевой стороны панели.
У меня всего **12** шарниров, соединяющих рамку с доской (по **3** вдоль каждой стороны). Два боковых шарнира расположены на расстоянии около **13 см** от внутреннего угла, а третий — по центру соответствующей стороны. Ниже лицевая сторона панели, на ней виден зазор между панелью и рамкой.
#### Размещение наклеек и моделей
Дарт Вейдер, световой меч и Звезда Смерти (это все светильники) продавались сразу с наклейками, создающими особый визуальный эффект: они как будто пробили основание насквозь. Мы сделали фон серым специально, чтобы подчеркнуть это эффект.
Далее выбираем оптимальное размещение этих трёх элементов на панели. Здесь вы можете положиться на свой художественный вкус. Определившись с расположением, закрепляем наклейки в соответствии с прилагаемой инструкцией. Обратите внимание, что в инструкции сказано, что окрашенной стене необходимо дать до двух недель, чтобы хорошенько высохнуть. Мы действительно ждали две недели, прежде чем наклеивать наклейки. Вот так выглядят все три наклейки.
Дополнительные наклейки мы купили на сайте Amazon, причём из набора пригодилось далеко не всё. Думаю, что каждый сам для себя решит, какое количество и какой тип наклеек захочет сделать.
Я усилил 3D-эффект с помощью моделей штурмовиков (звездолеты Hot Wheels TIE Fighters), прикрепив их к панели с помощью клеевого пистолета. Этот шаг можно пропустить.
В комплекте настенных светильников есть все необходимые шурупы для закрепления светильников на панели. Как обычно, рекомендую просверлить направляющие отверстия.
#### Шлем Дарта Вейдера
Из всех светильников необходимо предварительно вытащить встроенную электронику. К счастью, для этого нужно открутить всего несколько винтов.
Сначала снимаем заднюю крышку у головы Дарта Вейдера. Далее откручиваем винты, удерживающие светодиоды и выключатель, отрезаем провода, ведущие к батарейному отсеку. Эти компоненты, возможно, пригодятся для другого проекта. :)
Потом, для подготовки светодиодных модулей NeoPixel Jewels, подкючаем провода **22 AWG** к каждой из трех клемм. Рекомендую использовать красный провод для **5 В**, черный для заземления и зелёный для интерфейса. Отрезаем куски длиной около **90 см** и припаиваем сначала красный провод к контакту **5 В** первого модуля Jewel, затем чёрный провод. Наконец, припиаваем зелёный провод к контакту **Data In**.
Следующий модуль Jewel будет подключаться к первому. Снова отрезаем провода трёх цветов, на этот раз по **25 см**. Припаиваем красный провод к контактам **5 В** на первом и втором модуле Jewel. Красный провод припаиваем к контактам **GND** на первом и втором модуле Jewel. Наконец, зелёный провод — к контакту **Data Out** на первом модуле и контакту **Data In** на втором модуле.
Чтобы прикрепить модули к пластине шлема, используем трубочки для напитков. Они нужны для того, чтобы свет был виден через тёмные глазницы. Сначала нарезаем куски по 5 см (в этом примере использованы более толстые трубочки, но обычные тоже подойдут). Далее размещаем модули ближе к верхней части шлема. Для их крепления к задней части модулей NeoPixel и к пластине шлема используем клеевой пистолет. Одной трубочки вполне достаточно для надёжной фиксации, но, на всякий случай, я решил использовать вторую.
Наконец, нам нужно установить динамик в шлем. Приелкиваем его к пластине на уровне рта. В шлеме есть небольшой кусок металла, который приглушал бы звук, поэтому его нужно убрать. Для этого достаточно открутить несколько винтов. Далее, с помощью клеевого пистолета закрепляем динамик на пластине шлема.
Чтобы вывести провода, сверлим в центре пластины отверстие диаметром **6 мм (1/4")**. Не забудьте, вам нужно будет прикрепить пластину к панели без передней части шлема. Поэтому стоит просверлить новые отверстия в панели через отверстия в пластине. Таким образом, провода от шлема пройдут через отверстие в пластине и отверстие в панели, чтобы их можно было собрать в один пучок сзади.
Подключив светодиоды и динамик, пропускаем провода через отверстие и ставим пластину шлема на место. Не забудьте закрутить винты. :)
#### Световой меч
Разобрать световой меч немного сложнее. В итоге у вас должно получиться четыре отдельных элемента.
Сначала снимаем красную пластиковую трубку, имитирующую луч. Она просто отвинчивается и вытаскивается. Внутри неё вы найдёте вторую часть — длинную прозрачную пластиковую трубку. Это свернутый кусок пластика, на котором мы потом закрепим полосу светодиодов NeoPixel. Отложите этот элемент в сторону.
Следующий элемент, который нужно снять, — это пластина-основание. Отвинчиваем три винта. Должно получиться вот так.
Далее снимаем боковую часть рукояти светового меча и удаляем всю электронную начинку.
После этого обрезаем ленту NeoPixel, оставив на ней **100 светодиодов**. Если вы никогда этого не делали, вам будет полезно руководство [Adafruit Uberguide](https://learn.adafruit.com/adafruit-neopixel-uberguide).
Отрезаем три куска провода **22 AWG** примерно по **60 см**. Берём красный, чёрный и зелёный провода (кстати, лично я часто использую зелёный, белый или жёлтый провода в качестве интерфейсного провода для модулей NeoPixel), припаиваем красный провод к контакту **5 В**, чёрный — к контакту **GND**, а зелёный — к контакту **Data In**.
Дальше очень аккуратно протягиваем ленту NeoPixel в прозрачную пластиковую трубку, стараясь сильно её не гнуть.
После чего пропускаем провода через нижнюю пластину, как показано на фото ниже.
Протянув провода, закрепляем боковую пластину с помощью пяти винтов. Затем прикрепляем заднюю панель и протягиваем провода через отверстие, в котором находился переключатель. Там, где провода будут проходить через основную панель, необходимо просверлить отверстие диаметром **6 мм (1/4")**.
#### Макетирование
Составляем прототип каждой схемы, используя изображения в спойлерах.
> **Главные контроллер и контроллер светового меча**Схема (главный контроллер)
>
> 
>
>
>
> Схема (контроллер светового меча)
>
> 
>
>
>
> Как получилось у меня
>
> 
>
>
>
> **Контроллер звука**Схема
>
> 
>
>
>
> Как получилось у меня
>
> 
>
>
>
> **Контроллер Звезды Смерти/глаз Дарта Вейдера**Схема
>
> 
>
>
>
> Как получилось у меня
>
> 
>
>
>
> Контроллер Звезды Смерти крупным планом
>
> 
>
>
>
> Контроллер глаз Дарта Вейдера крупным планом
>
> 
>
>
>
> **Дополнительно**Так выглядят остальные части.
>
>
>
> Сенсор движений, ультразвуковой датчик и кольцо NeoPixel (сверху вниз)
>
> 
>
>
>
> Один модуль NeoPixel для тестирования глаз Дарта Вейдера
>
> 
>
>
>
> Миниатюрная монтажная плата для разводки **12 В** на все платы
>
> 
>
>
Обратите внимание, что вы должны уметь собирать макеты плат по схемам.
**Примечание**. Я использовал:
* дополнительные высокие однорядные монтажные платы с выводами в своём макете, а затем стандартные монтажные платы с выводами при пайке на печатных платах;
* кольцо NeoPixel вместо ленты NeoPixel (для светового меча);
* один модуль NeoPixel вместо двух (для глаз);
* миниатюрную монтажную плату для разводки **12 В** на все остальные платы.
В итоге, у нас получается вот такая cхема.
Для реализации этой части проекта потребуется значительное время (хотя, конечно не 2 недели :) ), кроме того, вы должны обратить пристальное внимание на схемы и размещение компонентов на макетах. Кстати, я использовал макетные платы Adafruit Perma-Proto.
Если всё прошло успешно, у вас получится такой результат.
#### Печатные платы
После сборки и тестирования макетов, схемы можно переносить на печатные платы (в моём случае это Perma-Proto).
Поочередно переносим схемы, припаивая детали. Лучше, чтобы у вас были запасные детали, чтобы скопировать схему, а не переносить её. Это поможет избежать ошибок.
**Примечание**:
* Я использовал стандартные однорядные монтажные платы с выводами для силовых соединений и соединений I2C. Для разводки питания отделил по два контакта. Для I2C отделил по три контакта.
* Взял **3-контактные клеммные** колодки для двух соединений NeoPixel. Это детали размером **3,5 мм**. Они должны быть припаяны к плате по диагонали.
* Также, использовал **28-контактные** разъёмы IC Sockets размером **1,5 см (0,6")** для Trinket Pro.
* Для размещения модуля Photon я взял **0,25-сантиметровые (0,1") 36-контактные** монтажные разъёмы с выводами. Отрезал два комплекта по 12 контактов для модуля Photon.
* Для подключения батареи монетного типа к контактам **GND** и **VBAT** модуля Photon я взял два контакта от монтажного разъёма с выводами.
* Как минимум для двух монтажных схем потребуется двойной комплект монтажных плат для перемычек **12 В**, либо вы можете использовать 3 набора для одной из схем. Питание будет подаваться с тыльной стороны панели, и его необходимо развести по всем платам.
* Шину **I2C** необходимо подключить к каждой монтажной плате. Для этого я припаял два комплекта монтажных плат как минимум для двух схем.
В спойлерах ниже вы найдёте фото получившихся схем.
> **Общий вид**
>
>
>
> **Вид сбоку крупным планом**
>
>
>
> **Контроллер Звезды Смерти/глаз Дарта Вейдера**
>
>
>
> **Основной контроллер**
>
>
>
> **Контроллер светового меча**
>
>
Если всё прошло успешно, у вас получится такой результат.
#### Звезда Смерти
Я выбрал Звезду Смерти, чтобы разместить в ней все электронные компоненты. Она идеально вписывается в концепцию и предоставляет достаточно свободного места.
Для начала необходимо её разобрать и удалить всю базовую электронику. Сначала откручиваем винты с задней стороны, потом винты, крепящие электронные компоненты, после чего отрезаем провода от батарейного отсека.
Собранные ранее схемы закрепляем на панели Звезды Смерти. Для этого используем распорки (или штифты) **M3**, винты **M3**, гайки **M3** и по две шайбы **M3** для каждой распорки. Всего распорок будет восемь (по две на каждую печатную плату).
Начинаем с крепления латунных штифтов к каждой плате с помощью гайки M3 (для этого вам, возможно, потребуется снять модули Trinket и Photon).
Три платы меньшего размера можно разместить с использованием уже имеющихся пазов на пластине. Для большой платы нужно просверлить отверстия. Далее, с внешней стороны пластины вкручиваем винт и шайбу, размещаем большую плату и карандашом помечаем точки, где будут закреплены штифты. Убираем плату и просверливаем отверстия для винтов. Порядок плат не имеет значения, поэтому каждый может подобрать оптимальную компоновку для себя и затем закрепить платы.
По аналогии со шлемом Дарта Вейдера нам понадобится центровочное отверстие, которое нужно сопоставить с отверстием в панели. Через него провода пройдут к задней стороне панели, куда будет подключен световой меч и шлем Дарта Вейдера.
У меня получилась вот такая компоновка плат. Обратите внимание на отверстие, просверленное вверху слева.
Далее подключаем двухпроводной разъём светодиодной подсветки и закрепляем его с помощью термоусадочной трубки. На фото ниже вы можете увидеть подготовку светодиода.
Второй динамик будет установлен внутри Звезды Смерти. Вышло так, что монтажные отверстия на динамике совпали с винтами внутри Звезды Смерти, как показано ниже. Поэтому подключаем динамик к клеммам звуковой карты. После чего крепим светодиодную подсветку с помощью клеевого пистолета над зелёным пластиковым куполом внутри Звезды Смерти.
По аналогии с процессом крепления светодиода, делаем выводы фоторезистора и проводим провода через отверстия на правой стороне купола (в сторону от светового меча). С внутренней стороны подключаем двухпроводной разъём к фоторезистору и помещаем его в термоусадочную трубку, как показано ниже.
В нижней части купола сверлим отверстия диаметром **1,3 см (1/2")** для датчика движения и ультразвукового датчика расстояния. Подключаем четырёхпроводной разъём к каждому датчику и протягиваем датчики в отверстия, после чего закрепляем их с внешней стороны купола с помощью клеевого пистолета.
Далее нарезаем два комплекта из трёх проводов **22 AWG** длиной примерно **60 см** для соединений NeoPixel и подключаем их к клеммам на плате. Красный провод — для 5В, чёрный — для **GND** и зелёный (или жёлтый) — для интерфейса. Цветовая кодировка в дальнейшем упростит подключение компонентов на задней панели платы. С помощью изоленты и маркера я пометил эти провода, чтобы легко идентифицировать их позже (я написал «световой меч» и «Дарт Вейдер»).
Далее отрезаем ещё два провода для динамика: красный и чёрный (лучше взять **26 AWG**, но **22 AWG** тоже подойдет), и подключаем их к клеммам. Двухпроводную розетку подключаем к разъёму **12 В** на плате Photon.
На этом этапе провода можно зачистить и закрепить с помощью хомутиков и изоленты. Сначала заводим шесть проводов от NeoPixel, провода от двух динамиков и провод питания через отверстие в пластине. С помощью изоленты их так, чтобы нельзя было вытащить с обратной стороны платы, после чего объединяем в пучки и стягиваем хомутиками.
Теперь собираем Звезду Смерти и пропускаем все провода через отверстие в панели.
На этом этапе подключаем все устройства. Провода на обратной стороне платы нужно подключить, используя наконечники, после чешго закрепить их с помощью изоленты или каких-либо клейких крепежных приспособлений. Не стоит оставлять слишком большой запас длины проводов, но при этом его должно быть достаточно, чтобы, в случае необходимости, можно было снова снять какой-либо из компонентов.
Программное обеспечение и приложения
------------------------------------
Программное обеспечение для этого проекта можно разделить на три категории.
**Во-первых**, это встроенное ПО для Photon. Это программное обеспечение управляет другими платами и поддерживает с ними связь через шину **I2C**. **Во-вторых**, это код Arduino, который загружается в каждый из трёх модулей Trinket Pro. **В-третьих**, это программное обеспечение Windows 10 UWP, которое используется на устройствах Windows 10 для удалённого управления нашей интерактивной инсталляцией.
Код в спойлере ниже — это встроенное ПО для Photon. Файлы классов, ссылки на которые присутствуют в коде, можно найти в [репозитории GitHub для этого проекта](https://github.com/porrey/StarWars).
**Немного кода :)**
```
#include "Controller.h"
#include "HC-SR04.h"
#include "SensorSmoothing.h"
// ***
// *** Два контакта, к которым подключается HC-SR04.
// ***
#define TRIGGER_PIN D2
#define ECHO_PIN D3
// ***
// *** Два контакта для подключения датчика движения
// ***
#define MOTION_OUT D4
#define MOTION_ENABLED D5
// ***
// *** Контакт фоторезистора
// ***
#define PHOTORESISTOR_PIN A0
// ***
// *** Количество измерений для усреднения
// ***
#define NUMBER_OF_SAMPLES 5
// ***
// *** Громкость по умолчанию
// ***
#define DEFALT_VOLUME 15
// ***
// *** Главный контроллер, который отправляет
// *** команды всем устройствам.
// ***
retained int _volume = DEFALT_VOLUME;
// ***
// *** Определяем контроллер.
// ***
Controller _controller = Controller();
// ***
// *** Создаем объект HcSr04 для
// *** HC-SR04 (ультразвуковой датчик расстояния).
// ***
HcSr04 _ranging = HcSr04();
// ***
// *** Эта переменная сигнализирует об
// *** обнаружении движения.
// ***
bool _motion = false;
// ***
// *** Эта переменная сигнализирует об
// *** обнаружении движения.
// ***
double _distance = 0.0;
// ***
// *** Аналоговая величина на контакте фоторезистора.
// ***
int _light = 0;
// ***
// *** В этом объекте будем хранить текущее среднее
// *** для выборки размером NUMBER_OF_SAMPLES.
// *** Это необходимо для предотвращения ложных или
// *** слишком частых срабатываний датчика движения.
// ***
SensorSmoothing \_distanceSample = SensorSmoothing(NUMBER\_OF\_SAMPLES);
// \*\*\*
// \*\*\* Таймер для опроса датчика
// \*\*\*
Timer \_sensorTimer(1000, onSensorTimer);
// \*\*\*
// \*\*\* Время возникновения последнего события
// \*\*\*
int \_lastEventTime = 0;
// \*\*\*
// \*\*\* Порог освещенности
// \*\*\*
#define DEFAULT\_LIGHT\_THRESHOLD 1000
retained int \_lightThreshold = DEFAULT\_LIGHT\_THRESHOLD;
bool \_lightBelowThreshold = false;
bool \_deathStarIsOn = false;
// \*\*\*
// \*\*\* Параметры для датчика движения
// \*\*\*
retained int \_minimumEventTime = 20; // секунды
retained int \_minimumDistance = 127; // сантиметры
void setup()
{
// \*\*\*
// \*\*\* Вывод сообщения о ходе настройки
// \*\*\*
Particle.publish("Setup", "Started");
// \*\*\*
// \*\*\* Активация ОЗУ для резервного копирования
// \*\*\*
STARTUP(System.enableFeature(FEATURE\_RETAINED\_MEMORY));
// \*\*\*
// \*\*\* Инициализация модуля HC-SR04 (ультразвуковой датчик расстояния)
// \*\*\*
\_ranging.begin(TRIGGER\_PIN, ECHO\_PIN);
// \*\*\*
// \*\*\* Настройка шины I2C
// \*\*\*
Wire.begin();
// \*\*\*
// \*\*\* Инициализация контроллера
// \*\*\*
\_controller.begin(\_volume);
// \*\*\*
// \*\*\* Включение индикатора D7 при активации
// \*\*\* светового меча
// \*\*\*
pinMode(D7, OUTPUT);
digitalWrite(D7, LOW);
// \*\*\*
// \*\*\* Набор общедоступных переменных
// \*\*\*
Particle.variable("motion", \_motion);
Particle.variable("distance", \_distance);
Particle.variable("light", \_light);
// \*\*\*
// \*\*\* Публикуем функции.
// \*\*\*
Particle.function("controller", controllerWebApi);
Particle.function("parameter", parameterWebApi);
Particle.function("test", testWebApi);
// \*\*\*
// \*\*\* Устанавливаем в качестве времени появления последнего события
// \*\*\* текущее время.
// \*\*\*
\_lastEventTime = Time.now();
// \*\*\*
// \*\*\* Запускаем таймер.
// \*\*\*
\_sensorTimer.start();
// \*\*\*
// \*\*\* Даем другим платам время для запуска,
// \*\*\* на случай если мы только что включили питание.
// \*\*\*
delay(3000);
// \*\*\*
// \*\*\* Сброс
// \*\*\*
\_controller.darthVaderOff();
\_controller.lightSaberOff();
\_controller.deathStarOff();
// \*\*\*
// \*\*\* Вывод сообщения о ходе настройки
// \*\*\*
Particle.publish("Setup", "Completed");
}
void loop()
{
// \*\*\*
// \*\*\* Временное сохранение значения \_lightBelowThreshold
// \*\*\*
bool previousLightBelowThreshold = \_lightBelowThreshold;
// \*\*\*
// \*\*\* Проверка наличия движения
// \*\*\*
if (\_motion)
{
// \*\*\*
// \*\*\* Проверка уровня освещенности и принятие решения
// \*\*\* о необходимости включения
// \*\*\* подсветки.
// \*\*\*
if (\_light < \_lightThreshold)
{
if (!previousLightBelowThreshold)
{
Particle.publish("Light", "Below Threshold");
}
\_lightBelowThreshold = true;
// \*\*\*
// \*\*\* Включить светодиод Звезды смерти.
// \*\*\*
\_deathStarIsOn = true;
\_controller.deathStarOn();
}
else
{
if (previousLightBelowThreshold)
{
Particle.publish("Light", "Above Threshold");
}
\_lightBelowThreshold = false;
}
// \*\*\*
// \*\*\* Проверим, что объект находится на расстоянии менее метра.
// \*\*\*
if (\_distance < \_minimumDistance)
{
// \*\*\*
// \*\*\* Убедимся, что с момента последнего обновления
// \*\*\* прошло больше минимального
// \*\*\* промежутка времени.
// \*\*\*
if ((Time.now() - \_lastEventTime) > \_minimumEventTime)
{
Particle.publish("Object", "Detected");
\_lastEventTime = Time.now();
\_controller.randomEvent();
}
}
}
else
{
// \*\*\*
// \*\*\* Движения не обнаружено.
// \*\*\*
if (\_deathStarIsOn)
{
// \*\*\*
// \*\*\* Если уровень освещенности больше пороговой величины, выключить
// \*\*\* светодиод Звезды смерти.
// \*\*\*
\_deathStarIsOn = false;
\_controller.deathStarOff();
}
}
// \*\*\*
// \*\*\* Задержка
// \*\*\*
delay(150);
}
void onSensorTimer()
{
// \*\*\*
// \*\*\* Опрос датчика движения
// \*\*\*
bool previousMotion = \_motion;
// \*\*\*
// \*\*\* Получить текущий статус датчика движения.
// \*\*\*
\_motion = (digitalRead(MOTION\_OUT) == HIGH);
// \*\*\*
// \*\*\* Публикация события происходит только при изменении состояния
// \*\*\* датчика движения.
// \*\*\*
if (!previousMotion && \_motion)
{
Particle.publish("Motion", "Detected");
if (\_lightBelowThreshold)
{
Particle.publish("Light Level", "Below Threshold: " + String(\_light) + "/" + String(\_lightThreshold));
}
else
{
Particle.publish("Light Level", "Above Threshold: " + String(\_light) + "/" + String(\_lightThreshold));
}
// \*\*\*
// \*\*\* Публикация события с информацией о расстоянии до
// \*\*\* объекта, находящегося напротив панели.
// \*\*\*
Particle.publish("Distance", String(String(\_distance / 2.54).toInt()) + " in / " + String(String(\_minimumDistance / 2.54).toInt()) + " in");
// \*\*\*
// \*\*\* Публикация события с информацией о периоде времени
// \*\*\* до инициации следующего события.
// \*\*\*
Particle.publish("Time", "Last Event: " + String(Time.now() - \_lastEventTime) + " second(s) ago");
}
else if (previousMotion && !\_motion)
{
Particle.publish("Motion", "Reset");
}
// \*\*\*
// \*\*\* Получение данных о расстоянии от ультразвукового
// \*\*\* датчика
// \*\*\*
\_distance = getRangeEx();
// \*\*\*
// \*\*\* Опрос фоторезистора
// \*\*\*
\_light = analogRead(PHOTORESISTOR\_PIN);
}
// \*\*\*
// \*\*\* Веб-API
// \*\*\*
int testWebApi(String command)
{
// \*\*\*
// \*\*\* Тестирование
// \*\*\*
Particle.publish("Test", "Running");
\_controller.setVolume(10);
delay(500);
\_controller.darthVaderOn();
delay(1000);
\_controller.darthVaderVoice(0);
delay(18000);
\_controller.darthVaderOff();
delay(3000);
\_controller.darthVaderOn();
delay(1000);
\_controller.darthVaderVoice(1);
delay(5000);
\_controller.darthVaderOff();
delay(3000);
\_controller.darthVaderOn();
delay(1000);
\_controller.darthVaderVoice(2);
delay(5000);
\_controller.darthVaderOff();
delay(3000);
\_controller.darthVaderOn();
delay(1000);
\_controller.darthVaderVoice(3);
delay(5000);
\_controller.darthVaderOff();
delay(3000);
\_controller.darthVaderOn();
delay(1000);
\_controller.darthVaderVoice(4);
delay(5000);
\_controller.darthVaderOff();
delay(3000);
\_controller.darthVaderOn();
delay(1000);
\_controller.darthVaderVoice(5);
delay(5000);
\_controller.darthVaderOff();
delay(3000);
\_controller.darthVaderOn();
delay(1000);
\_controller.darthVaderVoice(6);
delay(5000);
\_controller.darthVaderOff();
delay(3000);
\_controller.darthVaderOn();
delay(1000);
\_controller.darthVaderVoice(7);
delay(5000);
\_controller.darthVaderOff();
delay(3000);
\_controller.darthVaderOn();
delay(1000);
\_controller.darthVaderVoice(8);
delay(5000);
\_controller.darthVaderOff();
delay(3000);
\_controller.lightSaberOn(7000);
delay(2000);
\_controller.deathStarOn();
delay(5000);
\_controller.deathStarOff();
Particle.publish("Test", "Completed");
return 1;
}
// \*\*\*
// \*\*\* Веб-API
// \*\*\*
int parameterWebApi(String command)
{
int returnValue = 0;
// \*\*\*
// \*\*\* Если команда содержит аналогичный
// \*\*\* признак, будем считать, что система пытается
// \*\*\* задать значение параметра.
// \*\*\*
int equalIndex = command.indexOf("=");
// \*\*\*
// \*\*\* Проверка значения команды для типа
// \*\*\* вызова параметра.
// \*\*\*
if (equalIndex > 0)
{
// \*\*\*
// \*\*\* Эта команда устанавливает значение переменной.
// \*\*\*
String parameterName = command.substring(0, equalIndex);
String value = command.substring(equalIndex + 1, command.length());
if (parameterName == "volume")
{
\_volume = value.toInt();
\_controller.setVolume(\_volume);
}
else if (parameterName == "minimumDistance")
{
\_minimumDistance = value.toInt();
}
else if (parameterName == "lightThreshold")
{
\_lightThreshold = value.toInt();
}
else if (parameterName == "minimumEventTime")
{
\_minimumEventTime = value.toInt();
}
// \*\*\*
// \*\*\* Опубликовать параметр.
// \*\*\*
Particle.publish("Set Parameter", parameterName + " = " + value);
// \*\*\*
// \*\*\* Вернуть значение.
// \*\*\*
returnValue = value.toInt();
}
else if (equalIndex == -1)
{
// \*\*\*
// \*\*\* Если команда имеет аналогичное имя,
// \*\*\* вернуть значение.
// \*\*\*
if (command == "volume")
{
returnValue = \_volume;
}
else if (command == "minimumDistance")
{
returnValue = \_minimumDistance;
}
else if (command == "lightThreshold")
{
returnValue = \_lightThreshold;
}
else if (command == "minimumEventTime")
{
returnValue = \_minimumEventTime;
}
// \*\*\*
// \*\*\* Опубликовать параметр.
// \*\*\*
Particle.publish("Get Parameter", command);
}
else if (command == "reset")
{
// \*\*\*
// \*\*\* Вернуть значения параметров по умолчанию.
// \*\*\*
\_volume = DEFALT\_VOLUME;
\_controller.setVolume(\_volume);
\_minimumDistance = 50 \* 2.54;
\_lightThreshold = 1000;
\_minimumEventTime = 20;
\_lightThreshold = DEFAULT\_LIGHT\_THRESHOLD;
// \*\*\*
// \*\*\* Опубликовать параметр.
// \*\*\*
Particle.publish("Reset Parameters", "");
returnValue = 1;
}
return returnValue;
}
// \*\*\*
// \*\*\* Веб-API
// \*\*\*
int controllerWebApi(String command)
{
int returnValue = 0;
// \*\*\*
// \*\*\* Опубликовать параметр.
// \*\*\*
Particle.publish("Controller", command);
// \*\*\*
// \*\*\* Передать команду в контроллер.
// \*\*\*
returnValue = \_controller.executeCommand(command);
return returnValue;
}
double getRangeEx()
{
double returnValue = 0;
// \*\*\*
// \*\*\* Получить расстояние в сантиметрах.
// \*\*\*
Range range;
if (\_ranging.getRange(⦥))
{
// \*\*\*
// \*\*\* Добавить замер.
// \*\*\*
\_distanceSample.addSample(range.distance);
// \*\*\*
// \*\*\* Вернуть среднее расстояние.
// \*\*\*
returnValue = \_distanceSample.average();
}
else
{
// \*\*\*
// \*\*\* Проверить результат.
// \*\*\*
if (range.result == timeFailed)
{
switch (range.pingTime.result)
{
case alreadyActive:
Particle.publish("Result", "The sensor is busy.");
break;
case timeout:
Particle.publish("Result", "The sensor did not respond.");
break;
}
}
else if (range.result == underRange)
{
switch (range.result)
{
case underRange:
Particle.publish("Result", "The object is too close.");
break;
case overRange:
Particle.publish("Result", "No object is in range.");
break;
}
}
else
{
Particle.publish("Result", "Unknown Error.");
}
}
return returnValue;
}
```
Ниже скрины того, что у нас получилось.
Главный экран для управления эффектами и меню.
Настройка облачного API для Photon и настройка параметров.
Код Windows 10 обращается к облачному интерфейсу API Particle.io с помощью `HttpClient` для выполнения определенных функций, используя `Particle.function()`, как показано далее.
```
protected async virtual Task Execute(string functionName, string command)
{
int returnValue = 0;
HttpClient httpClient = new HttpClient();
HttpRequestMessage request = new HttpRequestMessage();
var values = new List>
{
new KeyValuePair("args", command)
};
FormUrlEncodedContent content = new FormUrlEncodedContent(values);
request.Headers.Authorization = this.Identity.Authentication;
request.Method = this.Method;
request.RequestUri = new Uri(this.Identity.BaseUri, string.Format(this.Resource, functionName));
request.Content = content;
HttpResponseMessage response = await httpClient.SendAsync(request);
if (response.IsSuccessStatusCode)
{
string json = await response.Content.ReadAsStringAsync();
dynamic obj = JsonConvert.DeserializeObject(json);
string value = obj.return\_value;
returnValue = Convert.ToInt32(value);
}
else
{
throw new HttpRequestException(response.ReasonPhrase);
}
return returnValue;
}
```
В приведённом ниже коде показано, как получить значение переменной, определенной с использованием `Particle.variable()`.
```
protected async override Task Execute(params string[] args)
{
T returnValue = default(T);
HttpClient httpClient = new HttpClient();
HttpRequestMessage request = new HttpRequestMessage();
request.Headers.Authorization = this.Identity.Authentication;
request.Method = HttpMethod.Get;
request.RequestUri = new Uri(this.Identity.BaseUri, string.Format(this.Resource, args));
HttpResponseMessage response = await httpClient.SendAsync(request);
if (response.IsSuccessStatusCode)
{
string json = await response.Content.ReadAsStringAsync();
dynamic obj = JsonConvert.DeserializeObject(json);
string value = obj.result;
returnValue = (T)Convert.ChangeType(value, typeof(T));
}
else
{
await this.OnFailed(response);
}
return returnValue;
}
```
Всё программное обеспечение доступно [в репозитории GitHub для этого проекта](https://github.com/porrey/StarWars). Список всех компонентов для проекта и ссылки на их покупку, можно найти на [сайте](https://microsoft.hackster.io/en-US/porrey/interactive-star-wars-3d-art-a71471).
Как это работает
----------------
В этом видео показаны различные эффекты, поддерживаемые этой интерактивной инсталляцией. В жизни панель включается автоматически по сигналу от датчика движения. | https://habr.com/ru/post/328022/ | null | ru | null |
# Магия Chocolatey: apt-get и yum для Windows
Сегодня я расскажу Вам о волшебстве. И это волшебство способно изменить жизнь системного администратора Windows раз и навсегда.
В наше время становится все меньше и меньше людей, которые хоть раз не устанавливали софт в среде Linux. Это невероятно просто: для установки midnight commander (mc), в среде RH (RedHat Enterprise, CentOS, Fedora, и т.д) нам всего лишь нужна пара «волшебных» команд:
```
# yum install mc
```
Менеджер пакетов yum позаботится о том, чтобы установилась самая свежая версия *mc*, а также о зависимостях пакета, если таковые имеются. Но что же делать, если в нашем распоряжении находится Windows, а мы хотим что-то подобное? Правильно, перейти на Linux или читать дальше!
Под моей «опекой» находится гетерогенная сеть из Windows и Linux машин (проще сказать — зоопарк), и вот уже около двух лет для установки софта под Win\* я пользуюсь, где это возможно, Chocolatey. Chocolatey ([chocolatey.org](http://chocolatey.org/), [github.com/chocolatey](https://github.com/chocolatey/chocolatey)) — система управления пакетами, во многом схожая с apt-get или yum, но только для Windows.
На хабре уже касались темы Chocolatey в контексте разработчика, сегодня я хочу взглянуть на этот замечательный инструмент с точки зрения системного администратора. Chocolatey работает на основе технологии NuGet (активно используется разработчиками софта под Windows), и основная черта Chocolatey — пакеты чаще всего **не** содержат установочных файлов (setup.msi, setup.exe, и т.д...). Работает это следующим образом: в пакете находится скрипт-установщик на powershell, который скачивает и устанавливает нужную версию установочного файла из нужного места в интернете, а Вам остается только наслаждаться легкостью установки.
Установка Chocolatey
--------------------
Прежде чем получить возможность использовать магию Chocolatey нам нужно установить ее ядро. Для этого запускаем в командной строке:
```
@powershell -NoProfile -ExecutionPolicy unrestricted -Command "iex ((new-object net.webclient).DownloadString('https://chocolatey.org/install.ps1'))" && SET PATH=%PATH%;%systemdrive%\chocolatey\bin
```
Эта команда скачает и запустит основной скрипт установки *[chocolatey.org/install.ps1](https://chocolatey.org/install.ps1)*, а также настроит требуемые переменные окружения. Теперь, когда у нас есть все необходимое давайте испытаем систему управления пакетами и установим Nodepad++. Достаточно выполнить следующую команду:
```
cinst notepadplusplus
```
Какие еще есть пакеты и откуда они берутся?
-------------------------------------------
Как и NuGet, Chocolatey обладает внушительным списком пакетов, который располагается в репозитории, он же [библиотека пакетов](http://chocolatey.org/packages). Вот только некоторые из них:
**Топ 10 самых популярных пакетов на chocolatey.org*** Git — 51191 скачиваний
* Notepad++ — 37533 скачиваний
* 7Zip — 37802 скачиваний
* Google Chrome — 25960 скачиваний
* Java Runtime — 25699 скачиваний
* NodeJS — 25542 скачиваний
* Mozilla Firefox — 20747 скачиваний
* Adobe Flash Player — 20660 скачиваний
* VLC Player — 20419 скачиваний
* Ruby 2.0 — 19587 скачиваний
Пакеты добавляются каждый день, ведь любой желающий может добавить свой пакет на chocolatey.org, главное чтобы он отвечал [требованиям](https://github.com/chocolatey/chocolatey/wiki/CreatePackages).
**Требования к публикации пакетов*** **Не публикуйте незаконные программы**. Программы, которые незаконны в большинстве стран мира также запрещены к размещению на Chocolatey.org. Это также применимо к программам, которые нарушает авторские права, пиратские программы и «кряки». Помните, что это также касается программ которые используются для пиратства.
* **Не пакуйте программы в chocolatey на которые у Вас нет прав на распространение**. Пожалуйста, уточняйте правила распространения программного обеспечения и не нарушайте их.
* **Не публикуйте вирусы либо любые другие программы наносящие вред**.
* **Публикуйте только те программы, которые будут полезны для других.** Если Ваш пакет не относится к этой категории — не публикуйте его.
* **Не публикуйте spyware или adware.** Программы, которые поставляются с встроенными adware или spyware или любыми другими нерелевантными программами не разрешены для публикации. Обычно все нерелевантные программы можно исключить из установки используя ключи установщика. Примерами таких программ являются [PDFCreator](https://github.com/stack72/MyChocolateyPackages/tree/master/PDFCreator) и [CCleaner](https://github.com/tonigellida/chocolateyautomaticpackages/tree/master/ccleaner).
* **Не публикуйте программы, которые уже опубликованы.** Используйте поиск по [Chocolatey.org](http://chocolate.org). Если Вы хотите улучшить уже существующий пакет — свяжитесь с человеком, который поддерживает пакет или отправьте pull-request в его репозиторий.
* **Не включайте другие программы в Ваш пакет, если для них уже есть свой пакет**. Если Вашему пакету требуется те или иные программы, существующий пакет должен быть включен Вами в качестве зависимости.
* **Разделяйте зависимости на несколько пакетов**. Старайтесь разделить пакет на как можно больше пакетов. Например программа поставляется с опциональными модулями. Создайте дополнительные пакеты для модулей, вместо того, чтобы включать их в общий пакет. Эта идея уже давно применяется в пакетах под Linux по той причине, что это позволяет создавать легковесные пакеты и минимизирует шанс конфликта.
##### Как это работает?
Я хотел бы подробнее разобрать содержание пакетов Chocolatey на примере [logstash](http://chocolatey.org/packages/logstash), который я создавал специально для развертывания агента logstash на сервере Windows:
```
\logstash
\tools
chocolateyInstall.ps1
logstash.nuspec
```
Здесь видно, что в пакете всего 2 файла: logstash.nuspec и chocolateyInstall.ps1.
**logstash.nuspec - файл, в котором описывается мета-информация пакета**
```
xml version="1.0"?
logstash
1.2.1.2013101701
logstash
kireevco
http://chocolatey.org/profiles/kireevco
https://github.com/kireevco/chocolatey-packages
http://logstash.net
http://logstash.net/images/logstash.png
false
Logstash is a tool for managing events and logs. You can use it to collect logs, parse them, and store them for later use (like, for searching). Speaking of searching, logstash comes with a web interface for searching and drilling into all of your logs. This package installs logstash flat jar as an agent service via nssm. All you need to do - is to configure your logstash.conf and start logstash service. Service is installed with these parameters: "java.exe -Xmx512M -jar logstash.jar agent --config logstash.conf --log logstash.log
"
Logstash Agent package
logstash, logging
```
В этом файле будет интересно разобрать секцию *dependencies*, в которой мы указываем что нашему пакету необходимо наличие 3х других пакетов определенных версий, а именно [javaruntime](http://chocolatey.org/packages/javaruntime), [NSSM](http://chocolatey.org/packages/NSSM) (позволяет установить наш .jar файл в качестве службы Windows), а также Chocolatey определенной версии. Если какой-либо из необходимых пакетов отсутствует, либо его версия не соответствует требуемой — система зависимостей разрешит ситуацию и приведет все к требуемому виду. Стоит отметить, что для указания версий используется [нотация nuget](http://docs.nuget.org/docs/reference/versioning).
**Powershell скрипт chocolateyInstall.ps1**
```
#Указываем откуда скачивать jar файл
$url='https://download.elasticsearch.org/logstash/logstash/logstash-1.2.1-flatjar.jar'
#Указываем путь где будет раполагаться управляющий cmd файл
$cmdfile='c:/logstash/logstash.cmd'
#Указываем куда копировать конфигурационный файл
$confile = 'c:/logstash/logstash.conf.sample'
$dir='c:/logstash'
if (!(Test-Path -path $dir)) {New-Item $dir -Type Directory}
Get-ChocolateyWebFile 'logstash' 'c:/logstash/logstash.jar' $url $url
$cmdcontent = @"
set HOME=c:/logstash/sincedb
cd /d c:\logstash
java.exe -Xmx512M -jar logstash.jar agent --config logstash.conf --log logstash.log
"@
Set-Content $cmdfile $cmdcontent -Encoding ASCII
#Создаем тестовый конфиг
$confcontent = @"
input {
stdin {}
}
output {
stdout {}
}
"@
Set-Content $confile $confcontent -Encoding ASCII
if ($serviceinfo = Get-Service "Logstash" -ErrorAction SilentlyContinue)
{
if ($serviceinfo.status -ne 'Running')
{
if ($serviceinfo.status -eq 'Stopped')
{
echo "Service found and is stopped. Deleting."
echo "Delete Service"
sc.exe \\localhost delete "Logstash"
nssm install "Logstash" C:\logstash\logstash.cmd
}
}
else
{
echo "Stop Service"
sc.exe \\localhost stop "Logstash"
echo "Delete Service"
sc.exe \\localhost delete "Logstash"
echo "Installing Service"
nssm install "Logstash" C:\logstash\logstash.cmd
}
}
else
{
#Устанавливаем службу через nssm
echo "Installing Logstash Service"
nssm install "Logstash" C:\logstash\logstash.cmd
}
```
Применение:
-----------
Многие админы, вероятно, побежали тестировать функционал — оно и правильно, ведь ничего сложного в использовании Chocolatey нет — в этом-то и есть сладость Chocolatey. Тем не менее, хотелось бы предложить несколько сценариев использования этого менеджера пакетов для Windows.
#### Cmd и Powershell скрипты
Все мы используем простейшие скрипты в нашей работе, и chocolatey как нельзя лучше интегрируется в этот процесс. Простейший скрипт для обычной клиентской машины может выглядеть так:
```
cinst flashplayerplugin
cinst flashplayeractivex
cinst notepadplusplus
cinst sublimetext2
cinst 7zip
cinst GoogleChrome
cinst javaruntime
cinst Firefox
cinst flashplayerplugin
cinst adobereader
cinst ccleaner
cinst sysinternals
cinst putty
cinst filezilla
cinst dropbox
cinst skype
cinst paint.net
cinst virtualbox
cinst DotNet4.5
cinst Wget
cinst ConEmu
cinst libreoffice
cinst PDFCreator
cinst teamviewer
cinst wuinstall.run
```
Представьте сколько времени это экономит Вам?
#### Puppet
Я использую Puppet для управления конфигурацией своей инфраструктуры, что экономит мне массу времени и нервов. В Puppet есть замечательная концепция ресурсов, а также декларативный стиль, которые в купе помогают мыслить абстрактно, на уровне «Какая программа должна стоять на том или ином сервере», а не на уровне «Какие комманды я должен запустить на Windows, а какие на Linux». Для Puppet существует [провайдер Chocolatey](http://forge.puppetlabs.com/rismoney/chocolatey), который позволяет нам сделать следующее:
```
package { "7zip" :
ensure => installed,
}
```
или
```
package { "notepadplusplus" :
ensure => 1.0,
}
```
Обо всем остальном позаботятся Puppet и Chocolatey. Поверьте, это намного удобнее чем производить установку из msi файла, который нужно еще где-то захостить, а также удостовериться что при обновлении версии (которое еще нужно сделать) старые версии тоже сохраняться и ничего при этом не сломается.
#### Chocolatey и Desktop
Предлагаю рассмотреть два способа использования Chocolatey для администрировании рабочих станций.
**Chocolatey GUI**[ChocolateyGUI](https://github.com/chocolatey/ChocolateyGUI) — это графический интерфейс для системы управления пакетов Chocolatey. Удобный способ для обзора текущего состояния репозитория, а также состояния локально-установленных пакетов. Мне почему-то очень сильно напомнило раннюю версию synaptic или даже aptitude. Работает достаточно сносно. Установить его, кстати, можно из коммандной строки:
```
cinst ChocolateyGUI
```
**Windows Post Install (WPI)**Можно пойти еще дальше, использовать интерфейс [WPI](http://www.wpiw.net) для удобного выбора пакетов, в котором будут исполняться команды Chocolatey. При помощи WPI можно удобно группировать программы по категориям, а также создавать шаблоны и наборы установки.
Решение не всегда сможет стать абсолютной альтернативой использования USB-HDD в качестве источника, но заменив все возможные компоненты на аналогичные из репозитория Chocolatey Вы избавите себя от мучительного копирования образа (папки) с полным набором софта (Photoshop, Office, 3D Max с Архикадом, что там еще?) и оболочкой WPI (а все ради того, чтобы поставить «легкие» программы вроде Google Chrome, Notepad++, Avast и т.п.).
К примеру, для приходящих админов, поддерживающих разрозненный парк машин без централизованного хранилища удобно иметь что-то вроде такого списка шаблонов:
* Бизнес
* Бухгалтер
* Разработчк
* Домашний пользователь
* Медиа-Станция
Таким образом, WPI всего лишь является оболочкой для запуска команд Chocolatey, что позволяет уменьшить суммарный объем дистрибутива. Конечно, при таком подходе на клиентской машине уже должен быть рабочее интернет-подключение, что сегодня не является проблемой, за исключением отдельных случаев.
Возвращаясь к программам которые отсутствуют в репозитории Chocolatey.org, следует упомянуть, что Chocolatey поддерживает любые NuGet фиды, а не только предлагаемый по-умолчанию chocolatey.org. Заливаем важные файлы в DropBox и создаем свой пакет где-нибудь на [www.myget.org](http://www.myget.org/) — это очень просто!
Если кому интересно, могу рассказать в подробностях (в форме отдельного поста) как создать свой пакет и как загрузить его в репозиторий chocolatey.org, и о том, как я научил Windows устанавливать все обновления без моего участия (с перезагрузками и лицензиями), как я обновляю базу maxmind.dat в автоматическом режиме, как я использую logstash и многом другом, и все это не без помощи chocolatey и puppet!
В заключение скажу, что на мой взгляд, идея децентрализованной системы управления пакетам для Windows и ее реализация — очередной способ убедиться что в наши дни opensource и открытие технологии становится не менее качественными и применимыми к реалиям системного администрирования. Закрытый код все реже становится рыночным преимуществом того или иного сообщества / компании, в то время как реализация и поддержка играют огромную роль. Представить что десять лет назад открытый проект, созданный одним человеком сможет создать такой резонанс в широких кругах, да еще и Windows кругах — нереально, а сегодня Chocolatey — это еще один шанс окунуться в opensource сообщество и убедиться в открытой возможности внести свой вклад в общую идею.
На любые ошибки и неточности прошу указывать в комментариях, с удовольствием поправлю и дополню материал.
И под конец, небольшой опрос: | https://habr.com/ru/post/210626/ | null | ru | null |
# Фильтры данных на ASP.NET MVC и Entity Framework
Очень часто в различных веб-приложениях мы работаем с данными, выбранными из таблиц БД. И нередко необходимо предоставлять пользователю возможность фильтровать эти данные. Можно, конечно, для каждого случая собирать данные с формы в ручную и в ручную создавать соответствующий запрос под них. Но что если у нас 20 разных страниц, представляющих те, или иные данные? Обрабатывать в ручную все долго и не удобно, а поддерживать еще хуже. Моя версия решения данной проблемы на ASP.NET MVC + Entity Framework под катом.
Сразу хочется отметить, что мое решение не претендует на гениальность и идеальную архитектуру, в нем есть минусы, которые я отмечу в конце, и очень надеюсь что хабр-сообщество укажет мне на те минусы, которые не вижу я.
Думаю, стоит сразу привести пример использования того, что я опишу ниже. Идея заключается в следующем: допустим у нас есть вот такая модель данных
```
public class Student
{
[Key]
public int Id { get; set; }
// имя
public string Name { get; set; }
// группа
public string Group { get; set; }
// год защиты
public short DefYear { get; set; }
// статус защищенности ВКР
public bool IsDefended { get; set; }
}
```
Пользователь работает со списком студентов и хочет отобрать определенных по фамилии, группе, году защиты и состоянию защиты. Для этого нам будет необходимо описать модель фильтра, выглядеть она будет следующим образом.
```
public class StudentFilter : FilterModel
{
[FilterName("ФИО")]
[InputType(InputTypeAttribute.InputTypies.TextBox)]
public string Name { get; set; }
[FilterName("Группа")]
[InputType(InputTypeAttribute.InputTypies.TextBox)]
public string Group { get; set; }
[FilterName("Год защиты")]
[InputType(InputTypeAttribute.InputTypies.DropDownList)]
[SelectListProperty("DefYearList", "Неважно")]
public short? DefYear { get; set; }
[FilterName("Статус защиты ВКР")]
[InputType(InputTypeAttribute.InputTypies.DropDownList)]
[SelectListProperty("IsDefendedList", "Неважно")]
public bool? IsDefended { get; set; }у
public SelectList DefYearList
{
get { return new SelectList(new List { 2011, 2012 }, DefYear); }
}
public SelectList IsDefendedList
{
get
{
var list = new List
{
{new {Id="true", Title="Защищена"}},
{new {Id="false", Title="Не защищена"}},
};
return new SelectList(list, "Id", "Title", IsDefended);
}
}
public override Func FilterExpression
{
get
{
return p =>
(String.IsNullOrEmpty(Name) || p.Name.IndexOf(Name) == 0) &&
(String.IsNullOrEmpty(Group) || p.Group.ToLower().IndexOf(Group.ToLower()) == 0) &&
(DefYear == null || p.DefYear == DefYear) &&
(IsDefended == null || (p.IsDefended == IsDefended));
}
}
public override void Reset()
{
Name = null; Group = null; DefYear = null; IsDefended = null;
}
}
```
Имея модель фильтра мы можем выбрать из БД данные, удовлетворяющие значениям, хранящимся в этой модель. Сделать это можно вот так
```
var filters = IocContainer.Resolve();
var students = DbContext.Students
.Where(Filter.FilterExpression)
.OrderBy(s => s.Name)
.ToList();
```
Ну и конечно же код вьюхи, которая будет отображать форму, которую пользователю необходимо заполнить, что бы отфильтровать данные.
```
..................
Студенты
--------
@Html.FilterForm(Filters.Find())
..................
```
Filters этот то же хранилище фильтров, которое использовали при выборке из БД. Лично я его получаю с помощью Unity.
Ну и все, больше нам ничего не понадобится. Пользователь будет видеть перед собой примерно вот такую форму
И набор данных, который соответствует этой форме.
Теперь перейдем к описанию всего того, что обслуживает вышеописанный код. Начнем мы с модели данных для фильтров. По скольку для каждого представления данных на сайте фильтры могут быть разные и соответственно разные модели, необходимо определить ее интерфейс, который будем реализовывать. Модель для фильтра должна уметь генерировать expression для выборки из коллекций данных entity framework и должна уметь устанавливать свое начальное состояние, по этому интерфейс, а вернее абстрактный класс, получился следующий:
```
public abstract class FilterModel
{
[Dependency]
public IUnityContainer IocContainer { get; set; }
public abstract void Reset();
}
public abstract class FilterModel : FilterModel
{
public abstract Func FilterExpression { get; }
}
```
Использую здесь именно абстрактный класс потому, что хотелось всегда держать контэйнер Unity под рукой. По этому свойство IocContainer можно смело убирать и превращать эти два класса в обычные интерфейсы.
Теперь, когда у нас есть модель, нам нужно ее где то хранить. Рассмотрим теперь интерфейс необходимого нам хранилища.
```
public interface IFilterFactory
{
///
/// Поиск фильтра по типу
///
///
///
TFilter Find() where TFilter : FilterModel;
///
/// Поиск фильтра по GUID типа
///
///
///
FilterModel Find(String guidString);
///
/// Замена объекта фильтра
///
///
void Replace(FilterModel filter);
///
/// Сброс данных фильтра на начальную позицию
///
/// guid типа фильтра
void Reset(String guidString);
}
```
Поиск фильтра по guid типа нам будет нужен для установки данных в конкретный тип, когда эти данный придут нам вместе с запросом. Т.е. из клиентской части мы указываем серверному коду, с каким фильтром работать, посредством передачи guid типа этого фильтра.
Вот базовая реализация интерфейса IFilterFactory.
```
public class DefaultFilterFactory : IFilterFactory
{
protected List Collection { get; private set; }
[InjectionConstructor]
public DefaultFilterFactory()
{
Collection = new List();
}
[Dependency]
public IUnityContainer IocContainer { get; set; }
///
/// Поиск необходимого фильтра
///
/// тип фильтра
///
public TFilter Find() where TFilter : FilterModel
{
try
{
return (TFilter)Collection.Single(f => f.GetType().FullName == typeof(TFilter).FullName);
}
catch
{
AddNew();
return Find();
}
}
///
/// Поиск фильтра по GUID его типа
///
/// строковое представление GUID
///
public FilterModel Find(String guidString)
{
return (FilterModel)Collection.Single(f => f.GetType().GUID.ToString() == guidString);
}
public void Replace(FilterModel filter)
{
try
{
var old = Collection.SingleOrDefault(f => f.GetType().FullName == filter.GetType().FullName);
if (old != null)
{
if (!Collection.Remove(old))
throw new InvalidOperationException("Неудача при удалении старого фильтра");
}
}
catch (InvalidOperationException)
{
throw;
}
catch
{
//сюда можно приделать логгер
}
Collection.Add(filter);
}
///
/// Добавление нового фильтра
///
/// тип фильтра
protected void AddNew() where TFilter : FilterModel
{
var filter = IocContainer.Resolve();
filter.Reset();
Collection.Add(filter);
}
///
/// Сброс фильтра по GUID его типа
///
/// строковое представление GUID
///
public void Reset(String guidString)
{
try
{
var filter = Find(guidString);
filter.Reset();
}
catch
{
//сюда можно приделать логгер
}
}
}
```
Хранить объект класса в DefaultFilterFactory приходится в рамках сессии, что бы сохранять выбранные пользователем значения. Для этого я использую Unity с дописанным lifemanager-ом для сессий ASP.NET MVC, Вы можете использовать любой другой DI-фрэймворк или же работать с объектом самостоятельно. Так же можно написать другую реализацию интерфейса IFilterFactory, которая будет использовать для хранения xml например или же БД, тут фантазия может быть безгранична…
Дальше необходимо каким то образом собрать модель из запроса пользователя и поместить ее в хранилище. Для этого будем использовать специальный сборщик модели (тут каюсь, не додумал, грамотней было бы его унаследовать от IModelBinder и использовать как любой другой сборщик моделей в MVC)
```
public class FilterBinder
{
///
/// Ключ словаря запроса, в значении которого будет лежать guid типа
///
public static string TypeKey
{
get { return "_filter_type"; }
}
///
/// Лямда для отсеиневания свойств, которые не относятся к данным фильтра
/// Все свойства модели фильтра, которые должны учавствовать в фильтрации необходимо отметить аттрибутом InputTypeAttribute
///
public static Func IsFilterProperty
{
get
{
return p =>
p.GetCustomAttributes(true).Count(a => a.GetType() == typeof(InputTypeAttribute)) > 0;
}
}
///
/// Объект запроса
///
public HttpRequest Request { get; protected set; }
///
/// Unity контэйнер
///
[Dependency]
public IUnityContainer IocContainer { get; set; }
///
/// Тип фильтра
///
public Type FilterType
{
get { return IocContainer.Resolve().Find(Request[TypeKey]).GetType(); }
}
public FilterBinder()
{
Request = HttpContext.Current.Request;
}
///
/// Сборка модели
///
///
public FilterModel BindFilter()
{
var filter = (FilterModel)IocContainer.Resolve(FilterType);
// перебор всех свойств фильтра, отмеченных InputTypeAttribute
foreach (var property in FilterType.GetProperties().Where(FilterBinder.IsFilterProperty))
{
object value = null;
//если значение свойства строковое, просто присваиваем ему данные из запроса с ключем, совпадающим с именем свойства
if (property.PropertyType == typeof(String))
{
value = Request[property.Name];
}
//если не строковое, пытаемся преобразовать типы
else
{
try
{
var parse = property.PropertyType.GetMethod("Parse", new Type[] { typeof(String) }) ??
property.PropertyType.GetProperty("Value").PropertyType.GetMethod("Parse", new Type[] { typeof(String) });
if (parse != null)
value = parse.Invoke(null, new object[] { Request[property.Name] });
}
catch
{
value = null;
}
}
//устанавливаем получившиеся значение в модель
property.SetValue(filter, value, null);
}
return filter;
}
}
```
Код атрибутов, задействованных в сборщике, приведу чуть ниже, когда будем заниматься отображением формы фильтров. Сейчас же приведу код контроллера, который будет заниматься приемом данных фильтра от клиента.
```
public class _FilterController : ExpandController
{
public ActionResult SetFilter(string backUrl)
{
try
{
var filter = IocContainer.Resolve().BindFilter();
if (filter == null)
{
FlashMessanger.ErrorMessage = "Ошибка установки фильтра";
return Redirect(backUrl);
}
Filters.Replace(filter);
}
catch
{
FlashMessanger.ErrorMessage = "Ошибка установки фильтра: истекло время сессии. Пожалуйста, повторите попытку";
}
return Redirect(backUrl);
}
public ActionResult Reset(string backUrl, string filter)
{
Filters.Reset(filter);
return Redirect(backUrl);
}
}
```
(ExpandController — расширенный базовый Controller, FlashMessanger — надстройка над TempData, не даю пояснений на этот счет, так как это совсем другая история)
Как видно из кода, в контроллере два действия: одно занимается обработкой значений, второе их сбросом. Оба, после окончания своей миссии, возвращают пользователя на ту страницу, от куда пришел запрос. И на ней пользователь уже сможет увидеть отфильтрованный набор интересующих данных.
Написав всю бизнес-логику задачи, теперь можно заняться отображением всего этого безобразия для пользователя. По скольку пока эти фильтры я применял всего в одном проекте, то html мне генерирует хелпер, и соответственно гибкости разметки нет почти никакой. Если у Вас есть идеи как можно решить эту проблему, буду рад их слышать в комментариях.
Для того, что бы сделать хелпер отображения чуточку умнее, мы воспользуемся аттрибутами для наших фильтров, которыми будем помечать свойства модели. Вот их код
```
///
/// Указывает на свойство, которое вернет SelectList с вариантами значений
///
public class SelectListPropertyAttribute : Attribute
{
///
/// Имя свойсва
///
public string Property { get; set; }
///
/// название для null
///
public string OptionLabel { get; set; }
public SelectListPropertyAttribute(string property)
{
Property = property;
OptionLabel = String.Empty;
}
public SelectListPropertyAttribute(string property, string optionLabel)
: this(property)
{
OptionLabel = optionLabel;
}
}
///
/// Отмечает свойство для отображения в форме и для получения данных в него из запроса
/// Так же выбирает через какой элементы формы отображать свойство
///
public class InputTypeAttribute : Attribute
{
public enum InputTypies
{
TextBox, CheckBox, DropDownList
}
public InputTypies Type { get; set; }
public InputTypeAttribute(InputTypies type)
{
Type = type;
}
}
///
/// Имя свойства для отображения в форме
///
public class FilterNameAttribute : Attribute
{
public string Name { get; set; }
public FilterNameAttribute(string name)
{
Name = name;
}
}
```
и код хелпера
```
public static class Helpers
{
///
/// Имя контроллера, которому отправляем данные
///
private const string CONTROLLER_NAME = "_Filter";
///
/// Имя действия для установки фильтра
///
private const string SET_ACTION_NAME = "SetFilter";
///
/// Имя действия для сброса фильтра
///
private const string RESET_ACTION_NAME = "Reset";
///
/// Создание разметки формы
///
///
public static IHtmlString FilterForm(this HtmlHelper helper, FilterModel filter, string controllerName = CONTROLLER_NAME, string setActionName = SET_ACTION_NAME, string resetActionName = RESET_ACTION_NAME)
{
var url = new UrlHelper(HttpContext.Current.Request.RequestContext, helper.RouteCollection);
//генерируем url на который будем отправлять форму
var hrefSet = url.Action(setActionName, controllerName, new { area = "", backUrl = HttpContext.Current.Request.Url });
var result = String.Format("\n\t", hrefSet);
result += helper.Hidden(FilterBinder.TypeKey, filter.GetType().GUID.ToString()).ToString();
result += "### Фильтры
";
// небольшие функции, которые нам пригодятся
// возвращает имя свойства
Func getFilterName = p =>
p.GetCustomAttributes(typeof(FilterNameAttribute), true).Any() ?
((FilterNameAttribute)p.GetCustomAttributes(typeof(FilterNameAttribute), true).Single()).Name :
p.Name;
// возвращает свойсвтво, содержащие SelectList возможных значений
Func getSelectListProperty = p =>
!p.GetCustomAttributes(typeof(SelectListPropertyAttribute), true).Any() ?
null :
p.DeclaringType.GetProperty(
((SelectListPropertyAttribute)p.GetCustomAttributes(typeof(SelectListPropertyAttribute), true).Single()).Property,
typeof(SelectList)
);
// возвращает имя свойства для отображения
Func getSelectListOptionLabel = p =>
!p.GetCustomAttributes(typeof(SelectListPropertyAttribute), true).Any() ?
null :
((SelectListPropertyAttribute)p.GetCustomAttributes(typeof(SelectListPropertyAttribute), true).Single()).OptionLabel;
//цикл по всем свойсвам модели, отмеченным InputTypeAttribute
foreach (var property in filter.GetType().GetProperties().Where(FilterBinder.IsFilterProperty))
{
result += "\n\t\t";
result += "\n\t\t\t" + getFilterName(property) + "";
//получаем тип элемента формы, с помощью которого будем отображать свойсвто
var type = (InputTypeAttribute)property.GetCustomAttributes(typeof(InputTypeAttribute), true).Single();
// генерируем html свойства
switch (type.Type)
{
case InputTypeAttribute.InputTypies.TextBox:
result += helper.TextBox(property.Name, property.GetValue(filter, null)).ToString();
break;
case InputTypeAttribute.InputTypies.CheckBox:
result += helper.CheckBox(property.Name, property.GetValue(filter, null)).ToString();
break;
case InputTypeAttribute.InputTypies.DropDownList:
var selectList = getSelectListProperty(property) != null ?
(SelectList)getSelectListProperty(property).GetValue(filter, null) :
new SelectList(new List());
result += String.IsNullOrEmpty(getSelectListOptionLabel(property)) ?
helper.DropDownList(property.Name, selectList) :
helper.DropDownList(property.Name, selectList, getSelectListOptionLabel(property));
break;
}
result += "\n\t\t";
}
result += "\n\t\t";
result += String.Format(
@"[]({1})",
url.Content("~/Content/images/button\_apply.png"),
url.Action(resetActionName, controllerName, new { area = "", backUrl = HttpContext.Current.Request.Url, filter = filter.GetType().GUID }),
url.Content("~/Content/images/button\_cancel.png")
);
return helper.Raw(result + "\n\t\n");
}
}
```
Пожалуй на этом все. Теперь вернемся к тем минусам, о которых я говорил в начале:
1) Если пользователь откроет страницу, затем оставит ее на время, достаточное для того, что бы истекло время сессии, после чего заполнит форму фильтров и отправит ее, то его ждет разочарование. Система не сможет найти тип фильтра по его guid. Как решить проблему, пока не придумал, но активно размышляю на этот счет
2) Как я уже говорил, хелпер генерирует статическую разметку, которую невозможно подправить во вьюхах. По этому получаем не очень гибкое отображение. Хотя конечно можно отказаться от использования хелпера и для каждой модели описывать разметку форму в ручную во вьюхах, но это слегка утомительно занятие
3) Для метода Reset класса FilterModel можно написать реализацию по умолчанию, в которой все свойства, помеченные InputTypeAttribute будут установлены в нулевые значения.
4) Я не уверен в абсолютной правильности архитектуры всего этого.
Большое Вам спасибо, что дочитали мою статью до конца! Буду крайне признателен Всем, кто оставит свое мнение и замечания.
**UPDATE**
Как верно подметили в комментариях
```
public abstract class FilterModel : FilterModel
{
public abstract Func FilterExpression { get; }
}
```
лучше заменить на
```
public abstract class FilterModel : FilterModel
{
public abstract Expression> FilterExpression { get; }
}
```
В этом случае выражение фильтра будет трансформироваться в SQL запрос. | https://habr.com/ru/post/141440/ | null | ru | null |
# Быль о типографе
Было время, когда каждый веб-разработчик писал свой типограф или думал о нём. Я не стал исключением и написал типограф на PHP. Но как сделать типограф без нормальной поддержки UTF-8, в то время я не представлял, в итоге забросил идею.
Прошло время, но идея создания типографа не оставляла, и я решил написать [его](https://github.com/typograf/typograf) уже на JavaScript.
Начал с основных требований:* только UTF-8;
* гибкость и расширяемость;
* работа на клиенте и сервере, там, где есть JavaScript;
* поддержка (X|HT)ML;
* по умолчанию, HTML-cущности переводятся в чистые UTF-8 символы;
* не типографировать стили и скрипты;
* CLI-утилита.
Я быстро пришёл к модульности правил в типографе, одно правило — одна функция — один файл, все правила распределены [по группам](https://github.com/typograf/typograf/tree/dev/src/rules/ru/optalign).
Добавить своё правило очень просто:
```
Typograf.rule({
name: 'common/other/emoji',
handler: function (text) {
return text.replace(/:-\)/g, '\uD83D\uDE0A');
}
});
```
Ядро типографа всего лишь запускает [правила-функции](https://github.com/typograf/typograf/blob/dev/docs/RULES.ru.md), передавая обработанный текст от правила к правилу.
Есть очереди, т. к. некоторые правила необходимо запускать в самом начале обработки текста, какие-то в конце.
Есть индексы у правил, в каком порядке в очереди запустить правило, это позволяет уменьшить сложность регулярных выражений.
Правила можно включать и отключать. Некоторые правила выключены по умолчанию, например, висячая пунктуация.
Быстрый старт
-------------
### В браузере
```
npm i typograf
```
```
var tp = new Typograf({lang: 'ru'});
alert(tp.execute(' Мир - мой мир!! '));
```
### В Node.js
```
npm i typograf
```
```
var Typograf = require('typograf'),
tp = new Typograf({lang: 'ru'});
tp.enable('ru/optalign/*'); // Включить висячую пунктуацию
console.log(tp.execute(' Мир - мой мир!! '));
```
### CLI
Устанавливаем:
```
npm i typograf -g
```
Типографируем текст по русским правилам:
```
typograf -l ru my_file.txt > my_new_file.txt
```
Варианты использования типографа:* [Typograf](https://github.com/typograf/typograf)
* Веб-интерфейс для [десктопа](https://typograf.github.io) или [мобильника](https://typograf.github.io/mobile.html)
* [Типографирование на лету](https://github.com/typograf/jquery-typograf) c jQuery или без, [пример](https://typograf.github.io/jquery-typograf/example.html)
* [Typograf в npm](https://www.npmjs.com/package/typograf)
* [gulp-typograf](https://www.npmjs.com/package/gulp-typograf) и [grunt-typograf](https://www.npmjs.com/package/grunt-typograf)
* [Букмарклет](https://github.com/typograf/bookmarklet) для «отчаявшихся»
* TODO: Плагины для браузеров
В каждом типографе есть ошибки после типографирования. Чем больше тестов-текстов и пользователей, тем качественнее типограф, а это значит приветствуются замечания и пулл-реквесты на [Github](https://github.com/typograf/typograf/issues). | https://habr.com/ru/post/266563/ | null | ru | null |
# Маленькая задача — вывести дату
Я хочу рассказать о простой задаче — вывод даты на главной странице [Mail.Ru](http://mail.ru). Маленькая задача, нетривиальное решение.
Решение в лоб:
```
function print_date(date){
return date.getDate() + ' ' + getMonth(date.getMonth()) …
}
print_date( new Date() );
```
Недавно появился еще один блок на странице. Начался чемпионат мира по хоккею, и надо выводить начало матча. Но время у каждого пользователя должно быть синхронизировано с его часовым поясом.
Тоже не слишком сложно — от сервера нам приходит timestamp начала матча. На клиенте вызываем уже сделанную нами функцию.
```
print_date( new Date(timestamp) );
```
Однако не всегда возможно правильно автоматом определять регион пользователя. Например, мой домашний провайдер в нашем районе стал выдавать IP-адреса из диапазона, которого у него раньше не было. Все порталы предлагали мне разные места на нашей планете, но в одном они все были согласны: я точно нахожусь далеко от Москвы. Именно для таких ситуаций мы предлагаем пользователю выбрать город самостоятельно.
Естественно, все даты должны быть синхронизированы с выбранным городом, а это означает, что текущее смещение пользователя относительно Гринвича может быть некорректным.
У нас есть timestamp начала матча и часовой пояс выбранного города. На клиенте делаем дату и смещаем ее на разницу между текущим смещением пользователя и смещением в выбранном городе.
```
var date = new Date(timestamp);
date.setMinutes(town_offset + date.getTimezoneOffset())
print_date(date)
```
Почему плюс между town\_offset и date.getTimezoneOffset(), можно прочитать тут: [developer.mozilla.org/en/JavaScript/Reference/Global\_Objects/Date/getTimezoneOffset#Description](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset#Description)
Теперь, если пользователь во Владивостоке, но выбрал Москву, мы корректируем объект Date на разницу между этими двумя городами.
С выводом времени начала матча разобрались, но есть еще и текущая дата. А с ней не все так гладко. При выводе даты матча мы используем timestamp из базы, а при выводе текущей даты мы используем new Date() на клиенте.
```
var date = new Date();
date.setMinutes(town_offset + date.getTimezoneOffset())
print_date(date)
```
А это значит, что мы используем timestamp пользовательского компьютера. Пользователь может вручную перевести свои часы, и тогда мы получаем некорректный текущий timestamp. Поэтому текущий timestamp мы тоже вынуждены передавать с сервера.
```
var date = new Date(server_timestamp);
date.setMinutes(town_offset + date.getTimezoneOffset())
print_date(date)
```
Но и это не конец — часы на главной странице должны «тикать», пусть мы не можем доверять пользовательскому timestamp, но на смещение timestamp относительно загрузки страницы можно положиться. На то, что пользователь собьет себе локальные часы именно посередине просмотра новостей на главной, закладываться не будем.
```
var begin = new Date().getTime();
function get_delta(){
return new Date().getTime() - begin;
}
function update_time(){
var date = new Date(server_timestamp + get_delta());
date.setMinutes(town_offset + date.getTimezoneOffset())
print_date(date)
}
```
Андрей Сумин
Руководитель разработки клиентской части Mail.Ru, компания Mail.Ru Group
Егор Дыдыкин
Тимлид команды разработки главной страницы портала Mail.Ru, компания Mail.Ru Group | https://habr.com/ru/post/143627/ | null | ru | null |
# Руководство по фоновой работе в Android. Часть 1
О фоновой работе приложений в Android есть много статей, но мне не удалось найти подробного руководства по реализации работы в фоне – думаю, из-за того, что появляется все больше новых инструментов для такой работы. Поэтому я решил написать серию статей о принципах, инструментах и методах асинхронной работы в приложениях под Android.
Будет несколько частей:
1. Основной поток, осуществление фоновой работы с помощью AsyncTask, публикация результатов в основном потоке.
2. Затруднения при использовании AsyncTask. Loaders как один из способов их избежать.
3. Работа в фоне с помощью ThreadPools и EventBus.
4. RxJava 2 как метод асинхронной работы.
5. Корутины в Kotlin как метод асинхронной работы.
Начнем с первой части.
Основы UI
=========
Первое, что следует понять, – почему мы вообще беспокоимся о работе в фоне в мобильных приложениях.
Во всех приложениях для Android есть хотя бы один поток, на котором происходит прорисовка UI и обработка пользовательского ввода. Поэтому он и называется потоком UI или главным потоком.
**Каждый метод жизненного цикла каждого компонента вашего приложения, включая Activity, Service и BroadcastReceiver, исполняется на UI-потоке.**
Человеческий глаз преобразовывает сменяющиеся изображения в плавное видео, если частота смены достигает 60 кадров в секунду (да, это магическое число берется отсюда), давая основному потоку только 16 мc для прорисовки всего экрана.
**Продолжительность сетевого вызова может быть в тысячи раз больше.**
Когда мы хотим загрузить что-либо из Интернета (прогноз погоды, пробки, сколько стоит ваша часть биткоина в данный момент), мы не должны делать это из главного потока. Более того, Android не позволит нам, выбросив [NetworkOnMainThreadException](https://developer.android.com/reference/android/os/NetworkOnMainThreadException.html).
Семь лет назад, когда я разрабатывал свои первые приложения на Android, подход от Google был ограничен использованием AsyncTasks. Давайте посмотрим, как мы писали код для общения с сервером (псевдокод преимущественно):
```
public class LoadWeatherForecastTask extends AsyncTask {
public Forecast doInBackground(String... params) {
HttpClient client = new HttpClient();
HttpGet request = new HttpRequest(params[0]);
HttpResponse response = client.execute(request);
return parse(response);
}
}
```
Метод doInBackground() гарантированно будет вызван не на основном потоке. Но на каком? Зависит от реализации. Вот как Android выбирает поток (это часть исходного кода класса AsyncTask):
```
@MainThread
public final AsyncTask executeOnExecutor(Executor exec, Params... params) {
...
mStatus = Status.RUNNING;
onPreExecute();
mWorker.mParams = params;
exec.execute(mFuture); // <-- mFuture contains a Runnable with our doInBackgroundMethod
return this;
}
```
Здесь можно увидеть, что выполнение зависит от параметра Executor. Посмотрим, откуда он берется:
```
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
...
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
...
@MainThread
public final AsyncTask execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
```
Как здесь указано, по умолчанию executor ссылается на пул потоков размера 1. Это означает, что все AsyncTasks в вашем приложении запускаются последовательно. Это не всегда было верно, так как для версий ОС от DONUT до HONEYCOMB использовался пул размером от 2 до 4(в зависимости от количества ядер процессора). После HONEYCOMB AsyncTasks снова выполняются последовательно по умолчанию.
Итак, работа выполнена, байты закончили свое длинное путешествие с другого полушария. Нужно превратить их во что-то понятное и разместить на экране. К счастью, наша Activity тут как тут. Давайте поместим результат в одно из наших View.
```
public class LoadWeatherForecastTask extends AsyncTask {
public Forecast doInBackground(String... params) {
HttpClient client = new HttpClient();
...
Forecast forecast = parse(response);
mTemperatureView.setText(forecast.getTemp());
}
}
```
О, черт! Опять исключение!
> android.view.ViewRoot$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.
Но мы не делали никаких сетевых обращений на основном потоке! Правильно, но мы попытались нарушить другой закон UI. Пользовательский интерфейс можно менять только из UI-потока. Это верно не только для Android, но и практически для любой системы, с которой вы столкнетесь. Причину этого хорошо объяснили в Java Concurrency In Practice. Вкратце – архитекторы хотели избежать сложной блокировки при изменениях из нескольких источников (пользовательский ввод, биндинг и другие изменения). Использование единственного потока решает эту проблему.
Да, но UI все равно нужно обновлять. У AsyncTask есть еще метод onPostExecute, который вызывается на UI-потоке:
```
public void onPostExecutre(Forecast forecast) {
mTemperatureView.setText(forecast.getTemp());
}
```
Как эта магия работает? Посмотрим в исходном коде AsyncTask:
```
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
private static class InternalHandler extends Handler {
public InternalHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
AsyncTaskResult result = (AsyncTaskResult) msg.obj;
switch (msg.what) {
case MESSAGE_POST_RESULT:
// There is only one result
result.mTask.finish(result.mData[0]);
break;
}
}
}
```
AsyncTask использует Handler для вызова onPostExecute в UI, ровно как и метод postOnUiThread в компонентах Android.
Handler прячет всю внутреннюю кухню. Какую именно? Идея состоит в том, чтобы иметь бесконечный цикл проверки сообщений, приходящих на UI-поток, и обрабатывать их соответствующе. Велосипедов тут никто не изобретает, хотя без кручения педалей не обошлось.
Для Android это реализовано классом Looper, который передается в InternalHandler в приведенном выше коде. Суть класса Looper находится в методе loop:
```
public static void loop() {
...
for (;;) {
Message msg = queue.next();
....
msg.target.dispatchMessage(msg);
}
...
}
```
Он просто опрашивает очередь входящих сообщений в бесконечном цикле и обрабатывает эти сообщения. Это означает, что на UI-потоке должен быть инициализированный экземпляр Looper. Можно получить доступ к нему с помощью статического метода:
```
public static Looper getMainLooper()
```
Кстати, вы только что узнали, как проверить, вызывается ли ваш код в UI-потоке:
```
if (Looper.myLooper() === Looper.getMainLooper()) {
// we are on the main thread
}
```
Если вы попытаетесь создать экземпляр Handler в методе doInBackground, то получите другое исключение. Оно сообщит о необходимости наличия Looper для потока. Теперь вы знаете, что это значит.
Надо заметить, что AsyncTask может быть создан только в UI-потоке по указанным выше причинам.
Вы можете подумать, что AsyncTask – это удобный способ выполнения фоновой работы, так как он скрывает сложность и требует немного усилий при использовании, но есть несколько проблем, которые приходится решать по пути:
* Каждый раз нужно писать достаточно много кода для решения относительно простой задачи
* AsyncTasks ничего не знают о жизненном цикле. При неправильном обращении лучшее, что вы получите — утечка памяти, в худшем – сбой
* AsyncTask не поддерживает сохранение состояния прогресса и повторное использование результатов загрузки.
В следующей части я подробно разберу эти проблемы и покажу, как Loaders могут помочь их решить. | https://habr.com/ru/post/348894/ | null | ru | null |
# Нейросети для чайников. Часть 2 — Перцептрон
В предыдущей [статье](http://habrahabr.ru/post/143129/) были рассмотрены самые азы для понимания темы нейронных сетей. Полученная система не являлась полноценной нейронной сетью, а несла просто ознакомительный характер. Принимающими решения механизмами в ней были «черные ящики», не описанные подробно.
Вот о них речь и пойдет в рамках данной статьи. Результатом статьи будет полноценная нейронная сеть из одного перцептрона, умеющая распознавать входные данные и позволяющая себя обучать.
Язык программирования, на этот раз — C#.
Заинтересовавшихся прошу под кат.
Изложение буду вести простым языком, поэтому профи прошу не критиковать за терминологию.
В первой статье, элементом, отвечающим за распознавание конкретной цифры, был некий «нейрон» (таковым, по сути, не совсем являвшийся, но принятый за него для простоты).
Рассмотрим, что же он из себя представляет.
На вход мы снова будем подавать изображение, поэтому входные данные представляют собой двумерный массив. Далее, каждый кусочек входных данных соединяется с нейроном с помощью специальной связи (синапса) — на рисунке красные линии. Но это не простые связи. Каждая из них имеет какую-то значимость для нейрона.
Приведу аналогию с человеком. Мы воспринимаем информацию разными органами чувств — видим, слышим, чуем, осязаем. Но некоторые из этих чувств имеют более высокий приоритет (зрение), а некоторые более низкий (чутье, осязание). Причем для каждой жизненной ситуации приоритет для каждого органа чувств мы задаем основываясь на своем опыте — готовясь съесть незнакомый продукт, мы ставим в максимальный приоритет зрение и обоняние, а вот слух не играет роли. А пытаясь в толпе людей найти своего друга, мы обращаем внимание на информацию, которую дают нам глаза и уши, а остальное отходит на второй план.
Простейшим подобием отдельного органа у нейрона и является синапс. В разных ситуациях разные синапсы будут иметь разную значимость. Эта значимость называется весом связи.
Т.к. подаваемая на вход картинка у нас черно-белая, то на входе аксона может быть только 1 или 0:
А на выходе либо значение веса, либо 0.
Грубо говоря, если на входе что-то есть — ножка начинает «дёргаться», говоря нейрону, что на ней есть информация. От того, как сильно она «дёргается», будет зависеть принимаемое сетью решение.
Количество аксонов соответствует числу элементов входного массива. В данной статье я буду использовать в качестве входной информации изображения размерами 3х5 пикселей. Соответственно, число связей, приходящих в нейрон будет 3 х 5 = 15.
Сигнал, отмасштабированный коэффициентом веса связи, приходит в нейрон, где складывается с остальными сигналами от прочих синапсов.
Получается некоторое число. Это число сравнивается с заранее установленным порогом — если полученное значение выше порога, то считается, что нейрон выдал на выход единицу.
Порог выбирается из следующих соображений: чем он выше, тем больше будет точность работы нейрона, но тем дольше нам придется его обучать.
Перейдем к программной реализации.
Создадим класс нейрона:
```
class Web
{
public int[,] mul; // Тут будем хранить отмасштабированные сигналы
public int[,] weight; // Массив для хранения весов
public int[,] input; // Входная информация
public int limit = 9; // Порог - выбран экспериментально, для быстрого обучения
public int sum ; // Тут сохраним сумму масштабированных сигналов
public Web(int sizex, int sizey,int[,] inP) // Задаем свойства при создании объекта
{
weight = new int[sizex, sizey]; // Определяемся с размером массива (число входов)
mul = new int[sizex, sizey];
input = new int[sizex, sizey];
input = inP; // Получаем входные данные
}
```
Да, я знаю, что процедуры умножения сигнала на вес, суммирования сигналов, сравнения с порогом и выдачи результата можно было объединить в одном месте. Но мне показалось, что будет понятнее, если мы проведем каждую операцию по-отдельности и вызовем их поочередно:
Масштабирование:
```
public void mul_w()
{
for (int x = 0; x <= 2; x++)
{
for (int y = 0; y <= 4; y++) // Пробегаем по каждому аксону
{
mul[x, y] = input[x,y]*weight[x,y]; // Умножаем его сигнал (0 или 1) на его собственный вес и сохраняем в массив.
}
}
}
```
Сложение:
```
public void Sum()
{
sum = 0;
for (int x = 0; x <= 2; x++)
{
for (int y = 0; y <= 4; y++)
{
sum += mul[x, y];
}
}
}
```
Сравнение:
```
public bool Rez()
{
if (sum >= limit)
return true;
else return false;
}
```
Программа будет открывать файл-картинку такого вида:
Пробегать по всем пикселям и пытаться определить, является ли эта цифра той, которую её научили распознавать.
Т.к. у нас нейрон только один, то и распознавать мы сможем только один символ. Я выбрал цифру 5. Иными словами, программа будет говорить нам — является скормленная ей картинка изображением цифры 5 или нет.
Чтобы программа могла продолжить работу после выключения, я буду сохранять значения весов в текстовый файл.
```
private void Form1_Load(object sender, EventArgs e)
{
NW1 = new Web(3, 5,input); // Создаем экземпляр нашего нейрона
openFileDialog1.Title = "Укажите файл весов";
openFileDialog1.ShowDialog();
string s = openFileDialog1.FileName;
StreamReader sr = File.OpenText(s); // Загружаем файл весов
string line;
string[] s1;
int k = 0;
while ((line = sr.ReadLine()) != null)
{
s1 = line.Split(' ');
for (int i = 0; i < s1.Length; i++)
{
listBox1.Items.Add("");
if (k < 5)
{
NW1.weight[i, k] = Convert.ToInt32(s1[i]); // Назначаем каждой связи её записанный ранее вес
listBox1.Items[k] += Convert.ToString(NW1.weight[i, k]); // Выводим веса, для наглядности
}
}
k++;
}
sr.Close();
}
```
Далее, необходимо сформировать массив входных данных:
```
Bitmap im = pictureBox1.Image as Bitmap;
for (var i = 0; i <= 5; i++) listBox1.Items.Add(" ");
for (var x = 0; x <= 2; x++)
{
for (var y = 0; y <= 4; y++)
{
int n = (im.GetPixel(x, y).R);
if (n >= 250) n = 0; // Определяем, закрашен ли пиксель
else n = 1;
listBox1.Items[y] = listBox1.Items[y] + " " + Convert.ToString(n);
input[x, y] = n; // Присваиваем соответствующее значение каждой ячейке входных данных
}
}
```
Распознаем символ, вызывая описанные выше методы класса:
```
public void recognize()
{
NW1.mul_w();
NW1.Sum();
if (NW1.Rez()) listBox1.Items.Add(" - True, Sum = "+Convert.ToString(NW1.sum));
else listBox1.Items.Add( " - False, Sum = "+Convert.ToString(NW1.sum));
}
```
Все. Теперь наша программа уже может называться нейронной сетью и что-то определять.
Однако, она совсем глупа и всегда выдает False.
Необходимо обучить её. Обучать будем по простейшему алгоритму.
Если сеть выдает правильный ответ — радуемся и ничего не делаем.
А если ошибается — наказываем её соответствующим образом:
— Если её неправильный ответ False, то прибавляем значения входов к весам каждой ножки (к ножке 1 — значение в точке [0,0] картинки и т.д.):
```
public void incW(int[,] inP)
{
for (int x = 0; x <= 2; x++)
{
for (int y = 0; y <= 4; y++)
{
weight[x, y] += inP[x, y];
}
}
}
```
— Если её неправильный ответ True, то вычитаем значения входов из веса каждой ножки:
```
public void decW(int[,] inP)
{
for (int x = 0; x <= 2; x++)
{
for (int y = 0; y <= 4; y++)
{
weight[x, y] -= inP[x, y];
}
}
}
```
Затем сохраняем полученные изменения в массиве весов и продолжаем обучение.
Как я уже сказал, я взял для образца цифру 5: 
Кроме того, я приготовил остальные цифры и несколько вариантов самой цифры 5:
Вполне ожидаемо, что самой проблемной будет цифра 6, однако и это мы преодолеем с помощью обучения.
Создаем текстовый файл, заполненный нулями 3х5 — чистая память нашей сети:
000
000
000
000
000
Запускаем программу и указываем ей на этот файл.
Загружаем картинку цифры 5:
Естественно, ответ неверный. Нажимаем «Не верно».
Происходит перерасчет весов (можете посмотреть результат в файле):
1 1 1
1 0 0
1 1 1
0 0 1
1 1 1
Теперь программа будет корректно распознавать эту картинку.
Продолжаем скармливать нашей программе картинки и наказывать её за неправильные ответы.
В конечном итоге она будет распознавать все картинки из набора безошибочно.
Вот итоговые значения весов, сохраненные в файл моей полностью настроенной сетью:
1 2 1
1 0 -4
1 2 1
-4 0 1
1 1 0
Вот и шестерка определяется корректно.
Исходные коды программы, исполняемый файл, файлы весов и картинок 3х5 можно взять [отсюда](https://www.dropbox.com/s/cqxals0krjv61zf/Neuro_C.zip?dl=0).
Если хотите поиграться с другими символами или обучить сеть заново — не забудьте обнулить все цифры в файле w.txt
На этом я заканчиваю статью, дорогие хабражители. Мы научились создавать, настраивать и обучать простейший перцептрон.
Если статья встретит горячие отзывы, в следующий раз попробуем реализовать что-то более сложное и многослойное. Кроме того, остался неосвещенным вопрос оптимального (быстрого) обучения сети.
За сим откланяюсь, спасибо за чтение. | https://habr.com/ru/post/144881/ | null | ru | null |
# Enyo 2. ООП
[Первый](http://habrahabr.ru/post/202288/) топик постигла участь многих пятничных постов, но не беда!
Я не сдаюсь, а значит мы продолжаем…
В этом топике мы осветим следующие темы:
* Классы. Определение, создание экземпляров, наследование.
* Методы и поля классов, конструкторы и методы базового класса
#### Disclaimer
Хабражители, я не претендую на истину в последней инстанции.
Мои познания JS и Enyo в частности — довольно ограничены, а потому tutorial является неполным.
Я настоятельно рекомендую всем заинтересовавшимся ознакомиться с офф. документацией.
Ссылки доступны в [первой](http://habrahabr.ru/post/202288/) части, в приложении к текущему топику и конечно на [enyojs.com](http://enyojs.com).
#### Исходные данные
Использовать будем все тот-же файл «index.html»:
```
Title
```
Все примеры будут изменять код внутри тега .
#### Классы. Определение, создание экземпляров, наследование.
Определение своих типов:
```
class ClassName {}
```
в Enyo конструкция будет иметь следующий вид
```
enyo.kind({name: 'ClassName'})
```
Создание экземпляра объекта не отличается оригинальностью:
```
var class_name = new ClassName()
```
Наследование немногим сложнее создания экземпляра:
```
class ClassNameA {}
class ClassNameB extends ClassNameA {}
```
в Enyo примет следующий вид:
```
enyo.kind({name: 'ClassNameA'})
enyo.kind({kind: 'ClassNameA', name: 'ClassNameB'})
```
Тут стоит оговориться: если в классических ООП языках экземпляр типа «ClassName» ссылается на участок памяти и не имеет каких либо выдающихся особенностей (в лучшем случае наследуется от класса Object), то в Enyo базовым классом по-умолчанию будет «enyo.Control» — блочный DOM-элемент с тегом `div` (суровое WEB наследие), т.е. для типа «ClassNameA» неявно базовым классом назначен «enyo.Control». Если это положение дел Вас не устраивает — наследуйте «enyo.Component».
Множественное наследование в стиле С++/Java/etc. обнаружить не удалось, везде где можно — [утиная типизация](http://ru.wikipedia.org/wiki/%D0%A3%D1%82%D0%B8%D0%BD%D0%B0%D1%8F_%D1%82%D0%B8%D0%BF%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F), хотя может плохо искал.
#### Практикум
Возьмем наш «index.html» и впишем следующий код:
```
//Определяем наши классы
enyo.kind({name: 'ClassNameA'})
enyo.kind({kind: 'ClassNameA', name: 'ClassNameB'})
//Создаем экземпляры объектов
var cls_a = new ClassNameA()
var cls_b = new ClassNameB()
//Выведем объекты в консоль
console.dir(cls_a)
console.dir(cls_b)
```
Если проверить DOM то мы не обнаружим `div` элементов. Это связано с тем что ни у одного из классов не был вызван метод «renderInto()», тем не менее объекты, были созданы и инициализированы.
#### Методы и поля классов, конструкторы и методы базового класса
Классы — это хорошо, но зачем класс если не наполнять его функционалом? — Сейчас сделаем!
Имея псевдокод:
```
class ClassNameA {
object fieldName = "value"
}
```
превратим в Enyo код:
```
enyo.kind({name: 'ClassNameA', fieldName: 'value'})
```
Теперь мы можем создать экземпляр класса и проверить что поле класса доступно:
```
var cls_a = new ClassNameA()
console.log(cls_a.fieldName)
```
Ок, но поля сами по себе мало что значат, где методы? — Да тут же, рядом!
Имея псевдокод:
```
class ClassNameA {
object method () {
return "value"
}
}
```
превратим в Enyo код:
```
enyo.kind({
name: 'ClassNameA',
method: function(){ return 'value' }
})
```
Теперь мы можем создать экземпляр класса и проверить что метод класса доступен:
```
var cls_a = new ClassNameA()
console.log(cls_a.method())
```
Ок, есть поля, есть методы… может еще и конструктор/деструктор есть? — Конечно! Конструкторов аж 2 штуки!!! Но, будем последовательны.
При создании любого Enyo объекта вызывается его метод `constructor`, если необходима инициализация — стоит его переопределить.
Выглядит это следующим образом:
```
enyo.kind({
name: 'ClassNameC',
constructor: function() {
// Собственно конструктор
console.log('constructor')
}
})
```
Для обращения к методу (в данном случае конструктору) базового класса в Enyo предусмотрена конструкция `this.inherited(arguments)`. Стоит отметить что `this.inherited(arguments)` работает для всех методов которые вы планируете переопределять.
Как следствие код станет следующим:
```
enyo.kind({
name: 'ClassNameC',
constructor: function() {
console.log('my init befor constructor')
this.inherited(arguments)
console.log('my init after constructor')
}
})
```
Все вышеописанное справедливо для всех объектов Enyo создаваемых пользователем, но тут есть дополнение…
Тип «enyo.Component» — если вкратце, то этот зверь является одним из базовых классов для «enyo.Control» (того самого который по-умолчанию `div`).
Среди его полей и методов значатся:
* name — поле отвечающее за типизацию/именование объектов
* createComponent / createComponents — методы для динамического создания дочерних компонентов
* destroyComponents — методы для динамического удаления дочерних компонентов
* owner — поле-ссылка на родителя текущего компонента
* id — думаю и так понятно
* и много вкусных методов по работе с event-ами, но о них в следующих топиках
Как ни крути, а такой функционал достоин внимания. Так вот этот самый «enyo.Component» вводит еще 2 метода в жизненный цикл своих «детей»:
```
enyo.kind({
name: 'ClassNameD',
// Этот метод был рассмотрен ранее
constructor: function() {
this.inherited(arguments);
},
// Этот метод вызывается при createComponent / createComponents
create: function() {
this.inherited(arguments);
},
// Этот метод вызывается при destroyComponents
destroy: function() {
this.inherited(arguments);
}
});
```
В чем соль? Да все очень просто!
Внутри «enyo.Component» и в частности «enyo.Control» может быть вложено множество элементов, а внутри них еще и т.д.
Как строить это дерево? Как связывать это дерево с DOM? Как пересчитывать размеры при добавлении / удалении элементов?
Как привязать / удалить event-ы? Чувствуете? Ага, свой маленький граф объектов с шашками и поэтессами!
Ради справедливости спешу сообщить что создание / удаление элементов и их фактическая отрисовка в DOM разнесены функционально.
Создание/Удаление дочерних элементов при создании нового экземпляра происходит по create/destroy. Доступ к вышестоящему узлу осуществляется по полю «owner», а к дочерним узлам по «this.$»
Офф. документация гласит: если ваш объект унаследован от «enyo.Component» или его потомков — используйте в качестве конструктора create т.к. он вызывается сразу после constructor, в противном случае — constructor.
Итог:
```
enyo.kind({
name: 'ClassNameD',
create: function() {
// this.$ - пуст
this.inherited(arguments)
// this.$ - содержит дочерние элементы, и их методы create уже завершены
},
destroy: function() {
// this.$ - содержит дочерние элементы
this.inherited(arguments);
// this.$ - пуст
}
});
```
#### Ссылки
[Наследование в Enyo. GitHub wiki Enyo](https://github.com/enyojs/enyo/wiki/Creating-Kinds)
[Object lifecycle Enyo. GitHub wiki Enyo](https://github.com/enyojs/enyo/wiki/Object-Lifecycle)
[enyo.Component. Enyo API](http://enyojs.com/api/#enyo.Component)
[enyo.Control. Enyo API](http://enyojs.com/api/#enyo.Control) | https://habr.com/ru/post/204598/ | null | ru | null |
# Делаем калейдоскоп на CSS+JS
Я как-то раньше никогда не задумывался над такой штукой, как калейдоскоп на странице. Видел их как-то раньше, но не обращал особо внимания. А тут увидел у Лебедева в портфолио [калейдоскоп](http://www.artlebedev.ru/everything/gsl/site/) на флеше, покрутил по нему мышкой, понял принцип работы и подумал «ёлки, это же не сложно!».
Конечно, нельзя сказать, что это действительно очень просто. И нельзя сказать, что получилось совсем всё, что хотелось. Но есть на что посмотреть, за чем приглашаю под кат.
**UPD**
В посте добавил улучшенный вариант от хабрачеловека [hlomzik](https://habrahabr.ru/users/hlomzik/), который не работает в ИЕ, но с меньшим кол-вом кода и с более правильным поведением.
В самом начале, я надеялся, что он будет работать совсем везде и хорошо. Не совсем получилось. В результате:
* **Firefox / Safari / Chrome** — Работает идеально (кто бы сомневался).
* **IE8** — работает, но только если калейдоскоп небольшой (до 300х300). Если больше — начинает серьезно тормозить.
* **IE7** — будет работать, если добавить для него отдельный CSS в котором поправить позиционирование блоков.
* **Opera** — ничерта не работает. Это отдельная песня. Сразу обращаюсь к ребятам из Оперы, которые это прочтут — посмотрите на демо и оформите это как багрепорт. В «самом быстром браузере на земле»© CSS-transform тормозит на столько безбожно, что это не лезет ни в какие ворота. И опять оперная вечная проблема — полная лажа при использовании overflow:hidden и не static-позиционированных элементах. СДЕЛАЙТЕ С ЭТИМ ЧТО-ТО!
Сразу дам ссылку на рабочий пример, чтоб было понятно, о чем вообще речь: [kaleidoscope.terion.name](http://kaleidoscope.terion.name/)
Итак, поехали.
#### Задача 1: понять, как вообще это сделать.
Калейдоскоп состоит из 12 секторов, собранных в диск. Соответственно возникает вопрос: как сделать сектор? На самом деле, это очень просто. Нам понадобится 4 блока и немного CSS. Выглядеть это должно так:
Блок-контейнер, один блок повернутый на -15°, внутри блок повернутый на 30°, внутри еще один повернутый на -15°.
У сектора установлена фоновая картинка, которую мы будем смещать.
#### Задача 2: собственно, собрать это все.
Код, соответственно очень простой:
> `class="sc s1">
>
> class="rl">
>
> class="rr">
>
> class="sv">`
Да, мы сразу предполагаем, что на странице может быть несколько калейдоскопов, поэтому используем только классы.
**Важное условие**: размер калейдоскопа должен меняться путем изменения размеров только контейнера, соответственно внутри всё должно быть в процентах.
Сразу отмечу, что значения в процентах были подобраны методом научного тыка, т.к. мои знания тригонометрии не столь глубоки, чтобы рассчитать всё это :)
> `1. .scope\_container .sc {
> 2. width:50%;
> 3. height:50%;
> 4. -webkit-transform-origin: top center;
> 5. -moz-transform-origin: top center;
> 6. -o-transform-origin:top center;
> 7. transform-origin:top center;
> 8. position:absolute;
> 9. top:50%;
> 10. left:25%;
> 11. z-index:-1;
> 12. }
> 13.
> 14. .scope\_container .sc div {
> 15. overflow:hidden}
> 16.
> 17. .scope\_container .rl {
> 18. height:110%;
> 19. width:60%;
> 20. -webkit-transform: rotate(-15deg);
> 21. -moz-transform: rotate(-15deg);
> 22. -o-transform: rotate(-15deg);
> 23. transform: rotate(-15deg);
> 24. position:relative;
> 25. top:1.5%;
> 26. left:4.5%;
> 27.
> 28. }
> 29.
> 30. .scope\_container .rr {
> 31. height:100%;
> 32. width:100%;
> 33. -webkit-transform: rotate(30deg);
> 34. -moz-transform: rotate(30deg);
> 35. -o-transform: rotate(30deg);
> 36. transform: rotate(30deg);
> 37. position:relative;
> 38. top:7%;
> 39. left:51%;
> 40. }
> 41.
> 42. .scope\_container .sv {
> 43. width:105%;
> 44. height:105%;
> 45. -webkit-transform: rotate(-15deg);
> 46. -moz-transform: rotate(-15deg);
> 47. -o-transform: rotate(-15deg);
> 48. transform: rotate(-15deg);
> 49. position:relative;
> 50. top:-2%;
> 51. left:-29%;
> 52. }`
Итак, у нас есть код для сектора. Теперь этих секторов должно быть 12 и ни должны быть завернуты в 2 контейнера, т.к. внутренний используется для позиционирования элементов, а внешний — для задания размеров и обрезки лишнего.
В итоге весь хтмл-код будет таким:
> `1. <div class="parent">
> 2. <div class="scope\_container pattern">
> 3.
> 4. <div class="sc s1"><div class="rl"><div class="rr"><div class="sv">div>div>div>div>
> 5. <div class="sc s2"><div class="rl"><div class="rr"><div class="sv">div>div>div>div>
> 6. <div class="sc s3"><div class="rl"><div class="rr"><div class="sv">div>div>div>div>
> 7. <div class="sc s4"><div class="rl"><div class="rr"><div class="sv">div>div>div>div>
> 8. <div class="sc s5"><div class="rl"><div class="rr"><div class="sv">div>div>div>div>
> 9. <div class="sc s6"><div class="rl"><div class="rr"><div class="sv">div>div>div>div>
> 10. <div class="sc s7"><div class="rl"><div class="rr"><div class="sv">div>div>div>div>
> 11. <div class="sc s8"><div class="rl"><div class="rr"><div class="sv">div>div>div>div>
> 12. <div class="sc s9"><div class="rl"><div class="rr"><div class="sv">div>div>div>div>
> 13. <div class="sc s10"><div class="rl"><div class="rr"><div class="sv">div>div>div>div>
> 14. <div class="sc s11"><div class="rl"><div class="rr"><div class="sv">div>div>div>div>
> 15. <div class="sc s12"><div class="rl"><div class="rr"><div class="sv">div>div>div>div>
> 16.
> 17. div>
> 18. div>`
Классы s1 — s12 для определения положения каждого сектора.
Класс pattern определяет, какая картинка будет использована (спасибо [eto\_moy\_nick](https://habrahabr.ru/users/eto_moy_nick/) за паттерн :) )
Расставляем блоки по местам:
> `1. .scope\_container .s1 {
> 2. -webkit-transform: rotate(0deg);
> 3. -moz-transform: rotate(0deg);
> 4. -o-transform: rotate(0deg);
> 5. transform: rotate(0deg);
> 6. }
> 7. .scope\_container .s2 {
> 8. -webkit-transform: rotate(30deg);
> 9. -moz-transform: rotate(30deg);
> 10. -o-transform: rotate(30deg);
> 11. transform: rotate(30deg);
> 12. }`
И так до 12го с шагом в 30 градусов.
В общем-то и всё.
Но ведь есть ИЕ, который всего этого не понимает! Но для ИЕ есть фильтры **filter: progid:DXImageTransform.Microsoft.Matrix(...)**.
Поэтому, в условный комментарий [if IE 8] добавляем следующий код:
> `1. .scope\_container .s1 {
> 2. -webkit-transform: rotate(0deg);
> 3. -moz-transform: rotate(0deg);
> 4. -o-transform: rotate(0deg);
> 5. transform: rotate(0deg);
> 6. }
> 7. .scope\_container .s2 {
> 8. -webkit-transform: rotate(30deg);
> 9. -moz-transform: rotate(30deg);
> 10. -o-transform: rotate(30deg);
> 11. transform: rotate(30deg);
> 12. }`
Как показали опыты, с абсолютным позиционированием и матрицей у ИЕ беда. Поэтому пришлось такие костыли городить.
Далее:
> `1. .s2 {
> 2. filter: progid:DXImageTransform.Microsoft.Matrix(M11=0.86602540, M12=-0.50000000, M21=0.50000000, M22=0.86602540,SizingMethod='auto expand',FilterType='nearest neighbor');
> 3. margin:-64.5% 0 0 -25%;
> 4. }
> 5. .s3 {
> 6. filter: progid:DXImageTransform.Microsoft.Matrix(M11=0.50000000, M12=-0.86602540, M21=0.86602540, M22=0.50000000,SizingMethod='auto expand',FilterType='nearest neighbor');
> 7. margin:-60.5% 0 0 -32.8%;
> 8. }`
И т.п.
К моему удивлению, **FilterType='nearest neighbor'** не принес результата (без бикубического сглаживания, скорее всего, не было бы таких тормозов).
Для расчетов матрицы я пользовался вот этим инструментом, просто спасшим мне жизнь: [www.boogdesign.com/examples/transforms/matrix-calculator.html](http://www.boogdesign.com/examples/transforms/matrix-calculator.html)
Маржинами были вручную расставлены блоки. Если есть желание заставить это все работать в ИЕ7 — нужно лишь для него переписать эти самые маржины.
#### Задача 3: заставить это двигаться
Javascript. Нужно двигать фон секторов за мышкой. При этом мы помним, что калейдоскоп на странице не один. Код ниже, читаем комментарии:
> `1. "text/javascript"</font>></li>
> <li> </li>
> <li><font color="#008000">//Мы используем классы, но ИЕ не умеет их выбирать. Компенсируем этот недостаток.</font></li>
> <li><font color="#0000ff">if</font>(<font color="#0000ff">document</font>.getElementsByClassName) {</li>
> <li> </li>
> <li> getElementsByClass = <font color="#0000ff">function</font>(classList, node) { </li>
> <li> <font color="#0000ff">return</font> (node || <font color="#0000ff">document</font>).getElementsByClassName(classList)</li>
> <li> }</li>
> <li> </li>
> <li> } <font color="#0000ff">else</font> {</li>
> <li> </li>
> <li> getElementsByClass = <font color="#0000ff">function</font>(classList, node) { </li>
> <li> <font color="#0000ff">var</font> node = node || <font color="#0000ff">document</font>,</li>
> <li> list = node.getElementsByTagName(<font color="#A31515">'\*'</font>),</li>
> <li> length = list.length, </li>
> <li> classArray = classList.split(/\s+/),</li>
> <li> classes = classArray.length,</li>
> <li> result = [], i,j</li>
> <li> <font color="#0000ff">for</font>(i = 0; i < length; i++) {</li>
> <li> <font color="#0000ff">for</font>(j = 0; j < classes; j++) {</li>
> <li> <font color="#0000ff">if</font>(list[i].className.search(<font color="#A31515">'\\b'</font> + classArray[j] + <font color="#A31515">'\\b'</font>) != -1) {</li>
> <li> result.push(list[i])</li>
> <li> <font color="#0000ff">break</font></li>
> <li> }</li>
> <li> }</li>
> <li> }</li>
> <li> </li>
> <li> <font color="#0000ff">return</font> result</li>
> <li> }</li>
> <li> }</li>
> <li> </li>
> <li> </li>
> <li><font color="#008000">//Получаем координаты мыши</font></li>
> <li><font color="#0000ff">function</font> mousePageXY(e)</li>
> <li>{</li>
> <li> <font color="#0000ff">var</font> x = 0, y = 0;</li>
> <li> </li>
> <li> <font color="#0000ff">if</font> (!e) e = window.<font color="#0000ff">event</font>;</li>
> <li> </li>
> <li> <font color="#0000ff">if</font> (e.pageX || e.pageY)</li>
> <li> {</li>
> <li> x = e.pageX;</li>
> <li> y = e.pageY;</li>
> <li> }</li>
> <li> <font color="#0000ff">else</font> <font color="#0000ff">if</font> (e.clientX || e.clientY)</li>
> <li> {</li>
> <li> x = e.clientX + (<font color="#0000ff">document</font>.documentElement.scrollLeft || <font color="#0000ff">document</font>.body.scrollLeft) - <font color="#0000ff">document</font>.documentElement.clientLeft;</li>
> <li> y = e.clientY + (<font color="#0000ff">document</font>.documentElement.scrollTop || <font color="#0000ff">document</font>.body.scrollTop) - <font color="#0000ff">document</font>.documentElement.clientTop;</li>
> <li> }</li>
> <li> </li>
> <li> <font color="#0000ff">return</font> {<font color="#A31515">"x"</font>:x, <font color="#A31515">"y"</font>:y};</li>
> <li>}</li>
> <li> </li>
> <li> </li>
> <li>window.onload = <font color="#0000ff">function</font>() {</li>
> <li> </li>
> <li><font color="#0000ff">var</font> scope\_cont = getElementsByClass(<font color="#A31515">'scope\_container'</font>, <font color="#0000ff">document</font>);</li>
> <li> </li>
> <li><font color="#008000">//Калейдоскопов может быть несколько, учитываем это.</font></li>
> <li><font color="#0000ff">for</font> (i=0;i<scope\_cont.length;i++)</li>
> <li>{</li>
> <li> scope\_cont[i].onmouseover = <font color="#0000ff">function</font>() {</li>
> <li> <font color="#0000ff">var</font> sect = getElementsByClass(<font color="#A31515">'sv'</font>, <font color="#0000ff">this</font>);</li>
> <li> <font color="#0000ff">var</font> curscope = <font color="#0000ff">this</font>;</li>
> <li> </li>
> <li> <font color="#0000ff">this</font>.onmousemove = <font color="#0000ff">function</font>(e){</li>
> <li> <font color="#0000ff">var</font> mCur = mousePageXY(e); </li>
> <li> <font color="#0000ff">for</font> (n=0;n<sect.length;n++)</li>
> <li> {</li>
> <li> <font color="#008000">//У четных секторов фон двигается в одну сторону</font></li>
> <li> <font color="#0000ff">if</font> (n%2) {</li>
> <li> sect[n].style.backgroundPosition = mCur.x + <font color="#A31515">'px '</font> + mCur.y + <font color="#A31515">'px'</font>;</li>
> <li> }</li>
> <li> <font color="#008000">//У нечетных — в другую</font></li>
> <li> <font color="#0000ff">else</font> {</li>
> <li> sect[n].style.backgroundPosition = mCur.x\*(-1) + <font color="#A31515">'px '</font> + mCur.y + <font color="#A31515">'px'</font></li>
> <li> }</li>
> <li> }</li>
> <li> </li>
> <li> }</li>
> <li> }</li>
> <li> scope\_cont[i].onmouseout = <font color="#0000ff">function</font>() {</li>
> <li> <font color="#008000">//Убираем за собой, чтоб не перегружать браузер</font></li>
> <li> <font color="#0000ff">document</font>.onmousemove = <font color="#0000ff">null</font>;</li>
> <li> }</li>
> <li>}</li>
> <li>}</li>
> <li>`
В общем-то, готово.
**Opera:**
Если блоку .pattern добавить overflow:hidden — пропадает ВСЁ. В итоге пустая страница со скроллами в пустоту на ширину «веера».
Если overflow:hidden убрать, то в «самом быстром браузере на земле»© эта конструкция работает медленнее, чем в ИЕ.
Это полный провал.
Надеюсь, вам было интересно :)
**UPD**
А вот и улучшенный вариант от хабрачеловека [hlomzik](https://habrahabr.ru/users/hlomzik/):
[quaint.su/for/habrahabr/kaleidoscope](http://quaint.su/for/habrahabr/kaleidoscope/)
Обсуждение, в котором это родилось, вот: [habrahabr.ru/blogs/css/99019/?reply\_to=3057019#comment\_3054307](http://habrahabr.ru/blogs/css/99019/?reply_to=3057019#comment_3054307) | https://habr.com/ru/post/99019/ | null | ru | null |
# OpenSCG’s HA failover solution “PGHA”. Решение Master-Slave для PostgreSQL 9.3
Ниже будет описан опыт настройки отказоустойчивой системы Master-Slave с использованием собственных ресурсов PostgresSQL — Asynchronous Replication + pgBouncer + PGHA — в формате вольного перевода с комментариями [одного поста](http://www.rummandba.com/2013/12/pgha-postgresqlpgbouncer-high.html) и руководства по [установке](https://bitbucket.org/openscg/pgha/src/95ab4749b33dafb36e9632bb509ee6c4deb43b14/doc/?at=master).
##### pgHA
[pgHA](http://www.openscg.com/postgresql-ha-automatic-failover/) — программа, написанная на Perl, код которой представлен в файле failoverd.pl, который и является основой инструмента. Использует в своей работе pgbouncer и собственную репликацию PostgresSQL; мониторит ведущую бд и в случае ее недоступности открывает вспомогательную бд на запись, останавливая репликацию. По крайней мере с версии 9.3 устанавливается вместе с PostgresSQL, скачать можно [здесь](https://bitbucket.org/openscg/pgha/downloads). Процесс установки описан в файле [README](https://bitbucket.org/openscg/pgha/src/95ab4749b33dafb36e9632bb509ee6c4deb43b14/doc/?at=master), который лежит в ./9.3/pgha/doc/.
На habrahabr, судя по всему, самым популярным инструментом для организации отказоустойчивости является pgpool. К сожалению существующий единичный опыт не позволяет сравнить эти два инструмента.
##### Настройка
Данная система требует наличия трех машин: ведущего сервера (master), вспомогательного (slave) и узла масштабирования. Можно обойтись без последнего.
###### 1. Настройка репликации
Про настройку нативной репликации уже написано в очень многих статьях, под этим предлогом я просто сошлюсь на некоторые:
* [www.rummandba.com/2013/08/postgresql-92-streaming-replication.html](http://www.rummandba.com/2013/08/postgresql-92-streaming-replication.html)
* [habrahabr.ru/post/106872](http://habrahabr.ru/post/106872/)
* [habrahabr.ru/post/188096](http://habrahabr.ru/post/188096/)
###### 2. Настройка pgBouncer
[pgBouncer](http://wiki.postgresql.org/wiki/PgBouncer) — легкий пулер, менеджер соединений для PostgreSQL. Здесь используется как входная точка доступа, которая перенаправляет запросы к главной бд или вспомогательной в зависимости от файла настроек. Устанавливается вместе с PostgresSQL 9.3.
1. Начать настройку нужно с создания пользователя bouncer и пароля к нему на сервере — узле масштабирования, или на любой другой машине которая будет следить за состоянием ведущего сервера.
2. Далее подготовить 2 файла pgbouncer.ini.orig и pgbouncer.ini.failover. Это файлы настройки pgbouncer и по сути отличаются лишь IP хостами бд: в файле .orig указан IP и порт ведущей бд, в .failover — вспомогательной. Примеры можно найти [здесь](https://bitbucket.org/openscg/pgha/src/95ab4749b33d/support/pgBouncer/cfg/?at=master).
— нужно создать пустой log файл и указать путь к нему
— еще нужно создать файл userlist.txt с пользователями под которыми будут делаться запросы через pgbouncer и не забыть указать путь к нему (поле auth\_file), пример можно найти в ./9.3/share/doc/pgbouncer или [здесь](https://bitbucket.org/openscg/pgha/src/95ab4749b33d/support/pgBouncer/cfg/?at=master)
— выбрать пользователей из созданных, которые будут обладать правами админа в отношении к pgbouncer и указать их в поле admin\_users
— также нужно указать порт на котором будет находиться pgbouncer (listen\_port) и далее, предварительно ознакомившись с другими заполненными полями и внеся где хочется изменения, можно обращаться к pgbouncer как к обычной бд… после запуска.
3. Создать файл pgbouncer.ini и скопировать в него содержимое файла pgbouncer.ini.orig. Это рабочий файл и в него далее будут копироваться файлы pgbouncer.ini.orig или pgbouncer.ini.failover в зависимости от ситуации. Создать пустой файл pgbouncer.ini\_old, он будет использоваться pgha.
4. Запустить pgbouncer от лица пользователя bouncer:
`pgbouncer -d /путь/pgbouncer.ini`
###### 3. Настройка pgHA
1. pgHA использует некоторые Perl модули, которые требуется предварительно установить. Перед этим нужно установить CPAN:
```
yum install perl-CPAN
perl -MCPAN -e 'install Module::Build::Compat'
perl -MCPAN -e 'install Config::IniFiles'
perl -MCPAN -e 'install DBI'
perl -MCPAN -e 'install DBD::Pg'
perl -MCPAN -e 'install Log::Log4perl'
perl -MCPAN -e 'install Proc::Daemon'
perl -MCPAN -e 'install Net::Ping'
perl -MCPAN -e 'install Nagios::Plugin'
```
При этом может возникать безвредная ошибка: yaml' not installed will not store persistent state. Если раздражает, можно сделать:
```
cpan
install Bundle::CPAN
reload cpan
exit
```
2. Далее следует подготовить файл настроек для pgHA, примеры которого можно найти в папке ./9.3/pgHA/cfg/ или [здесь](https://bitbucket.org/openscg/pgha/src/95ab4749b33dafb36e9632bb509ee6c4deb43b14/cfg/?at=master): файлы example.conf и scottmVm.conf, лучше ориентироваться на второй:
— pidFile может лежать в любом месте, нужно убедиться в доступности выбранного пути.
— logConfig находится в ./9.3/pgHA/cfg/log4perl.conf и содержит настройки логирования
— для triggerFile нужно указать файл указанный в recovery.conf
— раздел [failover] пока лучше удалить, чуть ниже будет упомянуто и о нем
— в разделе [app01] содержатся настройки pgbouncer, в том числе в конце файла описаны команды которые в случае отказа ведущей базы удаляют все соединения к ней и затем перезапускают pgbouncer для работы с новой главной бд:
```
# Which databases should be part of failover
fence_lock_dbs=postgres
# pgBouncer command to pause / fence the db's
fence_lock_command=kill
# pgBouncer command to reload the config file
fence_move_command=reload
# pgBouncer command to unlock the db's
fence_unlock_command=resume
dbcheck="select 1"
```
— в разделе [app01] в поле pgbouncer\_db\_user должен стоять один из admin\_users указанных в pgbouncer.ini
— следует ознакомиться и с остальными параметрами
3. Затем создать пустой log файл pgHA.log в папке /opt/pgHA/log/. Именно этот путь использует по умолчанию pgHA.
4. На ведущем сервере создать таблицу описанную в файле ./9.3/pgha/cfg/status\_table.sql, или [здесь](https://bitbucket.org/openscg/pgha/src/95ab4749b33dafb36e9632bb509ee6c4deb43b14/cfg/status_table.sql?at=master) в бд указанной в поле dbname в разделе [master].
5. Сгенерировать ssh ключ пользователя от имени которого будет запускаться pgHA и переслать его пользователю bouncer:
— `ssh-keygen -t rsa` (создать пустой пароль)
— скопировать содержимое ~/.ssh/id\_rsa.pub
— на машине с пользователем bouncer от его лица выполнить команды:
`mkdir ~/.ssh`
`chmod 0700 .ssh`
`vi authorized_keys` (вставить ранее скопированное содержимое id\_rsa.pub, закрыть с сохранением)
`chmod 0600 .ssh/authorized_keys`
6. Запустить pgHA.
`./failoverd.pl -c /путь/файлНастроекPgHA.conf --auto`
Файл failoverd.pl лежит в папке ./9.3/pgHA/bin.
7. Если пункт 6 прошел без ошибок, остановить pgHA
`./failoverd.pl -c /путь/файлНастроекPgHA.conf --stop`
В данном состоянии pgHA автоматического failover не случится. Нужно открыть файл failoverd.pl, закомментировать строчку 443 и откомментировать 442 согласно коду представленному [здесь](https://bitbucket.org/openscg/pgha/src/95ab4749b33dafb36e9632bb509ee6c4deb43b14/bin/failoverd.pl?at=master#cl-375). Должно получиться:
```
# Start the failoverd monitoring process
elsif ( $startWorker )
{
print "\n\tInitializing... \n";
. . .
# Once we have verified that the system is online, we need
# to set the failover 'spring'.
$logger->info("==Startup==: Arming Failover mechanism");
print "\t === Arming Failover mechanism === \n";
if ( SetSpring(%Config,$logger) != 1 )
# if ( 0 )
{
$logger->info("Cannot set failover configuration, exiting...");
print "Cannot set failover configuration, exiting...\n";
exit(1);
}
. . .
```
Теперь при отказе ведущей базы pgHA остановит репликацию, откроет вспомогательную базу на запись, перезапустит pgbouncer с настройками для роботы с новой главной бд и завершит свою работу. Возвращать систему в исходное состояние требуется в ручную.
8. Запустить pgHA. Тестить.
##### P.S.
В разделе [failover] указываются команды, которые исполняются во время failover. Таким образом можно, например, не менять код в failoverd.pl, а создать скрипт — который меняет файл настроек pgbouncer и перезагружает его — и указать на него.
Данное решение не уменьшает скорость работы программ, использующих базу данных, и при хорошей настройке pgbouncer может ее увеличить. Плюсом также считаю открытость кода pgHA — его можно дополнять, чтобы научить, например, попыткам перезагрузить ведущую базу перед failover, возобновлять репликацию, менять шрифт в терминале и т.д.
Решение для postgres 8.4 представлено в вышеупомянутом [блоге](http://www.rummandba.com/2013/12/pgha-postgresqlpgbouncer-high.html). | https://habr.com/ru/post/223825/ | null | ru | null |
# Next.js: подробное руководство. Итерация вторая
Привет, друзья!
Хочу поделиться с вами заметками о `Next.js` (надеюсь, кому-нибудь пригодится).
`Next.js` — это основанный на `React` фреймворк, предназначенный для разработки веб-приложений, обладающих функционалом, выходящим за рамки `SPA`, т.е. так называемых одностраничных приложений.
Как известно, основным недостатком `SPA` являются проблемы с индексацией страниц таких приложений поисковыми роботами, что негативно влияет на `SEO`.
Впрочем, по моим личным наблюдениям, в последнее время ситуация стала меняться к лучшему, по крайней мере, страницы [`моего небольшого SPA-PWA-приложения`](https://typescript-handbook.ru/) нормально индексируются.
Кроме того, существуют специальные инструменты, такие как [`react-snap`](https://github.com/stereobooster/react-snap), позволяющие превратить `React-SPA` в многостраничник путем предварительного рендеринга приложения в статическую разметку. Метаинформацию же можно встраивать в `head` с помощью таких утилит, как [`react-helmet`](https://www.npmjs.com/package/react-helmet). Однако `Next.js` существенно упрощает процесс разработки многостраничных и гибридных приложений (последнего невозможно добиться с помощью того же `react-snap`). Он также предоставляет множество других интересных возможностей.
* [Документация](https://nextjs.org/docs/getting-started)
* [Примеры](https://github.com/vercel/next.js/tree/canary/examples)
*Обратите внимание*: данная статья предполагает, что вы обладаете некоторым опытом работы с `React`. Также *обратите внимание*, что заметки не сделают вас специалистом по `Next.js`, но позволят получить о нем исчерпывающее представление.
Заметки состоят из 2 частей. Это часть номер два.
[Итерация первая](https://habr.com/ru/company/timeweb/blog/588498/)
*Ремарка*: ссылки ниже могут оказаться нерабочими из-за особенностей парсинга `MD` хабровским редактором.
* [Продвинутые возможности](#%D0%BF%D1%80%D0%BE%D0%B4%D0%B2%D0%B8%D0%BD%D1%83%D1%82%D1%8B%D0%B5-%D0%B2%D0%BE%D0%B7%D0%BC%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D0%B8)
+ [Динамическая маршрутизация](#%D0%B4%D0%B8%D0%BD%D0%B0%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F-%D0%BC%D0%B0%D1%80%D1%88%D1%80%D1%83%D1%82%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F)
+ [Автоматическая статическая оптимизация](#%D0%B0%D0%B2%D1%82%D0%BE%D0%BC%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F-%D1%81%D1%82%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F-%D0%BE%D0%BF%D1%82%D0%B8%D0%BC%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F)
+ [Экспорт статической разметки](#%D1%8D%D0%BA%D1%81%D0%BF%D0%BE%D1%80%D1%82-%D1%81%D1%82%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B9-%D1%80%D0%B0%D0%B7%D0%BC%D0%B5%D1%82%D0%BA%D0%B8)
+ [Абсолютный импорт и синонимы путей модулей](#%D0%B0%D0%B1%D1%81%D0%BE%D0%BB%D1%8E%D1%82%D0%BD%D1%8B%D0%B9-%D0%B8%D0%BC%D0%BF%D0%BE%D1%80%D1%82-%D0%B8-%D1%81%D0%B8%D0%BD%D0%BE%D0%BD%D0%B8%D0%BC%D1%8B-%D0%BF%D1%83%D1%82%D0%B5%D0%B9-%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D0%B5%D0%B9)
+ [Кастомный сервер](#%D0%BA%D0%B0%D1%81%D1%82%D0%BE%D0%BC%D0%BD%D1%8B%D0%B9-%D1%81%D0%B5%D1%80%D0%B2%D0%B5%D1%80)
+ [Кастомное приложение](#%D0%BA%D0%B0%D1%81%D1%82%D0%BE%D0%BC%D0%BD%D0%BE%D0%B5-%D0%BF%D1%80%D0%B8%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5)
+ [Кастомные страницы ошибок](#%D0%BA%D0%B0%D1%81%D1%82%D0%BE%D0%BC%D0%BD%D1%8B%D0%B5-%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B8%D1%86%D1%8B-%D0%BE%D1%88%D0%B8%D0%B1%D0%BE%D0%BA)
+ [`Директория src`](#%D0%B4%D0%B8%D1%80%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D0%B8%D1%8F-src)
+ [Локализованная маршрутизация (интернационализация)](#%D0%BB%D0%BE%D0%BA%D0%B0%D0%BB%D0%B8%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%B0%D1%8F-%D0%BC%D0%B0%D1%80%D1%88%D1%80%D1%83%D1%82%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F-%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D0%BD%D0%B0%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F)
+ [Заголовки безопасности](#%D0%B7%D0%B0%D0%B3%D0%BE%D0%BB%D0%BE%D0%B2%D0%BA%D0%B8-%D0%B1%D0%B5%D0%B7%D0%BE%D0%BF%D0%B0%D1%81%D0%BD%D0%BE%D1%81%D1%82%D0%B8)
* [API](#api)
+ [Next CLI](#next-cli)
+ [Create Next App](#create-next-app)
+ [`next/router`](#nextrouter)
+ [`next/link`](#nextlink)
+ [`next/image`](#nextimage)
+ [`next/head`](#nexthead)
+ [`next/server`](#nextserver)
* [`next.config.js`](#nextconfigjs)
Продвинутые возможности
-----------------------
### Динамическая маршрутизация
`Next.js` поддерживает динамический `import`. Он позволяет загружать модули по необходимости. Это также работает с `SSR`.
В следующем примере мы реализуем неточный (fuzzy) поиск с помощью [`fuse.js`](https://fusejs.io/), загружая этот модуль динамически после того, как пользователь начинает вводить данные в поле для поиска:
```
import { useState } from 'react'
const names = ['John', 'Jane', 'Alice', 'Bob', 'Harry']
export default function Page() {
const [results, setResults] = useState([])
return (
{
// загружаем модуль динамически
const Fuse = (await import('fuse.js')).default
const fuse = new Fuse(names)
setResults(fuse.search(value))
}}
/>
```
Результаты поиска: {JSON.stringify(results, null, 2)}
```
)
}
```
Динамический импорт — это способ разделения кода на части (code splitting), позволяющий загружать только тот код, который фактически используется на текущей странице.
Для динамического импорта `React-компонентов` рекомендуется использовать `next/dynamic`.
**Обычное использование**
В следующем примере мы динамически загружаем модель `../components/Hello`:
```
import dynamic from 'next/dynamic'
import Header from '../components/Header'
const DynamicHello = dynamic(() => import('../components/Hello'))
export default function Home() {
return (
Главная страница
================
)
}
```
**Динамический импорт именованного компонента**
Предположим, что у нас имеется такой компонент:
```
// components/Hello.js
export const Hello = () => Привет!
```
Для его динамического импорта его необходимо вернуть из `Promise`, возвращаемого `import`:
```
import dynamic from 'next/dynamic'
import Header from '../components/Header'
const DynamicHello = dynamic(() =>
import('../components/Hello')
.then((module) => module.Hello)
)
export default function Home() {
return (
Главная страница
================
)
}
```
**Индикатор загрузки**
Для рендеринга состояния загрузки можно использовать настройку `loading`:
```
import dynamic from 'next/dynamic'
import Header from '../components/Header'
const DynamicHelloWithCustomLoading = dynamic(
() => import('../components/Hello'),
{ loading: () => Загрузка...
}
)
export default function Home() {
return (
Главная страница
================
)
}
```
**Отключение `SSR`**
Для отключения импорта модуля на стороне сервера можно использовать настройку `ssr`:
```
import dynamic from 'next/dynamic'
import Header from '../components/Header'
const DynamicHelloWithNoSSR = dynamic(
() => import('../components/Hello'),
{ ssr: false }
)
export default function Home() {
return (
Главная страница
================
)
}
```
Настройка `suspense` позволяет загружать компонент лениво подобно тому, как это делает сочетание `React.lazy` и . *Обратите внимание*, что это работает только на клиенте или на сервере с `fallback`. Полная поддержка `SSR` в конкурентном режиме находится в процессе разработки:
```
import dynamic from 'next/dynamic'
import Header from '../components/Header'
const DynamicLazyHello = dynamic(() => import('../components/Hello'), { suspense: true })
export default function Home() {
return (
Главная страница
================
)
}
```
### Автоматическая статическая оптимизация
Если на странице присутствуют `getServerSideProps`, `Next.js` будет рендерить страницу при каждом запросе (рендеринг на стороне сервера).
В противном случае, `Next.js` выполняет предварительный рендеринг страницы в статическую разметку.
В процессе предварительного рендеринга объект роутера `query` будет пустым. После гидратации `Next.js` запускает обновление приложения для заполнения `query` параметрами маршрутизации.
`next build` генерирует HTML-файлы для статически оптимизированных страниц. Например, результатом для `pages/about.js` будет:
```
.next/server/pages/about.html
```
А если на эту страницу добавить `getServerSideProps`, то результат будет таким:
```
.next/server/pages/about.js
```
**Заметки**
* при наличии кастомного `App` оптимизация для страниц без статической генерации отключается
* при наличии кастомного `Document` с `getInitialProps` убедитесь в определении `ctx.req` перед рендерингом страницы на стороне сервера. Для страниц, которые рендерятся предварительно, `ctx.req` будет иметь значение `undefined`
### Экспорт статической разметки
`next export` позволяет экспортировать приложение в статический `HTML`. Такое приложение может запускаться без сервера.
Такое приложение поддерживает почти все возможности, предоставляемые `Next.js`, включая динамическую маршрутизацию, предварительный запрос и получение данных и динамический импорт.
`next export` работает за счет предварительного рендеринга всех страниц в `HTML`. Для динамических роутов страница может экспортировать функцию `getStaticPaths`, чтобы `Next.js` мог определить, какие страницы следует рендерить для данного роута.
`next export` рассчитан для приложений без рендеринга на стороне сервера или инкрементального рендеринга. Такие фичи, как инкрементальная статическая генерация и регенерация при использовании `next export` будут отключены.
Для экспорта приложения в статику после разработки приложения следует выполнить команду:
```
next build && next export
```
Статическая версия приложения будет записана в директорию `out`.
По умолчанию `next export` не требует настройки. HTML-файлы генерируются для всех страниц, определенных в директории `pages`. Для более продвинутых сценариев можно определить параметр `exportPathMap` в `next.config.js` для настройки генерируемых страниц.
**Заметки**
* с помощью `next export` мы генерируем HTML-версию приложения. Во время сборки для каждой страницы вызывается функция `getStaticProps`, результаты выполнения которой передаются компоненту страницы в виде пропов. Вместо `getStaticProps` можно использовать старый интерфейс `getInitialProps`, но это имеет некоторые ограничения
* режим `fallback: true` в `getStaticProps` не поддерживается
* интерфейс маршрутизации не поддерживается
* `getServerSideProps` не поддерживается
* локализованный роутинг не поддерживается
* дефолтный индикатор загрузки компонента `Image` не поддерживается (другие настройки `loader` поддерживаются)
### Абсолютный импорт и синонимы путей модулей
`Next.js` поддерживает настройки `baseUrl` и `paths` в файлах `tsconfig.json` и `jsconfig.json`.
`baseUrl` позволяет импортировать модули напрямую из корневой директории.
Пример:
```
// `tsconfig.json` или `jsconfig.json`
{
"compilerOptions": {
"baseUrl": "."
}
}
```
```
// components/button.js
export const Button = () => Click Me
// pages/index.js
import { Button } from 'components/button'
export default function Index() {
return (
<>
Привет, народ!
==============
)
}
```
`paths` позволяет определять синонимы для путей модулей. Например:
```
// `tsconfig.json` или `jsconfig.json`
{
"compilerOptions": {
"baseUrl": ".",
"paths": {
"@/*": ["components/*"]
}
}
}
```
```
// components/button.js
export const Button = () => Click Me
// pages/index.js
import { Button } from '@/button'
export default function Index() {
return (
<>
Привет, народ!
==============
)
}
```
### Кастомный сервер
Пример кастомного сервера:
```
// server.js
const { createServer } = require('http')
const { parse } = require('url')
const next = require('next')
const dev = process.env.NODE_ENV !== 'production'
const app = next({ dev })
const handle = app.getRequestHandler()
app.prepare().then(() => {
createServer((req, res) => {
// `true` обеспечивает разбор строки запроса
const parseUrl = parse(req.url, true)
const { pathname, query } = parseUrl
switch (pathname) {
case '/a':
return app.render(req, res, '/a', query)
case '/b':
return app.render(req, res, '/b', query)
default:
handle(req, res, parsedUrl)
}
}).listen(3000, (err) => {
if (err) throw err
console.log('Запущен по адресу: http://localhost:3000')
})
})
```
Для запуска этого сервера необходимо обновить раздел `scripts` в файле `package.json` следующим образом:
```
"scripts": {
"dev": "node server.js",
"build": "next build",
"start": "NODE_ENV=production node server.js"
}
```
Кастомный сервер использует такой импорт для подключения к `Next.js-приложению`:
```
const next = require('next')
const app = next({})
```
`next` — это функция, которая принимает объект со следующими настройками:
* `dev: boolean` — запуск сервера в режиме для разработки
* `dir: string` — корневая директория проекта (по умолчанию `.`)
* `quiet: boolean` — если `true`, ошибки сервера не отображаются (по умолчанию `false`)
* `conf: object` — такой же объект, что используется в `next.config.js`
После этого `app` может использоваться для обработки входящих запросов.
По умолчанию `Next.js` обслуживает каждый файл в директории `pages` по пути, совпадающему с названием файла. При использовании кастомного сервера это может привести к возвращению одинакового контента для разных путей.
Для отключения маршрутизации, основанной на файлах в `pages`, используется настройка `useFileSystemPublicRoutes` в `next.config.js`:
```
module.exports = {
useFileSystemPublicRoutes: false
}
```
*Обратите внимание*: это отключает роутинг по названиям файлов только для `SSR`. Маршрутизация на стороне клиента по-прежнему будет иметь доступ к этим путям.
### Кастомное приложение
`Next.js` использует компонент `App` для инициализации страниц. Кастомизация этого компонента позволяет делать следующее:
* распределять макет (layout) между страницами
* сохранять состояние при переключении между страницами
* обрабатывать ошибки с помощью `componentDidCatch`
* внедрять в страницы дополнительные данные
* добавлять глобальные стили
Для перезаписи дефолтного `App` необходимо создать файл `pages/_app.js` следующего содержания:
```
// pages/_app.js
import App from 'next/app'
function MyApp({ Component, pageProps }) {
return
}
MyApp.getInitialProps = async (appContext) => {
const appProps = await App.getInitialProps(appContext)
return { ...appProps }
}
export default MyApp
```
Проп `Component` — это активная страница. `pageProps` — это объект с начальными пропами, которые предварительно загружаются для страницы с помощью одного из методов для получения данных, в противном случае, данный объект будет пустым.
**Заметки**
* при добавлении кастомного `App` (создании файла `pages/_app.js`) при запущенном приложении может потребоваться перезапуск сервера для разработки
* добавление кастомного `getInitialProps` в `App` отключает автоматическую статическую оптимизацию страниц без статической генерации
* при добавлении `getInitialProps` в кастомное приложение следует `import App from 'next/app'`, вызвать `App.getInitialProps(appContext)` внутри `getInitialProps` и объединить объект ответа с возвращаемым значением
* в настоящее время `App` не поддерживает такие методы для получения данных, как `getStaticProps` или `getServerSideProps`
### Кастомные страницы ошибок
`Next.js` предоставляет дефолтные страницы для ошибок `404` и `500`. Для кастомизации этих страниц используются файлы `pages/404.js` и `pages/500.js`, соответственно:
```
// pages/404.js
export default function Custom404() {
return 404 - Страница не найдена
=========================
}
// pages/500.js
export default function Custom500() {
return 500 - Ошибка на сервере
=======================
}
```
Для получения данных во время сборки на этих страницах может использоваться `getStaticProps`.
Ошибки 500 обслуживаются как на стороне клиента, так и на стороне сервера компонентом `Error`. Для перезаписи этого компонента необходимо создать файл `pages/_error.js` и добавить в него код вроде следующего:
```
export default function Error({ statusCode }) {
return (
{statusCode
? `На сервере возникла ошибка ${statusCode}`
: `Ошибка возникла на клиенте`}
)
}
Error.getInitialProps = ({ res, err }) => {
const statusCode = res ? res.statusCode : err ? err.statusCode : 404
return { statusCode }
}
```
*Обратите внимание*: `pages/_error.js` используется только в продакшне. В режиме для разработки ошибка возвращается вместе со стеком вызовов для обеспечения возможности определения места ее возникновения.
Для рендеринга встроенной страницы ошибки также можно использовать компонент `Error`:
```
import Error from 'next/error'
export async function getServerSideProps() {
const res = await fetch('https://api.github.com/repos/harryheman/react-total')
const errorCode = res.ok ? false : res.statusCode
const data = await res.json()
return {
props: {
errorCode,
stars: data.stergazers_count
}
}
}
export default function Page({ errorCode, stars }) {
if (errorCode) {
return
}
return Количество звезд: {stars}
}
```
Компонент `Error` также принимает проп `title` для передачи текстового сообщения в дополнение к статус-коду.
### Директория `src`
Страницы приложения могут помещаться в директорию `src/pages` вместо корневой директории `pages`.
**Заметки**
* `src/pages` будет игнорироваться при наличии `pages`
* файлы с настройками, такие как `next.config.js` и `tsconfig.json` должны находиться в корневой директории проекта. Тоже самое касается директории `public`
### Локализованная маршрутизация (интернационализация)
`Next.js` имеет встроенную поддержку локализованного роутинга. Достаточно указать список локалей, дефолтную локаль и привязанные к домену локали.
Поддержка роутинга `i18n` означает интеграцию с такими библиотеками, как `react-intl`, `react-i18next`, `lingui`, `rosetta`, `next-intl` и др.
**Начало работы**
Для начала работы необходимо настроить `i18n` в файле `next.config.js`. Идентификатор локали выглядит как `язык-регион-скрипт`, например:
* `en-US` — американский английский
* `nl-NL` — нидерландский (голландский)
* `nl` — нидерландский без учета региона
```
// next.config.js
module.exports = {
i18n: {
// Локали, поддерживаемые приложением
locales: ['en-US', 'fr', 'nl-NL'],
// Дефолтная локаль, которая будет использоваться
// при посещении пользователем пути без префикса,
// например, `/hello`
defaultLocale: 'en-US',
// Список доменов и привязанных к ним локалей
// (требуется только в случае настройки маршрутизации на основе доменов)
// Обратите внимание: поддомены должны включаться в значение домена,
// например, `fr.example.com`
domains: [
{
domain: 'example.com',
defaultLocale: 'en-US'
},
{
domain: 'example.nl',
defaultLocale: 'nl-NL'
},
{
domain: 'example.fr',
defaultLocale: 'fr',
// Опциональное поле `http` может использоваться для локального тестирования
// локали, привязанной к домену (т.е. по `http` вместо `https`)
http: true
}
]
}
}
```
**Стратегии локализации**
Существует 2 стратегии локализации: маршрутизация на основе субпутей (subpaths) и роутинг на основе доменов.
*Роутинг на основе субпутей*
В этом случае локаль помещается в `url`:
```
// next.config.js
module.exports = {
i18n: {
locales: ['en-US', 'fr', 'nl-NL'],
defaultLocale: 'en-US'
}
}
```
Здесь `en-US`, `fr` и `nl-NL` будет доступны для перехода, а `en-US` будет использоваться по умолчанию. Для страницы `pages/blog` будут доступны следующие `url`:
* `/blog`
* `/fr/blog`
* `/nl-nl/blog`
Дефолтная локаль не имеет префикса.
*Роутинг на основе доменов*
В этом случае локали будут обслуживаться разными доменами:
```
// next.config.js
module.exports = {
i18n: {
locales: ['en-US', 'fr', 'nl-NL', 'nl-BE'],
defaultLocale: 'en-US',
domains: [
{
domain: 'example.com',
defaultLocale: 'en-US',
},
{
domain: 'example.fr',
defaultLocale: 'fr',
},
{
domain: 'example.nl',
defaultLocale: 'nl-NL',
// Список указанных локалей будет обслуживаться этим доменом
locales: ['nl-BE']
}
]
}
}
```
Для страницы `pages/blog` будут доступны следующие `url`:
* `example.com/blog`
* `example.fr/blog`
* `example.nl/blog`
* `example.nl/nl-BE/blog`
**Автоматическое определение локали**
Когда пользователь запускает приложение, `Next.js` пытается автоматически определить его локаль на основе заголовка `Accept-Language` и текущего домена. При обнаружении локали, отличающейся от дефолтной, выполняется перенаправление.
Если при посещении `example.com` запрос содержит заголовок `Accept-Language: fr;q=0.9`, в случае роутинга на основе домена выполняется перенаправление на `example.fr`, а в случае роутинга на основе субпутей — на `/fr`.
**Отключение автоматического определения локали**
```
// next.config.js
module.exports = {
i18n: {
localeDetection: false
}
}
```
**Доступ к информации о локали**
Информация о локали содержится в роутере, доступ к которому можно получить с помощью хука `useRouter`. Доступны следующие свойства:
* `locale` — текущая локаль
* `locales` — доступные локали
* `defaultLocale` — локаль по умолчанию
В случае предварительного рендеринга страниц с помощью `getStaticProps` или `getServerSideProps` информация о локали содержится в контексте, передаваемом функции.
При использовании `getStaticPaths` локали также содержатся в параметре `context`, передаваемом функции, в свойствах `locales` и `defaultLocale`.
**Переключение между локалями**
Для переключения между локалями можно использовать `next/link` или `next/router`.
Для `next/link` может быть указан проп `locale` для переключения на другую локаль. Если такой проп не указан, используется текущая локаль:
```
import Link from 'next/link'
export default function IndexPage(props) {
return (
Перейти к `/fr/another`
)
}
```
При использовании `next/router` локаль указывается в настройках:
```
import { useRouter } from 'next/router'
export default function IndexPage(props) {
const router = useRouter()
return (
{
router.push('/another', '/another', { locale: 'fr' })
}}
>
Перейти к `/fr/another`
)
}
```
*Обратите внимание*: для переключения локали с сохранением информации, хранящейся в роутере, такой так значения динамической строки запроса или значения скрытой строки запроса, в качестве значения пропа `href` можно использовать объект:
```
import { useRouter } from 'next/router'
const router = useRouter()
const { pathname, asPath, query } = router
// Переключаем локаль с сохранением другой информации
router.push({ pathname, query }, asPath, { locale: nextLocale })
```
Если `href` включает локаль, автоматическое добавления префикса можно отключить:
```
import Link from 'next/link'
export default function IndexPage(props) {
return (
Перейти к `/fr/another`
)
}
```
**Заметки**
* `Next.js` позволяет перезаписывать значение заголовка `Accept-Language` с помощью куки `NEXT_LOCALE=локаль`. При установке такой куки, `Accept-Language` будет игнорироваться.
* `Next.js` автоматически добавляет атрибут `lang` к тегу `html`. Однако, он не знает о возможных вариантах страницы, поэтому добавление мета-тега `hreflang` — задача разработчика (это можно сделать с помощью `next/head`).
**Статическая генерация**
*Динамические роуты и `getStaticProps`*
Для страниц, на которых используется динамическая маршрутизация с помощью `getStaticProps`, все локали, которые должны быть предварительно отрендерены, должны возвращаться из `getStaticPaths`. Вместе с объектом `params` возвращается поле `locale`, определяющее локаль для рендеринга:
```
// pages/blog/[slug].js
export const getStaticPaths = ({ locales }) => {
return {
paths: [
// При отсутствии `locale` генерируется только локаль по умолчанию
{ params: { slug: 'post-1' }, locale: 'en-US' },
{ params: { slug: 'post-1' }, locale: 'fr' },
],
fallback: true
}
}
```
Для автоматической статической оптимизации и нединамических страниц с `getStaticProps`, для каждой локали генерируется отдельная версия страницы. Это может существенно повлиять на время сборки в зависимости от количества локалей, определенных в `getStaticProps`.
Для решения этой проблемы следует использовать режим `fallback`. Это позволяет возвращать из `getStaticPaths` только самые популярные пути и локали для предварительного рендеринга во время сборки. Остальные страницы будут рендерится во время выполнения по запросу.
Если из `getStaticProps` нединамической страницы вернуть `notFound: true`, то соответствующий вариант страницы сгенерирован не будет:
```
export async function getStaticProps({ locale }) {
// Получаем посты из внешнего `API`
const res = await fetch(`https://example.com/posts?locale=${locale}`)
const posts = await res.json()
if (posts.length === 0) {
return {
notFound: true
}
}
return {
props: {
posts
}
}
}
```
**Ограничения**
* `locales`: максимум 100 локалей
* `domains`: максимум 100 доменов
### Заголовки безопасности
[Шпаргалка и туториал по заголовкам безопасности](https://github.com/harryheman/React-Total/blob/main/md/security/security.md).
Для улучшения безопасности приложения предназначена настройка `headers` в `next.config.js`. Данная настройка позволяет устанавливать HTTP-заголовки ответов для всех роутов в приложении:
```
// next.config.js
// Список заголовков
const securityHeaders = []
module.exports = {
async headers() {
return [
{
// Данные заголовки будут применяться ко всем роутам в приложении
source: '/(.*)',
headers: securityHeaders
}
]
}
}
```
**Настройки**
*`X-DNS-Prefetch-Control`*
Данный заголовок управляет предварительной загрузкой (prefetching) `DNS`, позволяя браузерам заблаговременно разрешать названия доменов для внешних ссылок, изображений, `CSS`, `JS` и т.д. Предварительная загрузка выполняется в фоновом режиме и уменьшает время реакции на клик пользователя по ссылке:
```
{
key: 'X-DNS-Prefetch-Control',
value: 'on'
}
```
*`Strict-Transport-Security`*
Данный заголовок указывает браузеру использовать `HTTPS` вместо `HTTP`:
```
{
key: 'Strict-Transport-Security',
// 2 года
value: 'max-age=63072000; includeSubDomains; preload'
}
```
*`X-XSS-Protection`*
Данный заголовок предназначен для блокировки межсайтового скриптинга в старых браузерах, не поддерживающих заголовок `Content-Security-Policy`:
```
{
key: 'X-XSS-Protection',
value: '1; mode=block'
}
```
*`X-Frame-Options`*
Данный заголовок определяет, может ли сайт открываться в `iframe`. Он также предназначен для старых браузеров, не поддерживающих настройку `frame-ancestors` заголовка `CSP`:
```
{
key: 'X-Frame-Options',
value: 'SAMEORIGIN'
}
```
*`Permissions-Policy`*
Данный заголовок позволяет определять, какие возможности и `API` могут использоваться в браузере (раньше он назывался `Feature-Policy`):
```
{
key: 'Permissions-Policy',
value: 'camera=(), microphone=(), geolocation=()'
}
```
*`X-Content-Type-Options`*
Данный заголовок запрещает браузеру автоматически определять тип содержимого при отсутствии заголовка `Content-Type`:
```
{
key: 'X-Content-Type-Options',
value: 'nosniff'
}
```
*`Referrer-Policy`*
Данный заголовок управляет тем, какая информация о предыдущем сайте включается в ответ:
```
{
key: 'Referrer-Policy',
value: 'origin-when-cross-origin'
}
```
*`Content-Security-Policy`*
Данный заголовок определяет разрешенные источники для загрузки скриптов, стилей, изображений, шрифтов, медиа и др.:
```
{
key: 'Content-Security-Policy',
value: // Политика `CSP`
}
```
API
---
### Next CLI
`Next CLI` позволяет запускать, собирать и экспортировать приложение.
Команда для получения списка доступных команд:
```
npx next -h
```
Пример передачи аргументов:
```
NODE_OPTIONS='--throw-deprecation' next
NODE_OPTIONS='-r esm' next
NODE_OPTIONS='--inspect' next
```
**Сборка**
Команда `next build` создает оптимизированную производственную сборку приложения. Для каждого роута отображается:
* размер (size) — количество ресурсов, загружаемых при запросе страницы на стороне клиента
* первоначально загружаемый (first load) `JS` — количество ресурсов, загружаемых при получении страницы от сервера
Флаг `--profile` позволяет включить производственный профайлинг:
```
next build --profile
```
Флаг `--verbose` позволяет получить более подробный вывод:
```
next build --verbose
```
**Разработка**
Команда `next dev` запускает приложение в режиме разработки с быстрой перезагрузкой кода, отчетами об ошибках и т.д.
По умолчанию приложение запускается по адресу `http://localhost:3000`. Порт может быть изменен с помощью флага `-p`:
```
npx next dev -p 4000
```
Для этого также можно использовать переменную `PORT`:
```
PORT=4000 npx next dev
```
Дефолтный хост (`0.0.0.0`) можно изменить с помощью флага `-H`:
```
npx next dev -H 192.168.1.2
```
**Продакшн**
Команда `next start` запускает приложение в производственном режиме. Перед этим приложение должно быть скомпилировано с помощью `next build`.
**Линтер**
Команда `next lint` запускает `ESLint` для всех файлов в директориях `pages`, `components` и `lib`. Дополнительные директории для проверки могут быть определены с помощью флага `--dir`:
```
next lint --dir utils
```
### Create Next App
CLI `create-next-app` — это простейший способ создать болванку `Next-проекта`.
```
npx create-next-app [app-name]
# or
yarn create next-app [app-name]
```
Или, если вам требуется поддержка `TypeScript`:
```
npx create-next-app [app-name] --typescript
# or
yarn create next-app [app-name] --ts
```
**Настройки**
* `--ts | --typescript` — инициализация `TS-проекта`
* `-e, --example [example-name][github-url]` — инициализация проекта на основе примера. В `URL` может быть указана любая ветка и/или поддиректория
* `--example-path [path-to-example]`
* `--use-npm`
### `next/router`
**`useRouter`**
Хук `useRouter` позволяет получить доступ к объекту `router` в любом функциональном компоненте:
```
import { useRouter } from 'next/router'
export const ActiveLink = ({ children, href }) => {
const router = useRouter()
const style = {
marginRight: 10,
color: router.asPath === href ? 'green' : 'blue',
}
const handleClick = (e) => {
e.preventDefault()
router.push(href)
}
return (
[{children}]({href})
)
}
```
*Объект `router`*
Объект `router` возвращается `useRouter` и `withRouter` и содержит следующие свойства:
* `pathname: string` — текущий роут, путь страницы из `/pages` без `basePath` или `locale`
* `query: object` — строка запроса, разобранная в объект. По умолчанию имеет значение `{}`
* `asPath: string` — путь (включая строку запроса), отображаемый в браузере, без `basePath` или `locale`
* `isFallback: boolean` — находится ли текущая страница в резервном режиме?
* `basePath: string` — активный базовый путь
* `locale: string` — активная локаль
* `locales: string[]` — поддерживаемые локали
* `defaultLocale: string` — дефолтная локаль
* `domainsLocales: Array<{ domain, defaultLocalem locales }>` — локали для доменов
* `isReady: boolean` — готовы ли поля роутера к использованию? Может использоваться только в `useEffect`
* `isPreview: boolean` — находится ли приложение в режиме предварительного просмотра?
**`router.push`**
Метод `router.push` предназначен для случаев, когда `next/link` оказывается недостаточно.
```
router.push(url, as, options)
```
* `url: string | object` — путь для навигации
* `as: string | object` — опциональный декоратор для адреса страницы при отображении в браузере
* `options` — опциональный объект со следующими свойствами:
+ `scroll: boolean` — выполнять ли прокрутку в верхнюю часть области просмотра при переключении страницы? По умолчанию имеет значение `true`
+ `shallow: boolean` — позволяет обновлять путь текущей страницы без использования `getStaticProps`, `getServerSideProps` или `getInitialProps`. По умолчанию имеет значение `false`
+ `locale: string` — локаль новой страницы
*Использование*
Переключение на страницу `pages/about.js`:
```
import { useRouter } from 'next/router'
export default function Page() {
const router = useRouter()
return (
router.push('/about')}>
О нас
)
}
```
Переключение на страницу `pages/post/[pid].js`:
```
import { useRouter } from 'next/router'
export default function Page() {
const router = useRouter()
return (
router.push('/post/abc')}>
Подробнее
)
}
```
Перенаправление пользователя на страницу `pages/login.js` (может использоваться для реализации защищенных страниц):
```
import { useEffect } from 'react'
import { useRouter } from 'next/router'
// Получаем данные пользователя
const useUser = () => ({ user: null, loading: false })
export default function Page() {
const { user, loading } = useUser()
const router = useRouter()
useEffect(() => {
if (!loading && !user) {
router.push('/login')
}
}, [user, loading])
return user ? Привет, {user.name}!
: Загрузка...
}
```
Пример использования объекта вместо строки:
```
import { useRouter } from 'next/router'
export default function ReadMore({ post }) {
const router = useRouter()
return (
{
router.push({
pathname: '/post/[pid]',
query: { pid: post.id }
})
}}
>
Подробнее
)
}
```
**`router.replace`**
Метод `router.replace` обновляет путь текущей страницы без добавления `URL` в стек `history`.
```
router.replace(url, as, options)
```
*Использование*
```
import { useRouter } from 'next/router'
export default function Page() {
const router = useRouter()
return (
router.replace('/home')}>
Главная
)
}
```
**`router.prefetch`**
Метод `router.prefetch` позволяет выполнять предварительную загрузку страниц для ускорения навигации. *Обратите внимание*: `next/link` выполняет предварительную загрузку страниц автоматически.
```
router.prefetch(url, as)
```
*Использование*
Предположим, что после авторизации мы перенаправляем пользователя на страницу профиля. Для ускорения навигации мы можем предварительно загрузить страницу профиля:
```
import { useCallback, useEffect } from 'react'
import { useRouter } from 'next/router'
export default function Login() {
const router = useRouter()
const handleSubmit = useCallback((e) => {
e.preventDefault()
fetch('/api/login', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
/* Данные пользователя */
}),
}).then((res) => {
// Выполняем перенаправление на предварительно загруженную страницу профиля
if (res.ok) router.push('/dashboard')
})
}, [])
useEffect(() => {
// Предварительно загружаем страницу профиля
router.prefetch('/dashboard')
}, [])
return (
{/\* Поля формы \*/}
Войти
)
}
```
**`router.beforePopState`**
Метод `router.beforePopState` позволяет реагировать на событие `popstate` перед обработкой пути роутером.
```
router.beforePopState(cb)
```
`cb` — это функция, которая запускается при возникновении события `popstate`. Данная функция получает объект события со следующими свойствами:
* `url: string` — путь для нового состояния (как правило, название страницы)
* `as: string` — `URL`, который будет отображен в браузере
* `options: object` — дополнительные настройки из `router.push`
*Использование*
`beforePopState` может использоваться для модификации запроса или принудительного обновления `SSR`, как в следующем примере:
```
import { useEffect } from 'react'
import { useRouter } from 'next/router'
export default function Page() {
const router = useRouter()
useEffect(() => {
router.beforePopState(({ url, as, options }) => {
// Разрешены только указанные пути
if (as !== '/' && as !== '/other') {
// Заставляем `SSR` рендерить страницу 404
window.location.href = as
return false
}
return true
})
}, [])
return Добро пожаловать!
}
```
**`router.back`**
Данный метод позволяет вернуться к предыдущей странице. При его использовании выполняется `window.history.back()`:
```
import { useRouter } from 'next/router'
export default function Page() {
const router = useRouter()
return (
router.back()}>
Назад
)
}
```
**`router.reload`**
Данный метод перезагружает текущий `URL`. При его использовании выполняется `window.location.reload()`:
```
import { useRouter } from 'next/router'
export default function Page() {
const router = useRouter()
return (
router.reload()}>
Обновить
)
}
```
**`router.events`**
Использование роутера приводит к возникновению следующих событий:
* `routeChangeStart(url, { shallow })` — возникает в начале обновления роута
* `routeChangeComplete(url, { shallow })` — возникает в конце обновления роута
* `routeChangeError(err, url, { shallow })` — возникает при провале или отмене обновления роута
* `beforeHistoryChange(url, { shallow })` — возникает перед изменением истории браузера
* `hashChangeStart(url, { shallow })` — возникает в начале изменения хеш-части `URL` (но не самого `URL`)
* `hashChangeComplete(url, { shallow })` — возникает в конце изменения хеш-части `URL` (но не самого `URL`)
*Обратите внимание*: здесь `url` — это адрес страницы, отображаемый в браузере, включая `basePath`.
*Использование*
```
// pages/_app.js
import { useEffect } from 'react'
import { useRouter } from 'next/router'
export default function MyApp({ Component, pageProps }) {
const router = useRouter()
useEffect(() => {
const handleRouteChange = (url, { shallow }) => {
console.log(
`Выполняется переключение на страницу ${url} ${
shallow ? 'с' : 'без'
} поверхностной маршрутизации`
)
}
router.events.on('routeChangeStart', handleRouteChange)
// При размонтировании компонента
// отписываемся от события с помощью метода `off`
return () => {
router.events.off('routeChangeStart', handleRouteChange)
}
}, [])
return
}
```
**`withRouter`**
Вместо `useRouter` может использоваться `withRouter`:
```
import { withRouter } from 'next/router'
function Page({ router }) {
return {router.pathname}
}
export default withRouter(Page)
```
**`TypeScript`**
```
import React from 'react'
import { withRouter, NextRouter } from 'next/router'
interface WithRouterProps {
router: NextRouter
}
interface MyComponentProps extends WithRouterProps {}
class MyComponent extends React.Component {
render() {
return {this.props.router.pathname}
}
}
export default withRouter(MyComponent)
```
### `next/link`
Компонент `Link`, экспортируемый из `next/link`, позволяет переключаться между страницами на стороне клиента.
Предположим, что в директории `pages` содержатся следующие файлы:
* `pages/index.js`
* `pages/about.js`
* `pages/blog/[slug].js`
Пример навигации по этим страницам:
```
import Link from 'next/link'
export default function Home() {
return (
* Главная
* О нас
* Пост
)
}
```
`Link` принимает следующие пропы:
* `href` — путь или `URL` для навигации. Единственный обязательный проп
* `as` — опциональный декоратор пути, отображаемый в адресной строке браузера
* `passHref` — указывает `Link` передать проп `href` дочернему компоненту. По умолчанию имеет значение `false`
* `prefetch` — предварительная загрузка страницы в фоновом режиме. По умолчанию — `true`. Предварительная загрузка страницы выполняется для любого `Link`, находящегося в области просмотра (изначально или при прокрутке). Предварительная загрузка может быть отключена с помощью `prefetch={false}`. Однако даже в этом случае предварительная загрузка выполняется при наведении курсора на ссылку. Для страниц со статической генерацией загружается JSON-файл для более быстрого переключения страницы. Предварительная загрузка выполняется только в производственном режиме
* `replace` — заменяет текущее состояние истории вместо добавления нового `URL` в стек. По умолчанию — `false`
* `scroll` — выполнение прокрутки в верхнюю часть области просмотра. По умолчанию — `true`
* `shallow` — обновление пути текущей страницы без перезапуска `getStaticProps`, `getServerSideProps` или `getInitialProps`. По умолчанию — `false`
* `locale` — по умолчанию к пути добавляется активная локаль. `locale` позволяет определить другую локаль. Когда имеет значение `false`, проп `href` должен включать локаль
**Роут с динамическими сегментами**
Пример динамического роута для `pages/blog/[slug].js`:
```
import Link from 'next/link'
export default function Posts({ posts }) {
return (
{posts.map((post) => (
* {post.title}
))}
)
}
```
**Кастомный компонент — обертка для тега `a`**
Если дочерним компонентом `Link` является кастомный компонент, оборачивающий `a`, `Link` должен иметь проп `passHref`. Это необходимо при использовании таких библиотек как `styled-components`. Без этого тег `a` не получит атрибут `href`, что негативно скажется на доступности и `SEO`.
```
import Link from 'next/link'
import styled from 'styled-components'
// Создаем кастомный компонент, оборачивающий `a`
const RedLink = styled.a`
color: red;
`
export default function NavLink({ href, name }) {
// Добавляем `passHref`
return (
{name}
)
}
```
**Функциональный компонент**
Если дочерним компонентом `Link` является функция, то кроме `passHref`, необходимо обернуть ее в `React.forwardRef`:
```
import Link from 'next/link'
import { forwardRef } from 'react'
// `onClick`, `href` и `ref` должны быть переданы DOM-элементу
const MyButton = forwardRef(({ onClick, href }, ref) => {
return (
[Кликни]({href})
)
})
export default function Home() {
return (
)
}
```
**Объект `URL`**
`Link` также принимает объект `URL`. Данный объект автоматически преобразуется в строку:
```
import Link from 'next/link'
export default function Home() {
return (
* О нас
* Пост
)
}
```
В приведенном примере у нас имеются ссылки на:
* предопределенный роут: `/about?name=test`
* динамический роут: `/blog/my-post`
**Замена `URL`**
```
О нас
```
**Отключение прокрутки**
```
Загрузить еще
```
### `next/image`
**Обязательные пропы**
Компонент `Image` принимает следующие обязательные пропы:
* `src` — статически импортированный файл или строка, которая может быть абсолютной ссылкой или относительным путем в зависимости от пропа `loader` или настроек загрузки. При использовании ссылок на внешние ресурсы, эти ресурсы должны быть указаны в разделе `domains` файла `next.config.js`
* `width` — ширина изображения в пикселях: целое число без единицы измерения
* `height` — высота изображения в пикселях: целое число без единицы измерения
**Опциональные пропы**
* `layout` — `intrinsic | fixed | responsive | fill`. Значением по умолчанию является `intrinsic`
* `loader` — кастомная функция для разрешения `URL`. Установка этого пропа перезаписывает настройки из раздела `images` в `next.config.js`. `loader` принимает параметры `src`, `width` и `quality`
```
import Image from 'next/image'
const myLoader = ({ src, width, quality }) => `https://example.com/${src}?w=${width}&q=${quality || 75}`
const MyImage = (props) => (
)
```
* `sizes` — строка, содержащая информацию о ширине изображения на различных контрольных точках. По умолчанию имеет значение `100vw` при использовании `layout="responsive"` или `layout="fill"`
* `quality` — качество оптимизированного изображения: целое число от `1` до `100`, где `100` — лучшее качество. Значением по умолчанию является `75`
* `priority` — если `true`, изображение будет считаться приоритетным и загружаться предварительно. Ленивая загрузка для такого изображения будет отключена
* `placeholder` — заменитель изображения. Возможными значениями являются `blur` и `empty`. Значением по умолчанию является `empty`. Когда значением является `blur`, в качестве заменителя используется значение пропа `blurDataURL`. Если значением `src` является объект из статического импорта и импортированное изображение имеет формат `JPG`, `PNG`, `WebP` или `AVIF`, `blurDataURL` заполняется автоматически
**Пропы для продвинутого использования**
* `objectFit` — определяет, как изображение заполняет родительский контейнер при использовании `layout="fill"`
* `objectPosition` — определяет, как изображение позиционируется внутри родительского контейнера при использовании `layout="fill"`
* `onLoadingComplete` — функция, которая вызывается после полной загрузки изображения и удаления заменителя
* `lazyBoundary` — строка, определяющая ограничительную рамку для определения пересечения области просмотра с изображением для запуска его ленивой загрузки. По умолчанию имеет значение `200px`
* `unoptimized` — если `true`, источник изображения будет использоваться как есть, без изменения качества, размера или формата. Значением по умолчанию является `false`
**Другие пропы**
Любые другие пропы компонента `Image` передаются дочернему элементу `img`, кроме следующих:
* `style` — для стилизации изображения следует использовать `className`
* `srcSet` — следует использовать размеры устройства
* `ref` — следует использовать `onLoadingComplete`
* `decoding` — всегда `async`
**Настройки**
Настройки для обработки изображений определяются в файле `next.config.js`.
*Домены*
Настройка доменов для провайдеров изображений позволяет защитить приложение от атак, связанных с внедрением в изображение вредоносного кода.
```
module.exports = {
images: {
domains: ['assets.acme.com']
}
}
```
*Размеры устройств*
Настройка `deviceSizes` позволяет определить список контрольных точек для ширины устройств потенциальных пользователей. Эти контрольные точки предназначены для предоставления подходящего изображения при использовании `layout="responsive"` или `layout="fill"`.
```
// настройки по умолчанию
module.exports = {
images: {
deviceSizes: [640, 750, 828, 1080, 1200, 1920, 2048, 3840]
}
}
```
*Размеры изображений*
Настройка `imageSizes` позволяет определить размеры изображений в виде списка. Этот список объединяется с массивом размеров устройств для формирования полного перечня размеров для генерации набора источников (srcset) изображения.
```
module.exports = {
images: {
imageSizes: [16, 32, 48, 64, 96, 128, 256, 384]
}
}
```
### `next/head`
Компонент `Head` позволяет добавлять элементы в `head` страницы:
```
import Head from 'next/head'
export default function IndexPage() {
return (
Заголовок страницы
Привет, народ!
)
}
```
Проп `key` позволяет дедуплицировать теги:
```
import Head from 'next/head'
export default function IndexPage() {
return (
Заголовок страницы
Привет, народ!
)
}
```
В данном случае будет отрендерен только .
Контент `head` удаляется при размонтировании компонента.
`title`, `meta` и другие элементы должны быть прямыми потомками `Head`. Они могут быть обернуты в один или рендериться из массива.
### `next/server`
Посредники создаются с помощью функции `middleware`, находящейся в файле `_middleware`. Интерфейс посредников основан на нативных объектах `FetchEvent`, `Response` и `Request`.
Эти нативные объекты расширены для предоставления большего контроля над формированием ответов на основе входящих запросов.
Сигнатура функции:
```
import type { NextRequest, NextFetchEvent } from 'next/server'
export type Middleware = (
request: NextRequest,
event: NextFetchEvent
) => Promise | Response | undefined
```
Функция не обязательно должна называться `middleware`. Это всего лишь соглашение. Функция также не обязательно должна быть асинхронной.
**`NextRequest`**
Объект `NextRequest` расширяет нативный интерфейс `Request` следующими методами и свойствами:
* `cookies` — куки запроса
* `nextUrl` — расширенный, разобранный объект `URL`, предоставляющий доступ к таким свойствам, как `pathname`, `basePath`, `trailingSlash` и `i18n`
* `geo` — геоинформация о запросе
+ `country` — код страны
+ `region` — код региона
+ `city` — город
+ `latitude` — долгота
+ `longitude` — широта
* `ip` — IP-адрес запроса
* `ua` — агент пользователя
`NextRequest` может использоваться вместо `Request`.
```
import type { NextRequest } from 'next/server'
```
**`NextFetchEvent`**
`NextFetchEvent` расширяет объект `FetchEvent` методом `waitUntil`.
Данный метод позволяет продолжить выполнение функции после отправки ответа.
Например, `waitUntil` может использоваться для интеграции с такими системами мониторинга ошибок, как `Sentry`.
```
import type { NextFetchEvent } from 'next/server'
```
**`NextResponse`**
`NextResponse` расширяет `Response` следующими методами и свойствами:
* `cookies` — куки ответа
* `redirect()` — возвращает `NextResponse` с набором перенаправлений (redirects)
* `rewrite()` — возвращает `NextResponse` с набором перезаписей (rewrites)
* `next()` — возвращает `NextResponse`, который является частью цепочки посредников
```
import { NextResponse } from 'next/server'
```
`next.config.js`
----------------
Файл `next.config.js` или `next.config.mjs` предназначен для кастомной продвинутой настройки `Next.js`.
Пример `next.config.js`:
```
/**
* @type {import('next').NextConfig}
*/
const nextConfig = {
/* настройки */
}
module.exports = nextConfig
```
Пример `next.config.mjs`:
```
/**
* @type {import('next').NextConfig}
*/
const nextConfig = {
/* настройки */
}
export default nextConfig
```
Можно использовать функцию:
```
module.exports = (phase, { defaultConfig }) => {
/**
* @type {import('next').NextConfig}
*/
const nextConfig = {
/* настройки */
}
return nextConfig
}
```
`phase` — это текущий контекст, для которого загружаются настройки. Доступными фазами являются:
* `PHASE_EXPORT`
* `PHASE_PRODUCTION_BUILD`
* `PHASE_PRODUCTION_SERVER`
* `PHASE_DEVELOPMENT_SERVER`
Фазы импортируются из `next/constants`:
```
const { PHASE_DEVELOPMENT_SERVER } = require('next/constants')
module.exports = (phase, { defaultConfig }) => {
if (phase === PHASE_DEVELOPMENT_SERVER) {
return {
/* настройки для разработки */
}
}
return {
/* другие настройки */
}
}
```
**Переменные среды окружения**
*Пример*
```
module.exports = {
env: {
someKey: 'some-value'
}
}
```
*Использование*
```
export default function Page() {
return Значением `someKey` является `{process.env.someKey}`
====================================================
}
```
*Результат*
```
export default function Page() {
return Значением `someKey` является `some-value`
=========================================
}
```
**Заголовки**
Настройка `headers` позволяет устанавливать кастомные HTTP-заголовки для входящих запросов:
```
module.exports = {
async headers() {
return [
{
source: '/about',
headers: [
{
key: 'x-custom-header',
value: 'кастомное значение заголовка',
},
{
key: 'x-another-custom-header',
value: 'еще одно кастомное значение заголовка'
}
]
}
]
}
}
```
`headers` — асинхронная функция, возвращающая массив объектов со свойствами `source` и `headers`:
* `source` — адрес входящего запроса
* `headers` — массив объектов со свойствами `key` и `value`
Дополнительные параметры:
* `basePath: false | undefined` — если `false`, `basePath` не будет учитываться при совпадении, может использоваться только для внешних перезаписей
* `locale: false | undefined` — определяет, должна ли при совпадении включаться локаль
* `has` — массив объектов со свойствами `type`, `key` и `value`
Если в настройках определены два кастомных заголовка с одинаковыми ключами, будет учитываться только значение последнего заголовка.
*Поиск совпадения путей*
Разрешен поиск совпадения путей. Например, путь `/blog/:slug` будет совпадать с `/blog/hello-world` (без вложенных путей):
```
module.exports = {
async headers() {
return [
{
source: '/blog/:slug',
headers: [
{
key: 'x-slug',
value: ':slug', // Совпавшие параметры могут использоваться в качестве значений
},
{
key: 'x-slug-:slug', // Совпавшие параметры могут использоваться в качестве ключей
value: 'кастомное значение заголовка'
}
]
}
]
}
}
```
*Поиск всех совпадений путей*
Для поиска всех совпадений можно использовать `*` после параметра, например, `/blog/:slug*` будет совпадать с `/blog/a/b/c/d/hello-world`:
```
module.exports = {
async headers() {
return [
{
source: '/blog/:slug*',
headers: [
{
key: 'x-slug',
value: ':slug*',
},
{
key: 'x-slug-:slug*',
value: 'кастомное значение заголовка'
}
]
}
]
}
}
```
*Поиск совпадений путей с помощью регулярных выражений*
Для поиска совпадений с помощью регулярок используются круглые скобки после параметра, например, `/blog/:slug(\\d{1,})` будет совпадать с `/blog/123`, но не с `/blog/abc`:
```
module.exports = {
async headers() {
return [
{
source: '/blog/:post(\\d{1,})',
headers: [
{
key: 'x-post',
value: ':post'
}
]
}
]
}
}
```
Символы `( ) { } : * + ?` считаются частью регулярного выражения, поэтому при использовании в `source` в качестве обычных символов они должны быть экранированы с помощью `\\`:
```
module.exports = {
async headers() {
return [
{
// Это будет совпадать с `/english(default)/something`
source: '/english\\(default\\)/:slug',
headers: [
{
key: 'x-header',
value: 'some-value'
}
]
}
]
}
}
```
*Поиск совпадения на основе заголовка, куки и строки запроса*
Для этого используется поле `has`. Заголовок будет установлен только при совпадении полей `source` и `has`.
Значением `has` является массив объектов со следующими свойствами:
* `type: string` — `header | cookie | host | query`
* `key: string` — ключ для поиска совпадения
* `value: string | undefined` — значение для проверки. Если `undefined`, любое значение будет совпадать. Для захвата определенной части значения может использоваться регулярное выражение. Например, если для `hello-world` используется значение `hello-(?.*)`, `world` можно использовать в качестве значения `destination` как `:param`:
```
module.exports = {
async headers() {
return [
// Если имеется заголовок `x-add-header`,
// будет установлен заголовок `x-another-header`
{
source: '/:path*',
has: [
{
type: 'header',
key: 'x-add-header',
},
],
headers: [
{
key: 'x-another-header',
value: 'hello'
}
]
},
// Если совпадают `source`, `query` и `cookie`,
// будет установлен заголовок `x-authorized`
{
source: '/specific/:path*',
has: [
{
type: 'query',
key: 'page',
// Значение `page` будет недоступно в заголовке,
// поскольку значение указано и при этом
// не используются именованная группа захвата, например `(?home)`
value: 'home',
},
{
type: 'cookie',
key: 'authorized',
value: 'true',
},
],
headers: [
{
key: 'x-authorized',
value: ':authorized'
}
]
},
// Если имеется заголовок `x-authorized` и он
// содержит искомое значение, будет установлен заголовок `x-another-header`
{
source: '/:path\*',
has: [
{
type: 'header',
key: 'x-authorized',
value: '(?yes|true)',
},
],
headers: [
{
key: 'x-another-header',
value: ':authorized'
}
]
},
// Если значением хоста является `example.com`,
// будет установлен данный заголовок
{
source: '/:path\*',
has: [
{
type: 'host',
value: 'example.com',
},
],
headers: [
{
key: 'x-another-header',
value: ':authorized'
}
]
}
]
}
}
```
*`basePath` и `i18n`*
При наличии `basePath`, его значение автоматически добавляется к значению `source`, если не определено `basePath: false`:
```
module.exports = {
basePath: '/docs',
async headers() {
return [
{
source: '/with-basePath', // становится /docs/with-basePath
headers: [
{
key: 'x-hello',
value: 'world'
}
]
},
{
source: '/without-basePath', // не модифицируется
headers: [
{
key: 'x-hello',
value: 'world'
}
],
basePath: false
}
]
}
}
```
При наличии `i18n` к значению `source` автоматически добавляются значения `locales`, если не определено `locale: false` — в этом случае значение `source` должно включать префикс локали:
```
module.exports = {
i18n: {
locales: ['en', 'fr', 'de'],
defaultLocale: 'en',
},
async headers() {
return [
{
source: '/with-locale', // автоматическая обработка всех локалей
headers: [
{
key: 'x-hello',
value: 'world'
}
]
},
{
// ручная установка локали
source: '/nl/with-locale-manual',
locale: false,
headers: [
{
key: 'x-hello',
value: 'world'
}
]
},
{
// это совпадает с `/`, поскольку `en` является `defaultLocale`
source: '/en',
locale: false,
headers: [
{
key: 'x-hello',
value: 'world'
}
]
},
{
// это преобразуется в /(en|fr|de)/(.*), поэтому не будет совпадать с роутами верхнего уровня, такими как
// `/` или `/fr`, а с `/:path*` будет
source: '/(.*)',
headers: [
{
key: 'x-hello',
value: 'worlld'
}
]
}
]
}
}
```
**Дополнительная настройка `Webpack`**
Перед кастомизацией Вебпака убедитесь, что `Next.js` не имеет поддержки необходимого функционала.
Пример определения функции для настройки `webpack`:
```
module.exports = {
webpack: (config, { buildId, dev, isServer, defaultLoaders, webpack }) => {
// не забудьте вернуть модифицированный конфиг
return config
}
}
```
Данная функция выполняется дважды: один раз для сервера и еще один для клиента. Это позволяет разделять настройки с помощью свойства `isServer`.
Вторым аргументом, передаваемым функции является объект со следующими свойствами:
* `buildId: string` — уникальный идентификатор сборки
* `dev: boolean` — индикатор компиляции в режиме разработки
* `isServer: boolean` — если `true`, значит, выполняется компиляция для сервера
* `defaultLocales: object` — дефолтные лоадеры:
+ `babel: object` — дефолтные настройки `babel-loader`
Пример использования `defaultLoaders.babel`:
```
module.exports = {
webpack: (config, options) => {
config.module.rules.push({
test: /\.mdx/,
use: [
options.defaultLoaders.babel,
{
loader: '@mdx-js/loader',
options: pluginOptions.options
}
]
})
return config
}
}
```
Настройка `distDir` позволяет определять директорию для сборки:
```
module.exports = {
distDir: 'build'
}
```
Настройка `generateBuildId` позволяет определять идентификатор сборки:
```
module.exports = {
generateBuildId: async () => {
// Здесь можно использовать, например, хеш последнего гит-коммита
return 'my-build-id'
}
}
```
Пример отключения проверки кода с помощью `eslint` при сборке проекта:
```
module.exports = {
eslint: {
ignoreDuringBuilds: true
}
}
```
Пример отключения `typescript` при сборке проекта:
```
module.exports = {
typescript: {
ignoreBuildErrors: true
}
}
```
Пожалуй, на сегодня это все.
Благодарю за внимание и хорошего дня!
---
[](https://cloud.timeweb.com/?utm_source=habr&utm_medium=banner&utm_campaign=cloud&utm_content=direct&utm_term=low) | https://habr.com/ru/post/590157/ | null | ru | null |
# Безопасная работа с секретами при сборке в Docker Compose
***Перевод статьи подготовлен в преддверии старта курса [«Web-разработчик на Python»](https://otus.pw/CXIC/).***
---
Когда вы собираете Docker-образ вам могут понадобиться секреты, например, пароль к приватному репозиторию пакетов. Вы не хотите, чтобы этот секрет в конечном итоге оказался в образе, потому что тогда любой, кто получит доступ к образу, получит доступ и к вашу приватному репозиторию.
> *Примечание*: Если вы думаете «Почему бы просто не использовать переменные среды?», которые используются для секретов в рантайме при создании образа. Эта статья посвящена секретам сборки, которые используются при создании образа с помощью Docker-файла.
Более новые версии Docker поддерживают секреты с помощью экспериментального сервиса [BuildKit](https://docs.docker.com/develop/develop-images/build_enhancements/), а в Docker Compose 1.25 и более поздних версиях уже можно создавать образы с помощью BuildKit. К сожалению, по состоянию на март 2020 года, возможность безопасной работы с секретами из Compose все еще находится в [процессе разработки](https://github.com/docker/compose/issues/6358).
*Так что же теперь делать?*
В сегодняшней статье я покажу, как можно использовать один и тот же Dockerfile для безопасного создания образов с секретами, но при этом не упускать преимущества быстрой разработки с помощью Docker Compose.
### Два варианта использования вашего Dockerfile
Очень удобно использовать один и тот же Dockerfile для продакшена и для локальной разработки с Docker Compose. Обычно вы используете Dockerfile вместе с функцией сборки из Compose:
```
version: "3.7"
services:
yourapp:
build:
context: "."
```
Затем вы можете сделать:
```
$ docker-compose up
```
С помощью этой команды вы можете (пере)собрать образ, а затем запустить его.
Для использования на продакшене, вы собираете образ и отправляете его с *push*:
```
$ docker build -t myimage .
$ docker push myimage
```
И пока все идет хорошо. Но что делать, если вам нужна сборка с секретом?
#### Первая попытка (небезопасная)
Допустим, у вас есть скрипт, которому нужна сборка с секретом, например, чтобы загрузить пакет Python из частного репозитория [DevPI](https://doc.devpi.net/). Для простоты, мы будем просто выводить секрет с помощью `use-secret.sh`, чтобы показать, что он у нас есть.
```
#!/bin/bash
set -euo pipefail
echo "Secret is: $THEPASSWORD"
```
Можно простодушно передать секрет с помощью аргументов сборки Docker, поскольку они поддерживаются везде, в том числе и в Docker Compose.
> *Примечание*: Выходя за пределы нашей дискуссии, хочу сказать, что использование Docker-файлов в этой статье – не лучшая практика, однако излишняя сложность может помешать донести основной смысл статьи.
Поэтому, если вы захотите запустить свое приложение на Python на продакшене с Docker, вот два хороших способа это сделать:
* Если вам нужен DIY: [подробный список с примерами и ссылками](https://pythonspeed.com/products/productionchecklist/)
* Если вам нужна рабочая версия как можно быстрее: шаблон, в котором учтены [лучшие практики](https://pythonspeed.com/products/pythoncontainer/)
```
FROM python:3.8-slim-buster
# Using ARG for build secrets is INSECURE!
ARG THEPASSWORD
COPY use_secret.sh .
RUN ./use_secret.sh
```
Мы можем написать `docker-compose.yml`, который будет передан в секрете:
```
version: "3.7"
services:
yourapp:
build:
context: "."
args:
THEPASSWORD: "s3kr!t"
```
Для локальной работы можно запустить или собрать образ с помощью Compose:
```
$ docker-compose build | grep Secret
Secret is: s3kr!t
```
И все хорошо.
А еще мы можем собрать образ с помощью Docker, в качестве подготовки к перемещению его в реестр образов:
```
$ docker build -t myimage --build-arg THEPASSWORD=s3krit . | grep Secret
Secret is: s3krit
```
**Так делать небезопасно: никогда так не делайте**. Если мы решим просмотреть слои образа, то увидим секрет, лежащий в нем!
```
$ docker history myimage
IMAGE CREATED CREATED BY SIZE
c224231ec30b 47 seconds ago |1 THEPASSWORD=s3krit /bin/sh -c ./use_secre… 0B
6aef62acf0db 48 seconds ago /bin/sh -c #(nop) COPY file:7aa28bbe6595e0d5… 62B
f88b19ca8e65 About a minute ago /bin/sh -c #(nop) ARG THEPASSWORD 0B
...
```
Любой, кто получит доступ к этому образу, узнает ваш пароль. Что в таком случае можно сделать?
#### Секреты BuildKit (частичное решение проблемы)
BuildKit – это новое (и все еще экспериментальное) решение для создания Docker-образов, которое помимо всего прочего добавляет поддержку безопасного использования секретов [при сборке](https://docs.docker.com/develop/develop-images/build_enhancements/). В Docker Compose есть поддержка BuildKit с v1.25.
Но есть одна проблема: Docker Compose до сих пор не поддерживает функционал секретов BuildKit. Сейчас [ведется работа](https://github.com/docker/compose/pull/7046) над этим, однако по состоянию на март 2020 года, готовых решений нет, не говоря уже о стабильном релизе.
Поэтому мы собираемся объединить два этих подхода:
* Docker Compose продолжит пользоваться аргументами при сборке, чтобы передавать секреты;
* Для образа на продакшене, собранного с помощью docker build, мы используем BuildKit для передачи секретов.
Так мы сможем использовать один и тот же Dockerfile для работы локально и на продакшене.
BuildKit работает с секретами следующим образом: файл с секретами монтируется во временную директорию, пока выполняется команда RUN, например, в `/var/secrets/thepassword`. Поскольку он монтируется в течение выполнения команды RUN, он не будет добавлен в конечный образ.
Мы изменим файл `use_secret.sh`, чтобы он проверял, существует ли такой временный файл. Если существует, он использует его установки переменной среды `$THEPASSWORD`. Если файла не существует, то мы вернемся к переменной среды. То есть `$THEPASSWORD` может быть установлена с помощью BuildKit или аргументов сборки:
```
#!/bin/bash
set -euo pipefail
if [ -f /run/secrets/thepassword ]; then
export THEPASSWORD=$(cat /run/secrets/thepassword)
fi
echo "Secret is: $THEPASSWORD"
```
Затем мы изменим Dockerfile, чтобы добавить BuildKit и смонтировать секрет:
```
# syntax = docker/dockerfile:1.0-experimental
FROM python:3.8-slim-buster
# Only use the build arg for local development:
ARG THEPASSWORD
COPY use_secret.sh .
# Mount the secret to /run/secrets:
RUN --mount=type=secret,id=thepassword ./use_secret.sh
```
Файл `docker-compose.yml` мы не меняем:
```
version: "3.7"
services:
yourapp:
build:
context: "."
args:
THEPASSWORD: "s3kr!t"
```
Теперь нужно определить две переменные среды, одна из которых будет говорить Docker, что нужно использовать BuildKit, вторая, что Compose нужно использовать CLI-версию Docker и, следовательно, BuildKit. Также мы запишем секрет в файл:
```
$ export DOCKER_BUILDKIT=1
$ export COMPOSE_DOCKER_CLI_BUILD=1
$ echo 's3krit' > /tmp/mypassword
```
С Compose используем аргументы для сборки:
```
$ docker-compose build --progress=plain \
--no-cache 2>&1 | grep Secret
#12 0.347 Secret is: s3kr!t
```
Обратите внимание, что `--no-cache` нужен, чтобы понять, что образ действительно пересоберется, если вы сами запустите все вышеприведенное. В реальной жизни этот параметр можно опустить. `2>&1` перенаправит `stderr` на `stdout` для корректной работы `grep`.
Когда мы будем готовы к сборке на продакшен, мы используем docker build с функционалом секретов из BuildKit:
```
$ docker build --no-cache -t myimage \
--secret id=thepassword,src=/tmp/mypassword \
--progress=plain . 2>&1 | grep Secret
#12 0.359 Secret is: s3krit
```
### Безопасно ли это?
Давайте убедимся, что секрет не виден:
```
$ docker history myimage
IMAGE CREATED CREATED BY SIZE
a77f3c32b723 25 seconds ago RUN |1 THEPASSWORD= /bin/sh -c ./use_secret.… 0B
25 seconds ago COPY use\_secret.sh . # buildkit 160B
...
```
Ура! Мы передали секрет в один и тот же Dockerfile, используя Compose и `docker build`, и в последнем случае не раскрыли секрет из сборки.
---
[Узнать подробнее о курсе.](https://otus.pw/CXIC/)
--- | https://habr.com/ru/post/501580/ | null | ru | null |
# Отправка уведомлений о пропущенных звонках из Asterisk
В данном посте я расскажу вам о возможностях отправки уведомлений о пропущенных звонках с помощью Asterisk. Я постараюсь привести простые примеры конфигурации и подробнее раскрыть данную тему, далее вы можете экспериментировать по своему усмотрению или потребностям. Asterisk предлагает довольно широкие возможности для решения различных задач, поэтому одну и ту же задачу можно решать по разному, главное результат — стабильная работа ваших сервисов.
#### Отправка отчета о пропущенном звонке на email
**Что имеем:**
Входящая многоканальная линия с номером +7 (495) 1234567, IVR, 4 оператора в очереди вызова.
**Задачи:**
1. Отправлять отчет о пропущенном звонке, с указанием номера звонящего, времени поступления звонка и времени ожидания на линии.
2. Если абонент ждал на линии более 10 секунд и по какой-либо причине положил трубку, не дождавшись ответа оператора — отправляем отчет о пропущенном звонке.
3. Заносить в БД (в текущем примере MySQL) данные о том, какой оператор в очереди ответил звонок и фиксируем время в которое разговор был завершен.
В качестве решения приведу пример конфигурации (один из возможных вариантов решения), с комментариями на самых интересных по-моему мнению моментах.
Вот так выглядит конфигурация IVR рабочего времени + очереди вызова:
```
[globals]
CIDFILE=/etc/asterisk/inc-calls/call-noanswer
SQLHOST=db.domain.ru
SQLUSER=asterisksql
SQLPASS=Gt6Rju8FkS
SQLDB=asteriskdb
IVRWORK=custom/IVR_company_wav
[incoming-74951234567]
exten => h,1,Set(WAITTIME=10)
exten => h,n,Set(CTALL=$[${CDR(duration)}])
exten => h,n,Set(CTANSWER=$[${CDR(billsec)}])
exten => h,n,Set(CTDTIME=$[${CTALL}-${CTANSWER}])
exten => h,n,NoOP(${CDR(disposition)})
exten => h,n,NoOP(${CTDTIME})
exten => h,n,GotoIf($["${CDR(disposition)}" = "NO ANSWER"]?timecheck:n1)
exten => h,n(n1),GotoIf($["${CDR(disposition)}" = "BUSY"]?timecheck:n2)
exten => h,n(n2),GotoIf($["${CDR(disposition)}" = "FAILED"]?timecheck:n3)
exten => h,n(n3),GotoIf($["${CDR(disposition)}" = "ANSWERED"]?n4:misscall)
exten => h,n(n4),MYSQL(Connect connid ${SQLHOST} ${SQLUSER} ${SQLPASS} ${SQLDB})
exten => h,n,MYSQL(Query resultid ${connid} UPDATE office_calls SET active=0 WHERE asterisk_id='${QID}')
exten => h,n,MYSQL(Clear ${resultid})
exten => h,n,MYSQL(Disconnect ${connid})
exten => h,n(hang),Hangup()
exten => h,n(timecheck),GotoIf($[${CTDTIME} > ${WAITTIME}]?misscall:hang)
exten => h,n(misscall),Goto(noanswer,s,1)
exten => s,1,NoOp(${CALLERID(num)})
exten => s,n,Set(CALLID=74951234567)
exten => s,n,Set(CALLER=${CALLERID(num)})
exten => s,n,Set(__QID=${CDR(uniqueid)})
exten => s,n(begin),GotoIfTime(10:00-22:00,mon-sat,*,*?workdays:outofoffice)
exten => s,n(workdays),NoOp(Incoming CALL from ${CALLERID(num)} to ${EXTEN})
exten => s,n,Answer()
exten => s,n,ResetCDR(w)
exten => s,n,Wait(1)
exten => s,n,Background(${IVRWORK})
exten => s,n,Queue(operators,t,,,300,,startflag1)
exten => s,n,NoOp(${DIALSTATUS})
exten => s,n,Goto(noanswer,s,1)
exten => s,n,Hangup()
```
Обратите внимание, что если работает IVR и требуется узнать точное время ожидания абонента на линии (в обратном случае, у вас посчитается и время, которое абонет слушал голосовое меню), то нужно после Answer() добавить ResetCDR(w). Еще один интересный момент — запись в БД нам нужно заносить как только оператор в очереди ответит на звонок — тут нам поможет макрос startflag1, который будет выполнен, как только любой оператор в очереди ответит на звонок.
Тут все довольно просто, если на вызов не ответили, переходим в контекст noanswer, который выглядит следующим образом:
```
[noanswer]
exten => s,1,NoOp(UID CALL: ${UNIQUEID} / DATE: ${STRFTIME(${EPOCH},,%Y%m%d-%H%M%S)}))
exten => s,n,Set(RANDOM=${RAND(1000,9999)})
exten => s,n,Set(COUNT=${DB(fwcid2/count)})
exten => s,n,GotoIf($[${ISNULL(${COUNT})}]?:nextstep)
exten => s,n,Set(DB(fwcid2/count)=1)
exten => s,n,NoOp()
exten => s,n,NoOp(UNIQID = ${COUNT})
exten => s,n,Set(COUNT=$[${COUNT} + 1])
exten => s,n,Set(DB(fwcid2/count)=${COUNT})
exten => s,n,System(echo "Неотвеченный вызов с номера +7${CALLERID(NUM)} в ${STRFTIME(${EPOCH},,%H:%M)}" > ${CIDFILE}-${CALLERID(NUM)}-${COUNT})
exten => s,n,System(echo "" >> ${CIDFILE}-${CALLERID(NUM)}-${COUNT})
exten => s,n,System(echo "Время ожидания абонента на линии составило ${CTDTIME} сек" >> ${CIDFILE}-${CALLERID(NUM)}-${COUNT})
exten => s,n,System(echo "hello" | mutt -x -s "+74951234567: пропущенный звонок ${STRFTIME(${EPOCH},,%d.%m.%Y)} ${STRFTIME(${EPOCH},,%H:%M)}" -e "set from="voip@domain.ru"" -e 'set realname='Asterisk'' voip@domain.ru < ${CIDFILE}-${CALLERID(NUM)}-${COUNT})
exten => s,n,System(/bin/rm -f ${CIDFILE}-${CALLERID(NUM)}-${COUNT})
exten => s,n,Hangup()
```
${STRFTIME(${EPOCH},,%H:%M)} — время поступления звонка.
${CALLERID(NUM)} — номер звонящего.
${COUNT} — по большей части пример работы с ASTBD, значение переменной добавляется в конец создаваемого файла, чтобы сделать его уникальным, на случай если с одного и того же номера, в одно и то же время поступит звонок.
Теперь о добавлении записей в таблицу MySQL.
${SQLHOST/SQLUSER/SQLPASS/SQLD} — данные переменные я определил в секции globals.
${QID} — переменная которую мы передаем в макрос, предварительно определив ее при входящем звонке 'Set(\_\_QID=${CDR(uniqueid)})'. Обратите внимание на два ведущих символа подчеркивания, позволяющих унаследовать переменную в макрос macro-startflag1.
```
[macro-startflag1]
exten => s,1,Set(CALLID=74951234567)
exten => s,n,MYSQL(Connect connid ${SQLHOST} ${SQLUSER} ${SQLPASS} ${SQLDB})
exten => s,n,MYSQL(Query resultid ${connid} INSERT INTO office_calls VALUES (NULL,'${STRFTIME(,GMT,%G-%m-%d %H:%M:%S)}',1,'${CALLID}','${CDR(src)}','${CDR(dstcha
nnel):0:9}','${STRFTIME(,GMT,%G-%m-%d %H:%M:%S)}','${STRFTIME(,GMT,%G-%m-%d %H:%M:%S)}','${QID}'))
exten => s,n,MYSQL(Clear ${resultid})
exten => s,n,MYSQL(Disconnect ${connid})
exten => s,n,Hangup()
```
**Рассмотрим еще одну задачу:** требуется формировать XML файл при пропущенных звонках.
Формат файла должен быть следующего вида:
```
xml version="1.0" encoding="UTF-8"?
100XXXX --- XXX какой-то уникальный идентификатор
--- номер телефона, на который пришел звонок
123456 --- номер телефона, с которого пришел звонок
Пропущенный звонок
false
11.12.2012 - 17:19 --- дата звонка
11.12.2012 - 17:19 --- дата звонка
```
В решении задачи я воспользуюсь командой System() и perl- скриптом.
Установим XML::Writer
```
yum install perl-XML-Writer
```
Скрипт /etc/asterisk/scripts/genxml.pl выглядит следующим образом:
```
#!/usr/bin/env perl
# Create XML file
use strict;
use warnings;
use XML::Writer;
# Out to file
#open STDOUT, ">", "REQUEST.20121211171903.xml" or die "$0: open: $!";
my $doc = new XML::Writer();
# Pring attributes
$doc->xmlDecl('UTF-8');
$doc->startTag("callback_request");
$doc->dataElement( id => "$ARGV[0]");
$doc->startTag( "name");
$doc->characters( "$ARGV[1]");
$doc->endTag( "name");
$doc->dataElement( phone => "$ARGV[2]");
$doc->dataElement( comment => "Пропущенный звонок");
$doc->dataElement( completed => "false");
$doc->dataElement( created_at => "$ARGV[3]");
$doc->dataElement( updated_at => "$ARGV[3]");
$doc->emptyTag( "no_answer");
$doc->endTag();
$doc->end();
```
Запуск скрипта производится следующим образом:
```
exten => s,n,System(/usr/bin/perl /etc/asterisk/scripts/genxml.pl "100${RANDOM}" "74951234567" "${CALLERID(NUM)}" "${STRFTIME(${EPOCH},,%d.%m.%Y - %H:%M)}" > /srv/www/domain.ru/xml/REQUEST.${STRFTIME(${EPOCH},,%Y%m%d%H%M%S)}.xml)
```
Надеюсь данный материал будет полезен вам.
Спасибо за внимание. | https://habr.com/ru/post/162825/ | null | ru | null |
# Mac Maniac
Привет! Это мой первый **хабратопик** (не считая песочницы)
и я даже не знаю увидит его кто-нибудь или нет :-)
Ну вот мне нравится некоторые фишки на Mac которых нету в Винде. По мере возможности я пишу их на скриптовом языке AutoHotKey дабы не чувствовать себя обделённым) Что? Вы ещё не знаете про этот язык? Ну чтож, скорее сюда [www.autohotkey.com](http://www.autohotkey.com/). Хотя это можно написать практически на любом полноценном языке, но примеры я приведу именно на этом, потомучто главное — идея.
Может быть это кому-то покажется полезным
**Отображение подключённых девайсов и их извлечение**
Как всё-таки удобно, когда на рабочем столе появляется ярлык только-что подключённого девайса. И также удобно его извлечение просто перемещением на значок означающий извлечение.
[](http://radikal.ru/F/i043.radikal.ru/0901/de/aea708404cf6.jpg.html)
Конечно же есть разные утилитки для этого процесса (к примеру [DeskDrive](http://blueonionsoftware.com/deskdrive.aspx)) но к сожалению она не позволяет простым переносом на заветную кнопочку извлечь CD/USB. В Моём случае значок извлечения — это просто ярлык на cкомпилированный EXE, которыя извлекает из Drag`n`Drop буквы устройств (да-да, возможно их выделить все и кинуть туда и они все извлекутся (и CD\DVD тоже)). Чтобы у ярлыка не отображалось имя, надо нажать «переименовать» и в поле ввода зажать ALT и быстро набрать на NumPad`е 0160. это комбинация поставит невидимый символ. для того чтобы все ярлыки на рабочем столе были такими, надо для каждого ярлыка проделать это n-ое количество раз, чтобы имена не совпадали.
**exe** + иконка [**тут**](http://kefirux.narod.ru/Eject.rar)
Для начала рассмотрим программу извлечения:
(простая версия. кидаем на съедение ярлыки устройств — они извлекается)
`#NoEnv
#NoTrayIcon
Loop ;это бесконечный цикл. обрабатываем всю группу ярлыков
{
curr:=%A_Index% ;A_Index - номер итерации цикла
;Следует обратить внимание на := и %% это не значит что в curr
;пойдёт 1,2,3... туда пойдут значение %1%, %2%, .... - а это и есть ссылки
if(curr="") ;а вот и конец нашего бесконечного цикла :-)
ExitApp ;выход из приложения
FileGetShortcut, %curr%, OutTarget ;Берём Target из ярлыка
Driveletter := SubStr(OutTarget,1,2) ;Берём букву девайса из ярлыка
;========Дальше идёт известный пример извлечения из Help по AutoHotKey=====
hVolume := DllCall("CreateFile"
, Str, "\\.\" . Driveletter
, UInt, 0x80000000 | 0x40000000 ; GENERIC_READ | GENERIC_WRITE
, UInt, 0x1 | 0x2 ; FILE_SHARE_READ | FILE_SHARE_WRITE
, UInt, 0
, UInt, 0x3 ; OPEN_EXISTING
, UInt, 0, UInt, 0)
if hVolume <> -1
{
DllCall("DeviceIoControl" ;годится как для USB, так и для CD
, UInt, hVolume
, UInt, 0x2D4808 ; IOCTL_STORAGE_EJECT_MEDIA
, UInt, 0, UInt, 0, UInt, 0, UInt, 0
, UIntP, dwBytesReturned ; Unused.
, UInt, 0)
DllCall("CloseHandle", UInt, hVolume)
}
FileRecycle, %curr% ;удаляем ярлык
}
return`
Но это была простая версия. сложная с «кучей наворотов» (Как раз вверху ссылка на сложную версию) выглядит так:
**\*** если кинута не ссылка на девайс, а файл, то перемещаем его в корзину (старый добрый MAC)
**\*** таже самая участь постигнет ссылка не на девайс а например на папку\файл в девайсе
**\*** тоже самое и ссылкой на Жёсткие Диски. Не надо их извлекать :-)
**\*** при запуске программы без параметров (просто даблклик), программа проверяет
все девайсы на готовность и обновляет ярлыки на рабочем столе (удаляет лишнее, добавляет нужное) причём Иконки и имена к девайсам берём из папки exe-шника «ico». Формат имён иконок думаю понятен: (J)Мыльница.ico — это значит что это иконка для девайса J и имя на рабочем столе у него будет «Мыльница».
Но чего то не хватает, чувствуете? Ага! Хочу чтобы иконки по мере подключения появлялись сами на рабочем столе! Но вот тут есть один нюанс — для этого надо чтобы программа всегда висела в памяти, отлавливая сообщение WM\_DEVICECHANGE, а на это мало кто согласится. Но всё же если вдруг:
[**Код + Exe**](http://kefirux.narod.ru/Device.rar)
[Зеркало (Webfile.ru)](http://webfile.ru/2599960)
конечно же есть некоторые баги: к примеру с кардридерами часто не правильно работает, но это потомучто почему-то система не посылает WM\_DEVICECHANGE при вынимании или вставлении карты памяти в кардридер (кто-нибудь знает решение?
**так как это тестировалось только на моей машине (XP SP3), то думаю ща будут эксепшены литься рекой :-)**
p.s.: Иконки можно брать тут:
[deviantArt.com](http://deviantArt.com)
[allday.ru](http://allday.ru) (только после регистрации)
[www.iconspedia.com](http://www.iconspedia.com)
p.p.s.: как бы это не последний топик на тему Mac Maniac или «Я слишком бедный для MAC» :-) | https://habr.com/ru/post/50707/ | null | ru | null |
# Книга «Путь Python. Черный пояс по разработке, масштабированию, тестированию и развертыванию»
[](https://habr.com/ru/company/piter/blog/466027/) Привет, Хаброжители! «Путь Python» позволяет отточить ваши профессиональные навыки и узнать как можно больше о возможностях самого популярного языка программирования. Вы научитесь писать эффективный код, создавать лучшие программы за минимальное время и избегать распространенных ошибок. Пора познакомиться с многопоточными вычислениями и мемоизацией, получить советы экспертов в области дизайна API и баз данных, а также заглянуть внутрь Python, чтобы расширить понимание языка. Вам предстоит начать проект, поработать с версиями, организовать автоматическое тестирование и выбрать стиль программирования для конкретной задачи. Потом вы перейдете к изучению эффективного объявления функции, выбору подходящих структур данных и библиотек, созданию безотказных программ, пакетам и оптимизации программ на уровне байт-кода.
### Отрывок. Параллельный запуск тестов
Запуск тестовых наборов может отнимать много времени. Это частое явление в крупных проектах, когда выполнение набора тестов занимает минуты. По умолчанию pytest запускает тесты последовательно, в определенном порядке.
Так как большинство компьютеров имеют многоядерные процессоры, можно ускориться, если произвести разделение тестов для запуска на нескольких ядрах.
Для этого в pytest есть плагин pytest-xdist, который можно установить с помощью pip. Этот плагин расширяет командную строку pytest аргументом ––numprocesses (сокращенно –n), принимающим в качестве аргумента количество используемых ядер. Запуск pytest –n 4 запустит тестовый набор в четырех параллельных процессах, сохраняя баланс между загруженностью доступных ядер.
Из-за того что количество ядер может различаться, плагин также принимает ключевое слово auto в качестве значения. В этом случае количество доступных ядер будет возвращено автоматически.
### Создание объектов, используемых в тестах, с помощью фикстур
В модульном тестировании часто придется выполнять набор стандартных операций до и после запуска теста, и эти инструкции задействуют определенные компоненты. Например, может понадобиться объект, который будет выражать состояние конфигурации приложения, и он должен инициализироваться перед каждым тестированием, а потом сбрасываться до начальных значений после выполнения. Аналогично, если тест зависит от временного файла, этот файл должен создаваться перед тестом и удаляться после. Такие компоненты называются *фикстурами*. Они устанавливаются перед тестированием и пропадают после его выполнения.
В pytest фикстуры объявляются как простые функции. Функция фикстуры должна возвращать желаемый объект, чтобы в тестировании, где она используется, мог использоваться этот объект.
Вот пример простой фикстуры:
```
import pytest
@pytest.fixture
def database():
return
def test\_insert(database):
database.insert(123)
```
Фикстура базы данных автоматически используется любым тестом, который имеет аргумент database в своем списке. Функция test\_insert() получит результат функции database() в качестве первого аргумента и будет использовать этот результат по своему усмотрению. При таком использовании фикстуры не нужно повторять код инициализации базы данных несколько раз.
Еще одна распространенная особенность тестирования кода — это возможность удалять лишнее после работы фикстуры. Например, закрыть соединение с базой данных. Реализация фикстуры в качестве генератора добавит функциональность по очистке проверенных объектов (листинг 6.5).
> #### Листинг 6.5. Очистка проверенного объекта
>
>
>
>
> ```
> import pytest
>
> @pytest.fixture
> def database():
> db =
> yield db
> db.close()
>
> def test\_insert(database):
> database.insert(123)
> ```
>
Так как мы использовали ключевое слово yield и сделали из database генератор, то код после утверждения yield выполнится только в конце теста. Этот код закроет соединение с базой данных по завершении теста.
Закрытие соединения с базой данных для каждого теста может вызвать неоправданные траты вычислительных мощностей, так как другие тесты могут использовать уже открытое соединение. В этом случае можно передать аргумент scope в декоратор фикстуры, указывая область ее видимости:
```
import pytest
@pytest.fixture(scope="module")
def database():
db =
yield db
db.close()
def test\_insert(database):
database.insert(123)
```
Указав параметр scope = «module», вы инициализировали фикстуру единожды для всего модуля, и теперь открытое соединение с базой данных будет доступно для всех тестовых функций, запрашивающих его.
Можно запустить какой-нибудь общий код до или после теста, определив фикстуры как автоматически используемые с помощью ключевого слова autouse, а не указывать их в качестве аргумента для каждой тестовой функции. Конкретизация функции pytest.fixture() с помощью аргумента True, ключевого слова autouse, гарантирует, что фикстура вызывается каждый раз перед запуском теста в том модуле или классе, где она объявлена.
```
import os
import pytest
@pytest.fixture(autouse=True)
def change_user_env():
curuser = os.environ.get("USER")
os.environ["USER"] = "foobar"
yield
os.environ["USER"] = curuser
def test_user():
assert os.getenv("USER") == "foobar"Запуск тестовых сценариев
При модульном тестировании может понадобиться запустить один и тот же тест, но с разными объектами, которые вызвали ошибку, или же прогнать весь набор тестов на другой системе.
Мы очень сильно полагались на этот метод при разработке Gnocchi, базы данных временных рядов. Gnocchi обеспечивает абстрактный класс под названием *storage API*. Любой класс в Python может реализовать эту абстрактную базу и зарегистрировать себя как драйвер. ПО при необходимости загружает отконфигурированный драйвер хранилища, а затем использует реализованное хранилище API для извлечения данных. В этом примере нам нужен класс модульного тестирования, который запускается с каждым драйвером (запускается для каждой реализации storage API), чтобы убедиться, что все драйверы совершают ожидаемые пользователем действия.
Этого легко добиться, если применить *параметрические фикстуры*, запускающие несколько раз все тесты, где они используются единожды для каждого указанного параметра. Листинг 6.6 содержит пример использования параметрических фикстур для запуска одного теста дважды, но с разными параметрами: один раз для mysql, а второй — для postgresql.
> #### Листинг 6.6. Запуск теста с помощью параметрических фикстур
>
>
> import pytest
> import myapp
>
> @pytest.fixture(params=["mysql", "postgresql"])
> def database(request):
> d = myapp.driver(request.param)
> d.start()
> yield d
> d.stop()
>
> def test\_insert(database):
> database.insert("somedata")
```
Фикстура driver получает в качестве параметра два разных значения — имена драйверов баз данных, которые поддерживаются приложением. test\_insert запускается дважды: один раз для базы данных MySQL, а второй — для базы данных PostgreSQL. Это облегчает повторное прохождение одного и того же тестирования, но с разными сценариями, без добавления новых строк кода.
### Управляемые тесты с объектами-пустышками
Объекты-пустышки (или заглушки, mock objects) — это объекты, которые имитируют поведение реальных объектов приложения, но в особенном, управляемом состоянии. Они наиболее полезны в создании окружений, которые досконально описывают условия проведения теста. Вы можете заменить все объекты, кроме тестируемого, на объекты-пустышки и изолировать его, а также создать окружение для тестирования кода.
Один из случаев их использования — создание HTTP-клиента. Практически невозможно (или точнее, невероятно сложно) создать HTTP-сервер, на котором можно прогнать все варианты ситуаций и сценарии для каждого возможного значения. HTTP-клиенты особенно сложно тестировать на сценарии ошибок.
В стандартной библиотеке есть команда mock для создания объекта-пустышки. Начиная с Python 3.3 mock объединен с библиотекой unittest.mock. Поэтому можно использовать фрагмент кода, приведенный ниже, для обеспечения обратной совместимости между Python 3.3 и более ранними версиями:
```
try:
from unittest import mock
except ImportError:
import mock
```
Библиотека mock очень проста в применении. Любой атрибут, доступный для объекта mock.Mock, создается динамически во время выполнения программы. Такому атрибуту может быть присвоено любое значение. В листинге 6.7 mock используется для создания объекта-пустышки для атрибута-пустышки.
> #### Листинг 6.7. Обращение к атрибуту mock.Mock
>
>
>
>
> ```
> >>> from unittest import mock
> >>> m = mock.Mock()
> >>> m.some_attribute = "hello world"
> >>> m.some_attribute
> "hello world"
> ```
>
Можно также динамически создавать метод для изменяемого объекта, как в листинге 6.8, где создается метод-пустышка, который всегда возвращает значение 42 и принимает в качестве аргумента все что угодно.
> #### Листинг 6.8. Создание метода для объекта-пустышки mock.Mock
>
>
>
>
> ```
> >>> from unittest import mock
> >>> m = mock.Mock()
> >>> m.some_method.return_value = 42
> >>> m.some_method()
> 42
> >>> m.some_method("with", "arguments")
> 42
> ```
>
Всего пара строк, и объект mock.Mock теперь имеет метод some\_method(), который возвращает значение 42. Он принимает любой тип аргумента, пока проверка того, что это за аргумент, отсутствует.
Динамически создаваемые методы могут также иметь (намеренные) побочные эффекты. Чтобы не быть просто шаблонными методами, которые возвращают значение, они могут быть определены для выполнения полезного кода.
Листинг 6.9 создает фиктивный метод, у которого есть побочный эффект — он выводит строку «hello world».
> #### Листинг 6.9. Создание метода для объекта mock.Mock с побочным эффектом
>
>
>
>
> ```
> >>> from unittest import mock
> >>> m = mock.Mock()
> >>> def print_hello():
> ... print("hello world!")
> ... return 43
> ...
> ❶ >>> m.some_method.side_effect = print_hello
> >>> m.some_method()
> hello world!
> 43
> ❷ >>> m.some_method.call_count
> 1
> ```
>
Мы присвоили целую функцию атрибуту some\_method ❶. Технически это позволяет реализовать более сложный сценарий в тесте, благодаря тому что можно включить любой необходимый для теста код в объект-пустышку. Далее нужно передать этот объект в функцию, которая его ожидает.
Атрибут ❷ call\_count — это простой способ проверки количества раз, когда метод был вызван.
Библиотека mock использует паттерн «действие — проверка»: это значит, что после тестирования нужно убедиться, что действия, замененные на пустышки, были выполнены корректно. В листинге 6.10 применяется метод assert() к объектам-пустышкам для осуществления этих проверок.
> #### Листинг 6.10. Вызов методов проверки
>
>
>
>
> ```
> >>> from unittest import mock
> >>> m = mock.Mock()
> ❶ >>> m.some_method('foo', 'bar')
>
> ❷ >>> m.some\_method.assert\_called\_once\_with('foo', 'bar')
> >>> m.some\_method.assert\_called\_once\_with('foo', ❸mock.ANY)
> >>> m.some\_method.assert\_called\_once\_with('foo', 'baz')
> Traceback (most recent call last):
> File "", line 1, in
> File "/usr/lib/python2.7/dist-packages/mock.py", line 846, in assert\_cal
> led\_once\_with
> return self.assert\_called\_with(\*args, \*\*kwargs)
> File "/usr/lib/python2.7/dist-packages/mock.py", line 835, in assert\_cal
> led\_with
> raise AssertionError(msg)
> AssertionError: Expected call: some\_method('foo', 'baz')
> Actual call: some\_method('foo', 'bar')
> ```
>
Мы создали методы с аргументами foo и bar в качестве тестов, вызвав метод ❶. Простой способ проверить вызовы к объектам-пустышкам — использовать методы assert\_called(), такие как assert\_called\_once\_with() ❷. Для этих методов необходимо передать значения, которые, как вы ожидаете, будут использованы при вызове метода-пустышки. Если переданные значения отличаются от используемых, то mock вызывает исключение AssertionError. Если вы не знаете, какие аргументы могут быть переданы, используйте mock.ANY в качестве значения ❸; он заменит любой аргумент, передаваемый в метод-пустышку.
Библиотека mock также может быть использована для замены функции, метода или объекта из внешнего модуля. В листинге 6.11 мы заменили функцию os.unlink() собственной функцией-пустышкой.
> #### Листинг 6.11. Использование mock.patch
>
>
>
>
> ```
> >>> from unittest import mock
> >>> import os
> >>> def fake_os_unlink(path):
> ... raise IOError("Testing!")
> ...
> >>> with mock.patch('os.unlink', fake_os_unlink):
> ... os.unlink('foobar')
> ...
> Traceback (most recent call last):
> File "", line 2, in
> File "", line 2, in fake\_os\_unlink
> IOError: Testing!
> ```
>
При использовании в качестве менеджера контекста mock.patch() заменяет целевую функцию на ту, которую мы выбираем. Это нужно, чтобы код, выполняемый внутри контекста, использовал исправленный метод. С методом mock.patch()можно изменить любую часть внешнего кода, заставив его вести себя так, чтобы протестировать все условия для приложения (листинг 6.12).
> #### Листинг 6.12. Использование mock.patch() для тестирования множества поведений
>
>
>
>
> ```
> from unittest import mock
>
> import pytest
> import requests
>
> class WhereIsPythonError(Exception):
> pass
>
> ❶ def is_python_still_a_programming_language():
> try:
> r = requests.get("http://python.org")
> except IOError:
> pass
> else:
> if r.status_code == 200:
> return 'Python is a programming language' in r.content
> raise WhereIsPythonError("Something bad happened")
>
> def get_fake_get(status_code, content):
> m = mock.Mock()
> m.status_code = status_code
> m.content = content
>
> def fake_get(url):
> return m
>
> return fake_get
>
> def raise_get(url):
> raise IOError("Unable to fetch url %s" % url)
>
> ❷ @mock.patch('requests.get', get_fake_get(
> 200, 'Python is a programming language for sure'))
> def test_python_is():
> assert is_python_still_a_programming_language() is True
>
> @mock.patch('requests.get', get_fake_get(
> 200, 'Python is no more a programming language'))
> def test_python_is_not():
> assert is_python_still_a_programming_language() is False
>
> @mock.patch('requests.get', get_fake_get(404, 'Whatever'))
> def test_bad_status_code():
> with pytest.raises(WhereIsPythonError):
> is_python_still_a_programming_language()
>
> @mock.patch('requests.get', raise_get)
> def test_ioerror():
> with pytest.raises(WhereIsPythonError):
> is_python_still_a_programming_language()
> ```
>
Листинг 6.12 реализует тестовый случай, который ищет все экземпляры строки *Python is a programming language* на сайте [python.org](http://python.org/) ❶. Не существует варианта, при котором тест не найдет ни одной заданной строки на выбранной веб-странице. Чтобы получить отрицательный результат, необходимо изменить страницу, а этого сделать нельзя. Но с помощью mock можно пойти на хитрость и изменить поведение запроса так, чтобы он возвращал ответ-пустышку с выдуманной страницей, не содержащей заданной строки. Это позволит протестировать отрицательный сценарий, в котором [python.org](http://python.org/) не содержит заданной строки, и убедиться, что программа обрабатывает такой случай корректно.
В этом примере используется версия декоратора mock.patch() ❷. Поведение объекта-пустышки не меняется, и было проще показать пример в контексте тестовой функции.
Использование объекта-пустышки поможет сымитировать любую проблему: возвращение сервером ошибки 404, ошибку ввода-вывода или ошибку задержки сети. Мы можем убедиться, что код возвращает правильные значения или вызывает нужное исключение в каждом случае, что гарантирует ожидаемое поведение кода.
### Выявление непротестированного кода с помощью coverage
Отличным дополнением для модульного тестирования является инструмент coverage [Покрытие кода — мера, используемая при тестировании. Показывает процент исходного кода программы, который был выполнен в процессе тестирования — *ред.*], который находит непротестированные части кода. Он использует инструменты анализа и отслеживания кода для выявления тех строк, которые были выполнены. В модульном тестировании он может выявить, какие части кода были задействованы многократно, а какие вообще не использовались. Создание тестов необходимо, а возможность узнать, какую часть кода вы забыли покрыть тестами, делает этот процесс приятнее.
Установите модуль coverage через pip, чтобы получить возможность использовать его через свою командную оболочку.
> #### ПРИМЕЧАНИЕ
>
>
>
> Команда также может называться python-coverage, если установка модуля происходит через установщик вашей ОС. Пример такого случая — ОС Debian.
Использовать coverage в автономном режиме довольно просто. Он показывает те части программы, которые никогда не запускаются и стали «мертвым грузом» — таким кодом, убрать который без изменения работоспособности программы уже не получится. Все тестовые инструменты, которые обсуждались ранее в главе, интегрированы с coverage.
При использовании pytest установите плагин pytest-cov через pip install pytest-pycov и добавьте несколько переключателей для генерации детального вывода непротестированного кода (листинг 6.13).
> #### Листинг 6.13. Использование pytest и coverage
>
>
>
>
> ```
> $ pytest --cov=gnocchiclient gnocchiclient/tests/unit
> ---------- coverage: platform darwin, python 3.6.4-final-0 -----------
> Name Stmts Miss Branch BrPart Cover
> ---------------------------
> gnocchiclient/__init__.py 0 0 0 0 100%
> gnocchiclient/auth.py 51 23 6 0 49%
> gnocchiclient/benchmark.py 175 175 36 0 0%
> --snip--
> ---------------------------
> TOTAL 2040 1868 424 6 8%
>
> === passed in 5.00 seconds ===
> ```
>
Опция --cov включает вывод отчета coverage в конце тестирования. Необходимо передать имя пакета в качестве аргумента, чтобы плагин должным образом отфильтровал отчет. Вывод будет содержать строки кода, которые не были выполнены, а значит, не тестировались. Все, что вам останется, — открыть редактор и написать тест для этого кода.
Модуль coverage еще лучше — он позволяет генерировать понятные отчеты в формате HTML. Просто добавьте -–cov-report-html, и в директории *htmlcov*, откуда вы запустите команду, появятся HTML-страницы. Каждая страница покажет, какие части исходного кода были или не были запущены.
Если вы хотите пойти еще дальше, то используйте –-cover-fail-under-COVER\_MIN\_PERCENTAGE, которая приведет к сбою тестового набора, если он не покрывает минимальный процент кода. Хотя большой процент покрытия — это хорошая цель, а инструменты тестирования полезны для получения информации о состоянии тестового покрытия, сама по себе величина процента не особо информативна. Рисунок 6.1 показывает пример отчета coverage с указанием процента покрытия.
Например, покрытие кода тестами на 100 % — достойная цель, но это не обязательно означает, что код тестируется полностью. Эта величина лишь показывает, что все строки кода в программе выполнены, но не сообщает, что были протестированы все условия.
Стоит использовать информацию о покрытии с целью расширения набора тестов и создания их для кода, который не запускается. Это упрощает поддержку проекта и повышает общее качество кода.
### Об авторе
*Джульен Данжу* занимается хакингом бесплатного ПО около двадцати лет, а программы на Python разрабатывает уже почти двенадцать лет. В настоящее время руководит проектной группой распределенной облачной платформы на основе OpenStack, которая владеет самой большой из существующих баз открытого кода Python, насчитывающей около двух с половиной миллионов строк кода. До разработки облачных сервисов Джульен занимался созданием менеджера окон и способствовал развитию многих проектов, например Debian и GNU Emacs.
### О научном редакторе
*Майк Дрисколл* программирует на Python более десяти лет. Долгое время он писал о Python в блоге [The Mouse vs. The Python](http://www.blog.pythonlibrary.org/). Автор нескольких книг по Python: Python 101, Python Interviews и ReportLab: PDF Processingwith Python. Найти Майка можно в Twitter и на GitHub: @driscollis.
» Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/new/product/put-python-chernyy-poyas-po-razrabotke-masshtabirovaniyu-testirovaniyu-i-razvertyvaniyu)
» [Оглавление](https://storage.piter.com/upload/contents/978544611308/978544611308_X.pdf)
» [Отрывок](https://storage.piter.com/upload/contents/978544611308/978544611308_p.pdf)
Для Хаброжителей скидка 25% по купону — **Python**
По факту оплаты бумажной версии книги на e-mail высылается электронная книга. | https://habr.com/ru/post/466027/ | null | ru | null |
# Можно ли доверять библиотекам, которые использует ваше приложение?
Если вы знакомы с современными техниками написания высококачественного кода, тогда, пожалуй, вам не стоит волноваться об уязвимостях кода, который вы написали. Однако, обычно приложения используют сторонние библиотеки (зависимости) - можно ли доверять им?
Пожалуй, нет. В мире насчитывается огромное количество разных библиотек и мы не можем быть уверены, что все они безопасны и что в них нет уязвимостей. Но возникает вопрос, как тогда удостовериться, что мы не добавим в наш проект уязвимостей вместе с добавлением новой библиотеки?
OWASP Dependency-Check на выручку
---------------------------------
Существует очень легкий и удобный способ убедиться, что новая библиотека не добавит уязвимостей в ваш проект - [OWASP Dependency-Check](https://owasp.org/www-project-dependency-check/). Это инструмент анализа состава программного обеспечения (SCA), который занимается обнаружением публично раскрытых уязвимостей, содержащихся в зависимостях проекта.
### Шаг 1 - Добавьте dependency check gradle плагин
Добавьте зависимость в ваш корневой build.gradle файл:
```
buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath 'org.owasp:dependency-check-gradle:7.2.0'
}
}
```
Затем добавьте dependency check gradle плагин в app/build.gradle:
```
apply plugin: 'org.owasp.dependencycheck'
```
### Шаг 2 - Запустите gradle-команду для проверки зависимостей
Начните проверку библиотек, используя следующую gradle команду:
```
./gradlew dependencyCheckAnalyze
```
При первом запуске потребуется некоторое время для загрузки файлов и выполнения проверки зависимостей. В результате проверки будет сгенерирован html-отчет:
При обнаружении уязвимостей, первым делом попробуйте проверить последнюю версию библиотеки - уязвимость может быть уже исправлена. Например, последние версии библиотеки Gson не содержат уязвимостей:
Таким образом, просто обновите версию библиотеки до последней и проблема будет устранена.
### Шаг 3 - Настройте CI для автоматической проверки
Очень удобно настроить CI автоматически запускать проверку зависимостей и завершать сборку приложения с ошибкой, если уязвимости были обнаружены. Если вы используете Github Actions, добавьте следующий шаг для проверки зависимостей:
```
- name: Run dependency check
run: ./gradlew dependencyCheckAnalyze
```
А чтобы завершить сборку приложения с ошибкой при обнаружении библиотек с уязвимостями, добавьте следующую инструкцию в app/build.gradle:
```
dependencyCheck {
failBuildOnCVSS = 0
}
```
### Выводы
Плагин проверки зависимостей - очень легкий и удобный способ увеличить надежность вашего приложения. И я был удивлен, насколько редко он используется. Я рекомендую добавить его в стек используемых средств на ваших проектах, а также настроить CI для автоматических и регулярных проверок, чтобы своевременно узнавать о том, что в какой-то библиотеке была обнаружена уязвимость и необходимо ее устранить.
### Полезные ссылки
* Главная [страница](https://owasp.org/www-project-dependency-check/) OWASP Dependency Check
* [Документация](https://github.com/dependency-check/dependency-check-gradle) Dependency Check Gradle плагина на Github | https://habr.com/ru/post/693890/ | null | ru | null |
# Сниппеты против Клевера – обыгрываем популярнейшую викторину в реальном времени
Апрель 2018-го года. Мне было 14. Мы с друзьями играли в тогда очень популярную онлайн-викторину «Клевер» от ВКонтакте. Один из нас (обычно я) всегда был за ноутбуком, чтобы пытаться быстро гуглить вопросы и глазами искать в поисковой выдаче правильный ответ. Но вдруг я понял, что каждый раз выполняю одно и то же действие, и решил попробовать написать это на частично известном мне тогда Python 3.
### Шаг 0. Что здесь происходит
Для начала я освежу в вашей памяти механику «Клевера».
Игра для всех начинается в одно и то же время — в 13:00 и в 20:00 по Москве. Чтобы сыграть, нужно в это время зайти в приложение и подключиться к прямой трансляции. Игра идет 15 минут, в течение которых участникам на телефон **одновременно** приходят вопросы. На ответ дается **10 секунд.** Затем объявляется верный ответ. Все, кто угадали, проходят дальше. Всего вопросов 12, и если ответить на все – получишь денежный приз.
Получается, наша задача — мгновенно ловить новые вопросы от сервера Клевера, обрабатывать их через какой-либо поисковик, а по результатам выдачи определять правильный ответ. Вывод ответа было решено производить в телеграм-бота, чтобы уведомления из него всплывали на телефоне прямо во время игры. И все это желательно за пару секунд, ведь время на ответ сильно ограничено. Если вы хотите увидеть, как довольно простой, но рабочий код (а посмотреть на такой будет полезно новичкам) помогал нам обыгрывать Клевер – добро пожаловать под кат.
### Шаг 1. Получаем вопросы с сервера
Сначала это показалось самым сложным этапом. Я уже сделал глубокий вдох и готов был полезть в дебри вроде компьютерного зрения, перехвата трафика или декомпиляции приложения… Как вдруг меня ждал сюрприз – у Клевера открытое API! Оно нигде не задокументировано, но если во время игры, как только всем игрокам задали вопрос, сделать request на api.vk.com, то в ответ мы получим заданный вопрос и варианты ответов к нему в JSON:
```
https://api.vk.com/method/execute.getLastQuestion?v=5.5&access_token=VK_USER_TOKEN
```
В качестве access\_token необходимо передавать API-токен любого пользователя ВКонтакте, но важно, чтобы он был изначально выписан именно для Клевера. Его app\_id – 6334949.
### Шаг 2. Обрабатываем вопрос через поисковик
Было два варианта: использовать официальное API поисковиков или добавлять поисковые аргументы прямо в адресную строку, а результаты парсить. Сначала я опробовал второй, но мало того, что иногда ловил капчу, так еще и терял кучу времени, ведь страницы грузились в среднем за 2 секунды. А я напомню, что нам желательно уложиться в эти самые две секунды. Ну и главное – я не получал от поисковиков больших и структурированных текстов на нужную тему, так как на странице поиска висят лишь небольшие кусочки нужного материала, которые именуются **сниппетами**:
Поэтому я начал искать API. Google не подошел — их решения были очень ограниченными и возвращали очень мало данных. Самым щедрым оказался [Яндекс.XML](https://xml.yandex.ru) — он разрешает посылать 10000 запросов в день, не более 5 в секунду, а данные возвращает очень быстро. В запросе к нему опционально количество страниц (вплоть до 100) и количество пассажей — специальных величин, которые используются для формирования сниппетов. Данные мы получаем в XML. Однако это все те же сниппеты.
Чтобы вы могли ознакомиться и поиграть с тем, что возвращает Яндекс, то вот пример ответа на запрос «Как зовут главного антагониста в серии видеоигр «The Legend of Zelda»?»: [Яндекс. Диск](https://yadi.sk/d/lZekhcm85Vy28A).
Мне повезло, и оказалось, что в pypi под это уже существует отдельный модуль [yandex-search](https://pypi.org/project/yandex-search/). И вот, я попробовал получить вопрос с сервера, найти его в яндексе, из сниппетов сделать один большой текст и разбить его на предложения:
```
import requests as req
import yandex_search
import json
apiurl = "https://api.vk.com/method/execute.getLastQuestion?access_token=VK_USER_TOKEN&v=5.5"
clever_response = (json.loads(req.get(apiurl).content))["response"]
# {'text': 'Какой из этих мультфильмов первым получил премию Оскар в номинации «Лучший анимационный полнометражный фильм»?', 'answers': [{'id': 0, 'users_answered': 0, 'text': '«История игрушек»'}, {'id': 1, 'users_answered': 0, 'text': '«Корпорация монстров»'}, {'id': 2, 'users_answered': 0, 'text': '«Шрек»'}], 'stop_time': 0, 'is_first': 0, 'is_last': 1, 'number': 12, 'id': 22, 'sent_time': 1533921436}
question = str(clever_response["text"])
ans1, ans2, ans3 = str(clever_response["answers"][0]["text"]).lower(), str(clever_response["answers"][1]["text"]).lower(), str(clever_response["answers"][2]["text"]).lower()
def yandexfind(question):
finded = yandex.search(question).items
snips = ""
for i in finded:
snips += (i.get("snippet")) + "\n"
return snips
items = yandexfind(question)
itemslist = list(items.split(". "))
```
### Шаг 3. В поисках ответов
Изначально задача точно распознать ответ по сниппетам казалась мне нереальной (напоминаю, что на момент написания кода я был абсолютным новичком). Поэтому я решил сперва упростить ту задачу, которую мы выполняли при ручном поиске.
Что мы с друзьями делали, когда вбивали свой вопрос в поисковик? Начинали бегло искать глазами ответы в результатах. В чем проблема такого подхода? В ~~многабукв~~ наличии большого количества лишних, не содержащих информацию об ответах, предложений. Искать глазами иногда приходилось подолгу. Поэтому первое, что я решил сделать – выделить все предложения с упоминанием любого из ответов и вывести их на экран, чтобы мы искали ответ в совсем небольшом тексте, точно содержащем нужную нам информацию.
```
hint = [] #Список предложений, содержащих один из вариантов ответа
for sentence in itemslist: #Чекаем каждое предложение из сниппетов
if (ans1 in sentence) or (ans2 in sentence) or (ans3 in sentence):
hint.append(sentence)
if len(hint) > 4:
break
```
Казалось бы, получай нужные предложения, читай их и отвечай правильно. Но что делать, если мы так и не нашли ни одного нужного предложения? Я решил в таком случае обрезать слова, чтобы не упускать их, если они стоят в другом падеже. А еще чтобы захватить те, которые образованы от исходных. Короче, я просто обрезал их окончание на два символа:
```
if len(hint) == 0:
def cut(string):
if len(string) > 2:
return string[0:-2]
else:
return string
short_ans1, short_ans2, short_ans3 = cut(ans1), cut(ans2), cut(ans3)
for pred in itemslist: #Чекаем каждое предложение из сниппетов
if (short_ans1 in pred) or (short_ans2 in pred) or (short_ans3 in pred)
hint.append(pred)
```
Но даже после такой подстраховки все равно были случаи, когда hint оставался пустым, просто потому что в результатах не всегда хоть как-то затрагивались ответы. Скажем, на вопрос *«У какого из этих писателей есть повесть, названная так же, как и песня группы Би 2?»* точного ответа не найти. В этом случае я прибегал к обратному подходу – наводил справки по ответам и выводил вариант на основе того, как часто в результатах упоминаются слова из вопроса.
```
if len(hint) == 0:
questionlist = question.split(" ")
blacklist = ["что", "такое", 'как', 'называется', 'в', 'каком', 'году', 'для', 'чего', 'какой', 'какого', 'кого', 'кто', 'зачем', 'является', 'самым', 'большим', 'маленьким', 'из', 'этого', 'входит', 'этих', 'кого', 'у', 'а', 'сколько']
for w in questionlist:
if w in blacklist:
questionlist.remove(w)
yandex_ans1 = yandexfind(ans1)
yandex_ans2 = yandexfind(ans2)
yandex_ans3 = yandexfind(ans3)
#Чуть позже я сделал этот процесс асинхронным, но это было костыльно
count_ans1, count_ans2, count_ans3 = 0, 0, 0
for w in questionlist:
count_ans1 += yandex_ans1.count(w)
count_ans2 += yandex_ans2.count(w)
count_ans3 += yandex_ans3.count(w)
if (count_ans1 + count_ans2 + count_ans3) > 5:
if count_ans1 > (count_ans2 + count_ans3):
print(ans1)
elif count_ans2 > (count_ans1 + count_ans3):
print(ans2)
elif count_ans3 > (count_ans2 + count_ans1):
print(ans3)
```
На этом месте скрипт обрел базовую функциональность. И вот, спустя всего полторы недели после релиза Клевера, мы сидим и уже играем с таким самописным «читом». Видели бы вы наши с другом лица, когда мы впервые **выиграли игру**, читая в командной строке как по волшебству появляющиеся предложения!
### Шаг 4. Вывод четких ответов
Но скоро такой формат надоел. Во-первых, нужно было каждую игру сидеть с ноутбуком. Во-вторых, скрипт просили себе друзья, и я устал каждому объяснять, как вставить свой токен ВКонтакте, как настроить Яндекс.XML (он привязан к IP, то есть под каждого пользователя скрипта нужно было создавать аккаунт) и как установить питон на компьютер.
Было бы куда лучше, если бы ответы всплывали в пуш-уведомлениях на телефоне прямо во время игры! Просто посмотрел наверх экрана и ответил так, как написано в пуш-уведомлении! А организовать это для всех можно, если создать скрипту свой телеграм-канал! Чудесно!
Но просто выводить в телеграм все те же предложения – не вариант. Читать их с телефона крайне неудобно. Поэтому пришлось учить скрипт самому понимать, какой ответ правильный.
Импортируем **telebot** и все функции **print()** меняем на **send\_tg()** и **notsure()**, который мы будем использовать в последнем методе, так как промахивается он немного чаще остальных:
```
def send_tg(ans):
bot.send_message("@autoclever", str(ans).capitalize())
print(str(ans))
return
def notsure(ans):
send_tg(ans.capitalize() + ". Это неточно!")
hint.append("WE TRIED!")
```
И вот на этом моменте я понял, что сниппеты подходят гораздо лучше подробных текстов! Потому что поисковик очень старается именно **дать ответ** на наш запрос, а не просто найти совпадения по словам. И у него получается – в сниппетах чаще содержались правильные ответы, чем неправильные, то есть анализировать текст потребности не было. Да и я, собственно, не умел.
Так что нехитро подсчитываем упоминания слов в результатах:
```
anscounts = {
ans1: 0,
ans2: 0,
ans3: 0
}
for s in hint:
for a in [ans1, ans2, ans3]:
anscounts[a] += s.count(a)
right = (max(anscounts, key=anscounts.get))
send_tg(right)
#Ура!
```
Что получилось в итоге:
### Дальнейшая судьба
Справедливости ради надо сказать, что машина смерти у меня не получилась. В среднем бот отвечал правильно только на 9-10 вопросов из 12ти. Оно и понятно, ведь встречались каверзные, которые не поддавались парсингу Яндексовского поиска. Меня, да и моих друзей утомило постоянно пролетать на парочке вопросов и ждать удачной игры, на которой бот наконец-то на все ответит правильно. Чуда не происходило, скрипт дорабатывать уже не сильно хотелось, и тогда мы, перестав питать надежды на легкую победу, забросили игру.
Со временем моя идея начала закрадываться в головы других молодых разработчиков. К закату 2018-го года насчитывалось как минимум 10 ботов и сайтов, выводящих свои догадки по вопросам в Клевере. Задача-то не такая сложная. Но что удивительно, никто из них так и не перешагнул планку в 9-10 вопросов за игру, а позднее все упали и вовсе до 7-8, как и мой бот. Видимо, составители вопросов просекли, как нужно составлять вопросы, чтобы труд поисковиков был нерелевантен.
К сожалению, бота уже не доработать, ведь 31го декабря Клевер провел последний эфир, а датасет вопросов у меня не сохранился. Тем не менее, это был отличный опыт для начинающего программиста. И наверняка был бы отличный вызов для продвинутого – только представьте себе дуэт word2vec и text2vec, асинхронные запросы к Яндексу, Гуглу и Википедии одновременно, продвинутый классификатор вопросов и алгоритм переформулировки вопроса в случае неудачи… Эх! Пожалуй, за такие возможности я любил эту игру больше, чем за сам геймплей. | https://habr.com/ru/post/435360/ | null | ru | null |
# PowerShell и GUI. Это — не сложно
Некоторое время назад в компании была развернута терминальная ферма.
Первым делом в неё были выселены пользователи некой желтой программы.
После чего отдел поддержки желтой программы спросил меня, можно ли отсылать сообщения пользователям фермы всем сразу. [XaocCPS](https://habrahabr.ru/users/xaoccps/) посоветовал мне играться в сторону WPF. Нужный скрипт был написан, но его работой я неудовлетворился:
1. Надо ставить внешний компонент PowerShellPack.
2. Компонент ставиться на сервера фермы (х64) отказался.
3. Распространять такое решение из за пункта 1 всем желающим не очень удобно.
[Xaegr](https://habrahabr.ru/users/xaegr/) подсказал что я могу избавиться от прослойки WPF.
Писать можно, можно даже писать красиво. Скрипт выполняется везде где есть .Net Framework — XP, Win7 и скорее всего пойдет даже на х64 серверах фермы.
Как писать — под катом.
UPD по просьбам скрипт выложен на SkyDrive, ссылка в конце
И так — ТЗ, полученное от отдела поддержки было «отправка сообщений всем пользователям терминальной фермы».
Мною ТЗ было расширено:
1. Выбор серверов.
2. Выбор пользователей.
3. Ввод текста сообщения.
4. Вставка подписи — идентификатор отправившего сообщения пользователя — виден в заголовке окна, но на него внимание обращают мало, выбрал вариант из нескольких предустановленных вариантов.
5. Защита от нечаянной отправки.
Предварительно было найдено, что в Win7 и 2008\* есть команда msg, с помощью которой данные сообщения и будут отправляться, но прием сообщений надо разрешить, что и сделал простеньким regedit файлом:
`Windows Registry Editor Version 5.00
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server]
"AllowRemoteRPC"=dword:00000001`
К сожалению, если пользователь из списка не подключен к серверу — скрипт много и сильно ругается. Я пока не придумал как получить вывод msg, и его обрабатывать.
Скрипт по максимуму комментирован.
~15kb
```
# Подключаем то, с помощью чего будем рисовать нашу форму
Add-Type -assembly System.Windows.Forms
# Все просто, массивы из списка серверов, списка пользоватей, и варианты подписи - чтобы использовать могла не только поддержка.
$Server = @("rdp1-1, rdp1-2, rdp1-3, rdp1-4", "rdp2-1, rdp2-2, rdp2-3, rdp2-4")
$User = @("*", "1c-admin1, 1c-admin2")
$Message = "Умолчательное сообщение"
# По хорошему, надо бы сделать так, чтобы если умолчательное сообщение не менялось и шло нажатие на кнопку отправить, то выводилось бы предупреждение.
# Так же по аналогии с тем что есть, тут тоже можно повесить список со стандартными сообщениями
# Подписываемся
$Sign = @("С уважением, администраторы 1С", "С уважением, системные администраторы")
# Повелось, что все функции описываются до их использования.
# Функция отправки сообщения. Принимаем параметры, проверяем, если чекбокс включен (а он включен по умолчанию), устанавливаем параметры отправки только на консоль локалхоста, иначе проходим по списку серверов, внутри каждого сервера инициируем цикл по списку пользователей с предварительно отрезанными пробелами до и после текста(помните формат: "сервер1, сервер2, сервер3" для красивой читаемости текста), вызываем сам msg для отправки сообщения и после чего вызываем диалогов окно с подтверждением отправки и закрытием программы.
Function SendMessage {
param ($Server, $User, $Message, $Sign)
# Write-Host $Server, $User, $Message, $Sign
If ($TestRunCheckBox.Checked -eq 1 ) { Write-Host $TestRunCheckBox.Checked; $Server="localhost"; $User = "Console" }
ForEach ($Item in $Server) {
ForEach ($UserX in $User) {
$UserTrim = $UserX.Trim()
$ServerTrim = $Item.Trim()
$MsgTrim = $Message.Trim()
$SignTrim = $SignX.Trim()
# Отладочный вывод, оставлен на всякий случай.
# Write-Host "User: $UserTrim; Server: $ServerTrim; Message: $MsgTrim; Signature: $SignTrim"
c:\windows\system32\msg.exe $UserTrim /Server:$ServerTrim $MsgTrim $SignTrim
}
}
Confirm
}
# Вывод окна с подтверждением
Function Confirm {
$ConfirmWin = New-Object System.Windows.Forms.Form
$ConfirmWin.StartPosition = "CenterScreen"
$ConfirmWin.Text = "Подтверждение отправки"
$ConfirmWin.Width = 200
$ConfirmWin.Height = 120
$ConfirmWin.ControlBox = 0
$ConfirmWinOKButton = New-Object System.Windows.Forms.Button
$ConfirmWinOKButton.add_click({ $MainSendWindow.Close(); $ConfirmWin.Close() })
$ConfirmWinOKButton.Text = "Закрыть"
$ConfirmWinOKButton.AutoSize = 1
$ConfirmWinOKButton.Location = New-Object System.Drawing.Point(50,50)
$ConfirmLabel = New-Object System.Windows.Forms.Label
$ConfirmLabel.Text = "Сообщение было отправлено"
$ConfirmLabel.AutoSize = 1
$ConfirmLabel.Location = New-Object System.Drawing.Point(10,10)
$ConfirmWin.Controls.Add($ConfirmLabel)
$ConfirmWin.Controls.Add($ConfirmWinOKButton)
$ConfirmWin.ShowDialog() | Out-Null
}
# Главное окно, по хорошему тоже стоило бы оформить в виде функции
$MainSendWindow = New-Object System.Windows.Forms.Form
$ToolTip = New-Object System.Windows.Forms.ToolTip
$ToolTip.BackColor = [System.Drawing.Color]::LightGoldenrodYellow
$ToolTip.IsBalloon = $true
# $ToolTip.InitialDelay = 500
# $ToolTip.ReshowDelay = 500
# Инициализация контролов формы
# Кнопки и чекбокс
$SendButton = New-Object System.Windows.Forms.Button
$CloseButton = New-Object System.Windows.Forms.Button
$TestRunCheckBox = New-Object System.Windows.Forms.CheckBox
# Текстовые поля и списки
$ServerTextBox = New-Object System.Windows.Forms.ComboBox
$UserTextBox = New-Object System.Windows.Forms.ComboBox
$MessageTextBox = New-Object System.Windows.Forms.TextBox
$SignTextBox = New-Object System.Windows.Forms.ComboBox
# Подписи
$ServerTextBoxLabel = New-Object System.Windows.Forms.Label
$UserTextBoxLabel = New-Object System.Windows.Forms.Label
$MessageTextBoxLabel = New-Object System.Windows.Forms.Label
$SignTextBoxLabel = New-Object System.Windows.Forms.Label
# Описываем свойства (комментариями я еще добавлю несколько нагугленных
# интересных свойств для общего развития и чтобы далеко не бегать ;))
# Главная форма
$MainSendWindow.StartPosition = "CenterScreen"
$MainSendWindow.Text = "Отправка сообщения пользователям"
$MainSendWindow.Width = 470
$MainSendWindow.Height = 220
# несколько плюшек и обещанных красивостей
#$Win.ControlBox = 0 # отключить кнопки свернуть, минимизацию и закрытие.
# $Win.ShowIcon = 0
# $Win.ShowInTaskbar = 0
# $Win.HelpButton = 1
# авторазмер может отрабатывать если вся форма - к примеру одна кнопка "Сделать хорошо"
# $Win.Autosize = 1
# $Win.AutoSizeMode = "GrowAndShrink"
# стиль обрамления и шрифт.
# $Win.FormBorderStyle = [System.Windows.Forms.FormBorderStyle]::Fixed3D
# $Win.Font = New-Object System.Drawing.Font("Verdana",32)
# Подписи к текстовым полям
$ServerTextBoxLabel.Location = New-Object System.Drawing.Point(10,12)
$ServerTextBoxLabel.Text = "Список серверов"
$ServerTextBoxLabel.Autosize = 1
$UserTextBoxLabel.Location = New-Object System.Drawing.Point(10,42)
$UserTextBoxLabel.Text = "Список пользователей"
$UserTextBoxLabel.Autosize = 1
$MessageTextBoxLabel.Location = New-Object System.Drawing.Point(10,73)
$MessageTextBoxLabel.Text = "Сообщение"
$MessageTextBoxLabel.Autosize = 1
# Плюшка в виде красивой подсказки, делается другим методом вызова, поэтому идет к каждому обьекту в блоке, чтобы не теряться.
$ToolTip.SetToolTip($MessageTextBoxLabel, "Надо подписаться, а то в заголовке окна с сообщениями не видно")
$SignTextBoxLabel.Location = New-Object System.Drawing.Point(10,103)
$SignTextBoxLabel.Text = "Подпись"
$SignTextBoxLabel.Autosize = 1
$ToolTip.SetToolTip($SignTextBoxLabel, "Надо подписаться, а то в заголовке окна с сообщениями не видно")
# Описание текстбокса
# Позиция
$ServerTextBox.Location = New-Object System.Drawing.Point(140,10)
# Источник данных
$ServerTextBox.DataSource = $Server
# Размер
$ServerTextBox.Width = 300
# Обработка события - при смене текста в поле, присваиваем переменной новое полученное значение.
$ServerTextBox.add_TextChanged({ $Server = $ServerTextBox.Text })
# индекс порядка перехода по Tab
$ServerTextBox.TabIndex = 1
$ToolTip.SetToolTip($ServerTextBox, "Укажите список серверов")
$UserTextBox.Location = New-Object System.Drawing.Point(140,40)
$UserTextBox.DataSource = $User
# Не забываем про массив
$UserTextBox.Text = $User[1]
$UserTextBox.add_TextChanged({ $User = $UserTextBox.Text })
$UserTextBox.Width = 300
$UserTextBox.TabIndex = 2
$ToolTip.SetToolTip($UserTextBox, "Кому отправлять будем? (* для *всех* пользователей, по умолчанию)")
# Поле сообщения
$MessageTextBox.Location = New-Object System.Drawing.Point(140,70)
$MessageTextBox.Text = $Message
# По клику в поле ввода - автоматически выделяем весь текст, чтобы не надо было
# нажимать удаление
$MessageTextBox.add_click({ $MessageTextBox.SelectAll() })
$MessageTextBox.add_TextChanged( { $Message = $MessageTextBox.Text })
$MessageTextBox.Width = 300
$MessageTextBox.TabIndex = 3
$ToolTip.SetToolTip($MessageTextBox, "И шо мы таки хотим сказать?")
# Поле подписи - отправляемая переменная уже другая
$SignTextBox.Location = New-Object System.Drawing.Point(140,103)
# Источник текста для подписи
$SignTextBox.DataSource = $Sign
# А мы помним, что там массив?:)
$SignTextBox.Text = $Sign[1]
$SignTextBox.add_TextChanged({ $SignX = $SignTextBox.Text })
$SignTextBox.Width = 300
$SignTextBox.TabIndex = 4
$ToolTip.SetToolTip($SignTextBox, "Страна должна знать своих героев")
# Нопка отправки.
$SendButton.Location = New-Object System.Drawing.Point(10,150)
$SendButton.Text = "Отправить сообщение"
# Выполняем разделения строк на массивы с разделителем запятая, вызываем функцию отправки сообщения
$SendButton.add_click({ $User = $UserTextBox.Text.Split(","); $Server = $ServerTextBox.Text.Split(","); $SignX = $SignTextBox.Text; SendMessage $Server $User $Message $SignX} )
$SendButton.Autosize = 1
$SendButton.TabIndex = 5
$ToolTip.SetToolTip($SendButton, "Тыцни пимпочку")
# Прописываем блокировочный чекбокс
$TestRunCheckBox.Location = New-Object System.Drawing.Point(200,150)
$TestRunCheckBox.Text = "Тест"
$TestRunCheckBox.Checked = 1
$TestRunCheckBox.AutoSize = 1
$TestRunCheckBox.TabIndex = 6
$ToolTip.SetToolTip($TestRunCheckBox, "Сними меня, а то работать не будет")
# Кнопочка выхода, по событию вызывает метод закрытия
$CloseButton.Location = New-Object System.Drawing.Point(315,150)
$CloseButton.Text = "Выйти из программы"
$CloseButton.add_click({ $MainSendWindow.Close() })
$CloseButton.Autosize = 1
$CloseButton.TabIndex = 7
$ToolTip.SetToolTip($CloseButton, "Пойдем ка отсюда")
# Добавляем контролы в форму и вызываем её запуск
$MainSendWindow.Controls.Add($SendButton)
$MainSendWindow.Controls.Add($TestRunCheckBox)
$MainSendWindow.Controls.Add($CloseButton)
$MainSendWindow.Controls.Add($ServerTextBox)
$MainSendWindow.Controls.Add($UserTextBox)
$MainSendWindow.Controls.Add($MessageTextBox)
$MainSendWindow.Controls.Add($SignTextBox)
$MainSendWindow.Controls.Add($ServerTextBoxLabel)
$MainSendWindow.Controls.Add($UserTextBoxLabel)
$MainSendWindow.Controls.Add($MessageTextBoxLabel)
$MainSendWindow.Controls.Add($SignTextBoxLabel)
$MainSendWindow.ShowDialog() | Out-Null
```
В результате получилась вот такая вот красивость
Скрипт могу выложить, при желании читателей, куда-то.
Не уверен, что хватит кармы публировать в профильный, поэтому выложил сюда
[Исходник скрипта на GitHub'е](https://github.com/foxmuldercp/shell_scripts/blob/master/PowerShell/SendNetworkMessageByRDP.ps1) | https://habr.com/ru/post/138008/ | null | ru | null |
# Преобразование черно-белых изображений в ASCII-графику при помощи неотрицательного матричного разложения
В общем случае преобразование изображения в ASCII-графику представляет собой довольно трудоемкую задачу, однако существуют алгоритмы, позволяющие автоматизировать данный процесс. В данной статье рассматривается подход, предложенный исследователями Paul D. O’Grady и Scott T. Rickard в работе [«Automatic ASCII Art Conversion of Binary Images Using Non-Negative Constraints»](https://pdfs.semanticscholar.org/07c5/05835924016de7a8cfd3cb6e2de1fb143388.pdf). Описанный ими метод предполагает представление процесса преобразования изображения как задачи оптимизации и решение этой задачи при помощи неотрицательного матричного разложения. Ниже приведены описание рассматриваемого алгоритма, а также его реализация:
Описание алгоритма
------------------
Исходное изображение разбивается на блоки размером , где  и  — ширина и высота одного символа в пикселях. Если ширина\высота изображения не кратна ширине\высоте символа, то картинка обрезается или дополняется белыми областями нужного размера.
Каждый из  блоков, полученных после разбиения, представляется в виде вектора длиной , значениями которого являются интенсивности цвета пикселей изображения (значения от 0 до 255, где белому пикселю соответствует значение 0, а черному — 255). Полученные векторы следует нормировать, используя норму :
Нормированные векторы переписываются в виде столбцов, образуя таким образом матрицу  размером .
Полученную матрицу  нужно представить в виде произведения матриц  и , все элементы которых неотрицательны:
Матрица  известна заранее: она строится аналогично матрице , но вместо участков исходной картинки используются изображения всех символов, используемых при генерации ASCII-графики. Если применяемый набор включает в себя  символов, то матрица  будет иметь размер .
Остается лишь подобрать матрицу  таким образом, чтобы минимизировать значение некоторой целевой функции, характеризующей разницу между  и произведением . В качестве такой функции используется следующая зависимость:
![D(V,W,H,\beta)=\sum_{ik}\bigg({v_{ik}\frac{v_{ik}^{\beta-1}-[WH]^{\beta-1}_{ik}}{\beta(\beta-1)}}+[WH]^{\beta-1}_{ik}\frac{[WH]_{ik}-v_{ik}}{\beta}\bigg)](https://habrastorage.org/getpro/habr/post_images/35d/fe5/834/35dfe58346bb38035eb7f9f1e5c0cc2d.svg)
Данное выражение по сути объединяет в себе несколько целевых функций: при  оно преобразуется в квадрат евклидова расстояния (Squared Euclidean Distance), при  приближается к расстоянию Кульбака-Лейблера (Kullback-Leibler Divergence), а при  — к расстоянию Итакуры-Сайто (Itakura-Saito Divergence).
Непосредственно подбор матрицы  производится следующим образом:  инициализируется случайными значениями от 0 до 1, после чего ее значения итеративно обновляются согласно следующему правилу (количество итераций задается заранее):
![h_{jk}=h_{jk}\frac{\sum^R_{i=1}{w_{ij}\frac{v_{ik}}{[WH]^{2-\beta}_{ik}}}}{\sum^R_{i=1}{w_{ij}[WH]^{\beta-1}_{ik}}}](https://habrastorage.org/getpro/habr/post_images/ce2/ab9/9ba/ce2ab99baf9cf808d44be37992988bd9.svg)
Каждое значение  соответствует степени схожести -го символа из используемого набора с -м участком изображения.
Таким образом, чтобы определить, каким символом следует заменить -й участок, достаточно найти максимальное значение в -м столбце матрицы . Номер строки, в котором располагается данное значение, и будет номером искомого символа в наборе. Кроме того, можно ввести некоторое пороговое значение , и если найденное максимальное значение меньше этого порога, то участок изображения заменяется пробелом. Использование пробела может положительно сказаться на виде результирующего изображения по сравнению с использованием символа с низкой степенью схожести.
Реализация
----------
Реализация алгоритма выполнена на языке C#. Для генерации ASCII-графики используются 95 символов (от 0x20 до 0x7E) размером 11x23 пикселей; применяемый шрифт — Courier. Ниже представлен исходный код функции преобразования исходного изображения в ASCII-графику:
```
public static char[,] ConvertImage(
Bitmap image,
double beta,
double threshold,
ushort iterationsCount,
ushort threadsNumber,
Action ProgressUpdated)
{
int charNumHor = (int)Math.Round((double)image.Width / glyphWidth);
int charNumVert = (int)Math.Round((double)image.Height / glyphHeight);
int totalCharactersNumber = charNumVert \* charNumHor;
int glyphSetSize = wNorm.ColumnCount;
Matrix v = SplitImage(image, charNumVert, charNumHor);
Matrix h = Matrix.Build.Random(
glyphSetSize,
totalCharactersNumber,
new ContinuousUniform());
int progress = 0;
ushort step = (ushort)(iterationsCount / 10);
for (ushort i = 0; i < iterationsCount; i++)
{
UpdateH(v, wNorm, h, beta, threadsNumber);
if((i + 1) % step == 0)
{
progress += 10;
if(progress < 100)
{
ProgressUpdated(progress);
}
}
}
var result = GetAsciiRepresentation(h, charNumVert, charNumHor, threshold);
ProgressUpdated(100);
return result;
}
```
Рассмотрим каждый ее шаг по отдельности:
1) Вычислим, какое количество символов можно уместить по ширине и по высоте изображения:
```
int charNumHor = (int)Math.Round((double)image.Width / glyphWidth);
int charNumVert = (int)Math.Round((double)image.Height / glyphHeight);
```
Используя рассчитанные значения, разобьем исходное изображение на блоки необходимого размера. Для каждого блока запишем значения интенсивности цвета пикселей в соответствующий столбец матрицы  (при необходимости расширим исходное изображение, добавив в матрицу нулевые значения, соответствующие белым пикселям), после чего нормализуем все столбцы:
```
private static Matrix SplitImage(
Bitmap image,
int charNumVert,
int charNumHor)
{
Matrix result = Matrix.Build.Dense(
glyphHeight \* glyphWidth,
charNumHor \* charNumVert);
for (int y = 0; y < charNumVert; y++)
{
for (int x = 0; x < charNumHor; x++)
{
for (int j = 0; j < glyphHeight; j++)
{
for (int i = 0; i < glyphWidth; i++)
{
byte color = 0;
if ((x \* glyphWidth + i < image.Width) &&
(y \* glyphHeight + j < image.Height))
{
color = (byte)(255 - image.GetPixel(
x \* glyphWidth + i,
y \* glyphHeight + j).R);
}
result[glyphWidth \* j + i, charNumHor \* y + x] = color;
}
}
}
}
result = result.NormalizeColumns(2.0);
return result;
}
```
2) Заполним матрицу  случайными значениями от 0 до 1:
```
Matrix h = Matrix.Build.Random(
glyphSetSize,
totalCharactersNumber,
new ContinuousUniform());
```
Применим к ее элементам правило обновления заданное количество раз:
```
for (ushort i = 0; i < iterationsCount; i++)
{
UpdateH(v, wNorm, h, beta, threadsNumber);
if((i + 1) % step == 0)
{
progress += 10;
if(progress < 100)
{
ProgressUpdated(progress);
}
}
}
```
Непосредственно обновление элементов матрицы реализовано следующим образом (к сожалению, проблемы, связанные с делением на ноль, решаются при помощи некоторых костылей):
```
private static void UpdateH(
Matrix v,
Matrix w,
Matrix h,
double beta,
ushort threadsNumber)
{
const double epsilon = 1e-6;
Matrix vApprox = w.Multiply(h);
Parallel.For(
0,
h.RowCount,
new ParallelOptions() { MaxDegreeOfParallelism = threadsNumber },
j =>
{
for (int k = 0; k < h.ColumnCount; k++)
{
double numerator = 0.0;
double denominator = 0.0;
for (int i = 0; i < w.RowCount; i++)
{
if (Math.Abs(vApprox[i, k]) > epsilon)
{
numerator +=
w[i, j] \* v[i, k] / Math.Pow(vApprox[i, k], 2.0 - beta);
denominator +=
w[i, j] \* Math.Pow(vApprox[i, k], beta - 1.0);
}
else
{
numerator += w[i, j] \* v[i, k];
if (beta - 1.0 > 0.0)
{
denominator +=
w[i, j] \* Math.Pow(vApprox[i, k], beta - 1.0);
}
else
{
denominator += w[i, j];
}
}
}
if (Math.Abs(denominator) > epsilon)
{
h[j, k] = h[j, k] \* numerator / denominator;
}
else
{
h[j, k] = h[j, k] \* numerator;
}
}
});
}
```
3) Последний шаг состоит в выборе для каждого участка изображения подходящего символа путем нахождения максимальных значений в столбцах матрицы :
```
private static char[,] GetAsciiRepresentation(
Matrix h,
int charNumVert,
int charNumHor,
double threshold)
{
char[,] result = new char[charNumVert, charNumHor];
for (int j = 0; j < h.ColumnCount; j++)
{
double max = 0.0;
int maxIndex = 0;
for (int i = 0; i < h.RowCount; i++)
{
if (max < h[i, j])
{
max = h[i, j];
maxIndex = i;
}
}
result[j / charNumHor, j % charNumHor] =
(max >= threshold) ? (char)(firstGlyphCode + maxIndex) : ' ';
}
return result;
}
```
Полученное изображение записывается в html-файл. Полный исходный код программы можно найти [тут](https://github.com/vihmp/AsciiArtGenerator).
Примеры сгенерированных изображений
-----------------------------------
Ниже представлены примеры изображений, сгенерированных при различных значениях параметра  и количествах итераций. Исходное изображение имело размер 407x500 пикселей, соответственно результирующие изображения имели размер 37x22 символов.
Заключение
----------
В рассматриваемом алгоритме можно выделить следующие недостатки:
1. Долгая обработка изображений: в зависимости от размера картинки и количества итераций ее обработка может занимать от нескольких десятков секунд до нескольких десятков минут.
2. Низкое качество обработки детализированных изображений. Например, попытка преобразования изображения человеческого лица дает следующий результат:
В то же время уменьшение количества деталей за счет увеличения яркости и контрастности изображения позволяет значительно улучшить вид результирующего изображения:
В целом несмотря на перечисленные недостатки можно сделать вывод о том, что алгоритм дает удовлетворительные результаты. | https://habr.com/ru/post/463193/ | null | ru | null |
# Настройка окружения для сборки и тестирования приложения в закрытом периметре
Добрый день, хаброчитатели.
Снова хочу поделиться с вами небольшими практическими наработками.
Совсем недавно в рамках одного проекта мне была поставлена задача подготовить для команды тестеров стандартное окружение для сборки и тестирования приложения (Jenkins + SVN + Maven).
Все тесты должны проводиться в частной виртуальной сети, доступ в которую организован через впн-соединение.
Сервер, на котором производится установка выхода в интернет не имеет.
Прав на установку чего-либо заказчик решил не выдавать в целях безопасности. И по той же причине из доступных портов были только 22 и 8080.
Не густо, но, как выяснилось, вполне достаточно.
Первым делом выкачиваем себе локально последнюю версию [Apache-Tomcat](http://apache-mirror.telesys.org.ua/tomcat/tomcat-7/v7.0.39/bin/apache-tomcat-7.0.39.tar.gz) и [Jenkins](http://mirrors.jenkins-ci.org/war/latest/jenkins.war).
Потом по scp заливаем архив и jenkins.war на наш сервер.
Распаковываем архив и помещаем jenkins.war в папку /path/to/my/home/apache-tomcat/webapps.
Пробуем запускать:
```
/path/to/my/home/apache-tomcat/bin/startup.sh
Using CATALINA_BASE: /path/to/my/home/apache-tomcat
Using CATALINA_HOME: /path/to/my/home/apache-tomcat
Using CATALINA_TMPDIR: /path/to/my/home/apache-tomcat/temp
Using JRE_HOME: /usr/java/latest
Using CLASSPATH: /path/to/my/home/apache-tomcat/bin/bootstrap.jar:/path/to/my/home/apache-tomcat/bin/tomcat-juli.jar
```
Проверяем, что Jenkins стартовал корректно по ссылке [your\_server\_ip](http://your_server_ip):8080/jenkins
Теперь нужно реализовать работу svn ( в моей случае это Subversion, который идёт в поставке с redhat) через Tomcat.
После некоторого поиска готовых решений нашёл [SCM Manager](http://www.scm-manager.org/).
Выкачиваем последнюю версию [SCM WebApp](http://maven.scm-manager.org/nexus/content/repositories/releases/sonia/scm/scm-webapp/1.30/scm-webapp-1.30.war) и заливаем её по scp на сервер в папку /path/to/my/home/apache-tomcat/webapps.
Делаем рестарт Tomcat.
Идём знакомиться с SCM Manager по ссылке [your\_server\_ip](http://your_server_ip):8080/scm-webapp-1.30.
Стандартные логин/пароль — scmadmin/scmadmin.
Функционал приятно порадовал. Приложение умеет работать с SVN и GIT.
Меню простое и понятное.
Создаём пользователя с правами «READ» для использования его в задачах Jenkins.
Создаём репозиторий.
Даём доступ пользователю в репозиторий.
Смотрим какой url у нашего репозитория и пробуем сделать checkout.
```
sandro@sandro-VirtualBox:~/myrepo$ svn checkout http://jenkins@your_server_ip:8080/scm-webapp-1.30/svn/myrepo
Authentication realm: SONIA :: SCM Manager
Пользователь: jenkins
Пароль для 'jenkins':
Получена редакция 0.
```
Maven устанавливаем по той же схеме.
Выкачиваем локально пакет [Apache-Maven](http://apache-mirror.telesys.org.ua/maven/maven-3/3.0.5/binaries/apache-maven-3.0.5-bin.tar.gz), отправляем его по scp на сервер и там распаковываем.
Так как у сервера выхода в интернет нет, то нужно сразу позаботиться о наличии всех зависимостей сборки локально на сервере.
Для этого я просто попросил одного из тестеров приложения дать мне архив его локального репозитория (для тех, кто не знаком с maven, это папка .m2).
Этот архив я также отправил по scp на сервер и там распаковал.
Настраиваем maven на использование локального репозитория:
Открываем maven/conf/settings.xml, находим и приводим к следующему виду строки:
```
/path/to/my/home/.m2/repository
true
```
Настраиваем Jenkins на использование нашего Maven.
Для этого открываем вкладку «Настроить Jenkins» -> «Конфигурирование системы»
На этом конфигурирование завершено. Окружение готово к работе. | https://habr.com/ru/post/176719/ | null | ru | null |
# Как я участвовал в IOCCC-'19 (и проиграл). Часть 2: «Симулятор NOR»
Это вторая часть цикла статей о том, как я участвовал в IOCCC'19
1. [Как я участвовал в IOCCC-'19 (и проиграл). Часть 1: «Крестики-нолики»](https://habr.com/ru/post/505044/)
2. [Как я участвовал в IOCCC-'19 (и проиграл). Часть 2: «Симулятор NOR»](#)
Я надеюсь, что данная статья поможет вам при разборе чужого кода или кода после декомпилятора или обфускатора.
Если вы еще не знаете, что такое IOCCC или вы хотите ознакомиться с более простым вариантом запутанного кода, то рекомендую обратиться к первой части.
Всем остальным я желаю приятного чтения.
Все исходники помещены на [github](https://github.com/codemeow/ioccc2020/tree/master/nor), откуда их можно невозбранно скачать и попробовать скомпилировать.
### Исходные данные
Так как исходный код в текстовом виде можно найти по ссылке, покажу как код выглядит графически:
Традиционно сложилось, что «дополнительные баллы» даются, если код отформатирован нестандартно или выглядит как какое-то изображение. Что ж, будем считать, это с этим здесь всё в порядке.
Но что же делает программа?
Она инициализирует графический стек X-сервера, сканирует предоставленный файл конфигурации, рисует электрическую схему согласно файлу и запускает симуляцию, поочередно меняя полярность на 4 ножках входа, используя при этом только NOR (Not-OR) элементы. Отрисовка происходит с шейдером старого LCD-экрана.
В комплекте с программой идут несколько конфигурационных файлов, а именно:
#### DIP8-4packnot.txt — примерный аналог CMOS 4041/Четырехканальный инвертор
(изображение сжато в 2 раза, чтобы уместиться в рамки приличия. На самом деле забавно, что программа, весом в 3.5 КБ генерирует ряд изображений, который в максимальном сжатии занимают 10.5+МБ)
#### DIP8-triplexor.txt — примерный аналог CMOS 4030 с объединенными входами и тремя каналами/Трехканальный XOR-gate с объединенными входами
#### DIP8-fulladder.txt — примерный аналог CMOS 4008, но на два бита/сумматор на 2 бита с выводом бита переноса
### Разбор кода
Самой сложной задачей в этот раз было уместиться в ограничение по размеру присылаемой работы. Ограничен не только размер файла, но и количество условных «токенов» — символов операций, ключевых слов языка и пар скобок. Именно для того, чтобы «заэксплойтить» эту особенность парсера-проверяльщика размера в программе объявлено огромное количество define'ов, приводящих блоки кода к одному ключевому слову языка С.
Для начала, заглянем в Makefile, чтобы понять, как код собирается:
```
#!/usr/bin/env make
PROJECT=prog
CC= gcc
SRC=prog.c
CWARN=-Wall -Wextra -Wno-char-subscripts
CSTD= -std=c99
# Syscalls table
# DS - syscall nanosleep
# DO - syscall open
# DR - syscall read
# DC - syscall close
# X11 structures offsets
# dS - offset of screens in Display
# dR - offset of root in Screen
# dD - offset of root_depth in Screen
# dV - offset of root_visual in Screen
# dG - offset of default_gc in Screen
BITS := $(shell uname -p)
ifeq ($(BITS), x86_64)
ARCH= -m64
CDEFINE= -DDS=35 -DDO=2 -DDR=0 -DDC=3 -DdS=232 -DdR=16 -DdD=56 -DdV=64 -DdG=72
else
ARCH= -m32
CDEFINE= -DDS=162 -DDO=5 -DDR=3 -DDC=6 -DdS=140 -DdR=8 -DdD=36 -DdV=40 -DdG=44
endif
OPT= -g
CFLAGS= ${CWARN} ${CSTD} ${ARCH} ${CDEFINE} ${OPT}
LDFLAGS= -ldl
RM= rm
all: ${PROJECT}
${PROJECT}:
${CC} ${CFLAGS} ${SRC} -o $@ ${LDFLAGS}
clean:
${RM} -f ${PROJECT}
```
Как видим, эта работа, так же, как и предыдущая активно использует системные вызовы, чтобы избежать уродливых "#include", которые нарушают узор картинки. Запомним этот факт и подготовим строку для препроцессора и линтера:
**После препроцессора**
```
gcc -DDS=35 -DDO=2 -DDR=0 -DDC=3 -DdS=232 -DdR=16 -DdD=56 -DdV=64 -DdG=72 prog.c -ldl -E | indent -kr -brf > /tmp/fmt.c
```
```
int _x[] = { 15117427, 8413248, 5878632, 13027014, 1 };
extern void *dlsym(void *, char *);
int x_[616][1220];
extern long syscall(long, ...);
extern void *dlopen(char *, int);
char m[19][20], _n[] =
"pu~D--2os" "<<<<<<<<" "<<= 19 || y >= 19 || x < 0 || y < 0) || (m[y][x] == l)
|| (m[y][x] != c))
return;
m[y][x] = l;
b(t, x - 1, y, c, l);
b(t, x + 1, y, c, l);
b(t, x, y - 1, c, l);
b(t, x, y + 1, c, l);
}
void e(int t, int x, int y, int c, int l) {
if ((x >= 64 || y >= 40 || x < 0 || y < 0) || (\_[t][y][x] == l)
|| (\_[t][y][x] != c))
return;
\_[t][y][x] = l;
e(t, x - 1, y, c, l);
e(t, x + 1, y, c, l);
e(t, x, y - 1, c, l);
e(t, x, y + 1, c, l);
}
void k(int t, int x, int y, int c, int l) {
while (c--) {
\_[t][y][x++] = l;
\_[t][y++][x++] = l;
}
}
void r(int t, int x, int y, int c, int l) {
while (c--) {
\_[t][y][x--] = l;
\_[t][y++][x--] = l;
}
}
void u(int t, int x, int y, int c, int l) {
while (c--)
\_[t][y++][x] = l;
}
char \*z[8] = {
(char[]) {4},
(char[]) {6, 1 \* 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16, 0, 0,
21 + 0 \* 3 - 0, 16, 1, 63, 21 + 0 \* 3 - 0, 16, 2,
63 \* 0, 21 - 0, 4, 2, 31 + 0, 36 - 0, 4, 0 + 1,
32 - 1, 5 - 0, 16, 0, 0, 21 + 1 \* 3 - 0, 16, 1, 63,
21 + 1 \* 3 - 0, 16, 2, 63 \* 1, 21 - 0, 4, 2, 31 + 1,
36 - 0, 4, 6, 1 \* 4 + 0, 3, 31, 8 - 0, 6, 1 \* 4 + 2,
3, 33, 38 - 0, 6, 1 \* 4 + 3, 3, 30, 38 - 0, 4},
(char[]) {5, 1},
(char[]) {6, 0 \* 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16,
0, 0, 21 + 0 \* 3 - 0, 16, 1, 63,
21 + 0 \* 3 - 0, 16, 2, 63 \* 0, 21 - 0,
4, 2, 31 + 0, 36 - 0, 4, 0 + 1, 32 - 1,
5 - 0, 16, 0, 0, 21 + 1 \* 3 - 0, 16, 1,
63, 21 + 1 \* 3 - 0, 16, 2, 63 \* 1,
21 - 0, 4, 2, 31 + 1, 36 - 0, 4, 6,
0 \* 4 + 0, 3, 31, 8 - 0, 6, 0 \* 4 + 2,
3, 33, 38 - 0, 6, 0 \* 4 + 3, 3, 30,
38 - 0,
4},
(char[]) {4}, (char[]) {4},
(char[]) {6, 2 \* 4 + 1, 0 + 0, 32 - 0, 5 - 3, 16, 0, 0,
21 + 0 \* 3 - 3, 16, 1, 63, 21 + 0 \* 3 - 3, 16, 2, 63 \* 0,
21 - 3, 4, 2, 31 + 0, 36 - 3, 4, 0 + 1, 32 - 1, 5 - 3,
16, 0, 0, 21 + 1 \* 3 - 3, 16, 1, 63, 21 + 1 \* 3 - 3, 16,
2, 63 \* 1, 21 - 3, 4, 2, 31 + 1, 36 - 3, 4, 6, 2 \* 4 + 0,
3, 31, 8 - 3, 6, 2 \* 4 + 2, 3, 33, 38 - 3, 6, 2 \* 4 + 3,
3, 30, 38 - 3, 4},
(char[]) {6, 13, 0, 32, 9 + 0, 12 - 0,
0, 8 + 0 + 0, 21, 12 - 0, 1,
31, 9 + 0, 12 - 0, 1,
55 - 0 - 0, 21, 12 - 0, 0,
32, 9 + 3, 12 - 3, 0,
8 + 3 + 3, 21, 12 - 3, 1,
31, 9 + 3, 12 - 3, 1,
55 - 3 - 3, 21, 12 - 3, 6,
14 + 0, 2, 31 + 0, 13, 4,
1 - 0, 31 + 0, 16, 7, 3,
30 + 3 \* 0, 14, 6,
12 + 0 \* 4, 3, 32 - 0,
11 + 0 \* 8, 6, 14 + 1, 2,
31 + 1, 13, 4, 1 - 1,
31 + 1, 16, 7, 3,
30 + 3 \* 1, 14, 6,
12 + 1 \* 4, 3, 32 - 1,
11 + 1 \* 8,
4}
};
void d\_(int t, int p, int q) {
for (int y = 0; y < 40; y++)
for (int x = 0; x < 64; x++)
if (\_[t]
[y][x])
x\_[y + q \* 16 + p \* 16][x + 580 + p \* 32 - q \*
32] = \_[t][y][x];
}
int main(int a, char \*s[]) {
int h = 127;
while (h--) {
\_n[h] ^= 28;
\_n[h] -= (\_n[h] == 32 ? 32 : 0);
}
T = dlopen(\_n, 2);
d = ((void \*(\*)()) dlsym(T, \_n + (1 \* 20))) (0);
w = ((long (\*)()) dlsym(T, \_n + (2 \* 20))) (d,
(\*(long \*)
((char
\*) (\*(long \*) ((char \*)
d +
232)) +
16))
, 0, 0, 1220, 616, 1, 0,
0);
M = ((void \*(\*)()) dlsym(T, \_n + (3 \* 20))) (d,
(\*(long \*)
((char
\*) (\*(long \*) ((char \*)
d +
232)) +
64)),
(\*(long \*)
((char
\*) (\*(long \*) ((char \*)
d +
232)) +
56)), 2, 0, (char \*) x\_,
1220, 616, 32, 0);
for (int i = 0; i < 8; i++) {
char \*p = z[i];
int c = 0;
while (\*p != 4) {
switch (\*p) {
case 0:
k(i, p[1], p[2], p[3], c);
p += 4;
break;
case 1:
r(i, p[1], p[2], p[3], c);
p += 4;
break;
case 2:
u(i, p[1], p[2], p[3], c);
p += 4;
break;
case 3:
e(i, p[1]
, p[2], 0, c);
p += 3;
break;
case 5:
p = z[p[1]];
break;
case 6:
c = \_x[p[1] / 4] - 1643277 \* (p[1] % 4);
p += 2;
break;
}
}
}
while (a++) {
int f = syscall(2, s[1], 0);
syscall(0, f, m, 380);
syscall(3, f);
for (int y = 0; y < 19; y++)
for (int x = 0; x < 19; x++)
if ((x % 14 == 2) && (y % 4 == 3))
m[y][x] = 46;
b(0, 2, 3, m[3][2], a & 1 ? 43 : 45);
b(0, 2, 7, m[7][2], a & 2 ? 43 : 45);
b(0, 2, 11, m[11][2], a & 4 ? 43 : 45);
b(0, 2, 15, m[15][2], a & 8 ? 43 : 45);
for (int i = 0; i < 20; i++)
for (int y = 0; y < 19; y++)
for (int x = 0; x < 19; x++)
if (m[y][x] == 62)
b(0, x + 1, y, m[y][x + 1],
!(m[y - 1][x] == 43 ? 1 : 0
|| m[y + 1][x] == 43 ? 1 : 0) ? 43 : 45);
for (int y = 0; y < 616; y++)
for (int x = 0; x < 1220; x++)
x\_[y][x] = 0;
for (int y = 0; y < 19; y++)
for (int x = 0; x < 19; x++)
d\_(((m[y][x] >> 4) & 1) << 2 | (m[y][x] & 3), x, y);
for (int y = 0; y < 19; y++)
for (int x = 0; x < 19; x++)
if ((x % 14 == 2) && (y % 4 == 3))
d\_(7, x, y);
for (int y = 0; y < 616; y++)
for (int x = 0; x < 1220; x++) {
x\_[y][x] &= 14737632 | (31 << ((x % 3) << 3));
x\_[y][x] += 986895 & (rn \*= 16777619);
} ((long (\*)()) dlsym(T, \_n + (4 \* 20))) (d, w,
(\*(long \*)
((char
\*) (\*(long
\*) ((char \*)
d +
232)) +
72)), M, 0, 0, 0,
0, 1220, 616);
((long (\*)()) dlsym(T, \_n + (5 \* 20))) (d, w);
((long (\*)()) dlsym(T, \_n + (6 \* 20))) (d);
syscall(35, &N, &R);
} return 0;
}
```
Что ж, по крайней мере одно из условий конкурса мы выполнили, код после препроцессора понятнее не стал.
Начнем с того, что можно выловить с первого взгляда и попытаемся восстановить цепочку событий.
#### dlsym\dlopen
Очевидно, что чтобы воспользоваться функциями X-сервера и создать окно, а затем в нем что-то отрисовать код должен обратиться к библиотеке XLib. В коде присутствуют функции dlopen/dlsym, позволяющие динамически подгрузить библиотеку, однако на вход им подается какая-то хитрая каша:
```
char _n[] =
"pu~D--2os" "<<<<<<<<" "<<
```
Пройдем на шаг назад и проинспектируем следующий код:
```
int h = 127;
while (h--) {
_n[h] ^= 28;
_n[h] -= (_n[h] == 32 ? 32 : 0);
}
```
Судя по всему, он некоторым образом преобразует исходный массив, позволяя нам получить читаемые строки. Выполним его отдельно:
<https://onlinegdb.com/SJNM9Og7v>:
```
libX11.so
XOpenDisplay
XCreateSimpleWindow
XCreateImage
XPutImage
XMapWindow
XFlush
```
Для того, чтобы одной строкой вызывать столь различные по формату функции код эксплуатирует тот факт, что в стандарте языка С (void) означает отсутствие параметров, а () — любое число параметров. Остается только привести полученный void \* к соответствующему ((long (\*)()) типу и вуаля:
```
w = ((long (*)()) dlsym(T, _n + (2 * 20))) (d, (*(long *)((char *) (*(long *)((char *) d + 232)) + 16))
```
Зная, что эти преобразования означают теперь мы можем заменить столь необычное использование dlsym сначала на строки:
**После замены строк:**
```
int _x[] = { 15117427, 8413248, 5878632, 13027014, 1 };
extern void *dlsym(void *, char *);
int x_[616][1220];
extern long syscall(long, ...);
extern void *dlopen(char *, int);
char m[19][20];
long w, N[2] = { 0, 1 << 29 };
int rn = 2166136261, _[8][40][64] = { 0 };
long R[2];
void *M, *d, *T;
void b(int t, int x, int y, int c, int l) {
if ((x >= 19 || y >= 19 || x < 0 || y < 0) || (m[y][x] == l)
|| (m[y][x] != c))
return;
m[y][x] = l;
b(t, x - 1, y, c, l);
b(t, x + 1, y, c, l);
b(t, x, y - 1, c, l);
b(t, x, y + 1, c, l);
}
void e(int t, int x, int y, int c, int l) {
if ((x >= 64 || y >= 40 || x < 0 || y < 0) || (_[t][y][x] == l)
|| (_[t][y][x] != c))
return;
_[t][y][x] = l;
e(t, x - 1, y, c, l);
e(t, x + 1, y, c, l);
e(t, x, y - 1, c, l);
e(t, x, y + 1, c, l);
}
void k(int t, int x, int y, int c, int l) {
while (c--) {
_[t][y][x++] = l;
_[t][y++][x++] = l;
}
}
void r(int t, int x, int y, int c, int l) {
while (c--) {
_[t][y][x--] = l;
_[t][y++][x--] = l;
}
}
void u(int t, int x, int y, int c, int l) {
while (c--)
_[t][y++][x] = l;
}
char *z[8] = {
(char[]) {4},
(char[]) {6, 1 * 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16, 0, 0,
21 + 0 * 3 - 0, 16, 1, 63, 21 + 0 * 3 - 0, 16, 2,
63 * 0, 21 - 0, 4, 2, 31 + 0, 36 - 0, 4, 0 + 1,
32 - 1, 5 - 0, 16, 0, 0, 21 + 1 * 3 - 0, 16, 1, 63,
21 + 1 * 3 - 0, 16, 2, 63 * 1, 21 - 0, 4, 2, 31 + 1,
36 - 0, 4, 6, 1 * 4 + 0, 3, 31, 8 - 0, 6, 1 * 4 + 2,
3, 33, 38 - 0, 6, 1 * 4 + 3, 3, 30, 38 - 0, 4},
(char[]) {5, 1},
(char[]) {6, 0 * 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16,
0, 0, 21 + 0 * 3 - 0, 16, 1, 63,
21 + 0 * 3 - 0, 16, 2, 63 * 0, 21 - 0,
4, 2, 31 + 0, 36 - 0, 4, 0 + 1, 32 - 1,
5 - 0, 16, 0, 0, 21 + 1 * 3 - 0, 16, 1,
63, 21 + 1 * 3 - 0, 16, 2, 63 * 1,
21 - 0, 4, 2, 31 + 1, 36 - 0, 4, 6,
0 * 4 + 0, 3, 31, 8 - 0, 6, 0 * 4 + 2,
3, 33, 38 - 0, 6, 0 * 4 + 3, 3, 30,
38 - 0,
4},
(char[]) {4}, (char[]) {4},
(char[]) {6, 2 * 4 + 1, 0 + 0, 32 - 0, 5 - 3, 16, 0, 0,
21 + 0 * 3 - 3, 16, 1, 63, 21 + 0 * 3 - 3, 16, 2, 63 * 0,
21 - 3, 4, 2, 31 + 0, 36 - 3, 4, 0 + 1, 32 - 1, 5 - 3,
16, 0, 0, 21 + 1 * 3 - 3, 16, 1, 63, 21 + 1 * 3 - 3, 16,
2, 63 * 1, 21 - 3, 4, 2, 31 + 1, 36 - 3, 4, 6, 2 * 4 + 0,
3, 31, 8 - 3, 6, 2 * 4 + 2, 3, 33, 38 - 3, 6, 2 * 4 + 3,
3, 30, 38 - 3, 4},
(char[]) {6, 13, 0, 32, 9 + 0, 12 - 0,
0, 8 + 0 + 0, 21, 12 - 0, 1,
31, 9 + 0, 12 - 0, 1,
55 - 0 - 0, 21, 12 - 0, 0,
32, 9 + 3, 12 - 3, 0,
8 + 3 + 3, 21, 12 - 3, 1,
31, 9 + 3, 12 - 3, 1,
55 - 3 - 3, 21, 12 - 3, 6,
14 + 0, 2, 31 + 0, 13, 4,
1 - 0, 31 + 0, 16, 7, 3,
30 + 3 * 0, 14, 6,
12 + 0 * 4, 3, 32 - 0,
11 + 0 * 8, 6, 14 + 1, 2,
31 + 1, 13, 4, 1 - 1,
31 + 1, 16, 7, 3,
30 + 3 * 1, 14, 6,
12 + 1 * 4, 3, 32 - 1,
11 + 1 * 8,
4}
};
void d_(int t, int p, int q) {
for (int y = 0; y < 40; y++)
for (int x = 0; x < 64; x++)
if (_[t]
[y][x])
x_[y + q * 16 + p * 16][x + 580 + p * 32 - q *
32] = _[t][y][x];
}
int main(int a, char *s[]) {
T = dlopen("libX11.so", 2);
d = ((void *(*)()) dlsym(T, "XOpenDisplay") (0);
w = ((long (*)()) dlsym(T, "XCreateSimpleWindow")) (d,
(*(long *)
((char
*) (*(long *) ((char *)
d +
232)) +
16))
, 0, 0, 1220, 616, 1, 0,
0);
M = ((void *(*)()) dlsym(T, "XCreateImage")) (d,
(*(long *)
((char
*) (*(long *) ((char *)
d +
232)) +
64)),
(*(long *)
((char
*) (*(long *) ((char *)
d +
232)) +
56)), 2, 0, (char *) x_,
1220, 616, 32, 0);
for (int i = 0; i < 8; i++) {
char *p = z[i];
int c = 0;
while (*p != 4) {
switch (*p) {
case 0:
k(i, p[1], p[2], p[3], c);
p += 4;
break;
case 1:
r(i, p[1], p[2], p[3], c);
p += 4;
break;
case 2:
u(i, p[1], p[2], p[3], c);
p += 4;
break;
case 3:
e(i, p[1]
, p[2], 0, c);
p += 3;
break;
case 5:
p = z[p[1]];
break;
case 6:
c = _x[p[1] / 4] - 1643277 * (p[1] % 4);
p += 2;
break;
}
}
}
while (a++) {
int f = syscall(2, s[1], 0);
syscall(0, f, m, 380);
syscall(3, f);
for (int y = 0; y < 19; y++)
for (int x = 0; x < 19; x++)
if ((x % 14 == 2) && (y % 4 == 3))
m[y][x] = 46;
b(0, 2, 3, m[3][2], a & 1 ? 43 : 45);
b(0, 2, 7, m[7][2], a & 2 ? 43 : 45);
b(0, 2, 11, m[11][2], a & 4 ? 43 : 45);
b(0, 2, 15, m[15][2], a & 8 ? 43 : 45);
for (int i = 0; i < 20; i++)
for (int y = 0; y < 19; y++)
for (int x = 0; x < 19; x++)
if (m[y][x] == 62)
b(0, x + 1, y, m[y][x + 1],
!(m[y - 1][x] == 43 ? 1 : 0
|| m[y + 1][x] == 43 ? 1 : 0) ? 43 : 45);
for (int y = 0; y < 616; y++)
for (int x = 0; x < 1220; x++)
x_[y][x] = 0;
for (int y = 0; y < 19; y++)
for (int x = 0; x < 19; x++)
d_(((m[y][x] >> 4) & 1) << 2 | (m[y][x] & 3), x, y);
for (int y = 0; y < 19; y++)
for (int x = 0; x < 19; x++)
if ((x % 14 == 2) && (y % 4 == 3))
d_(7, x, y);
for (int y = 0; y < 616; y++)
for (int x = 0; x < 1220; x++) {
x_[y][x] &= 14737632 | (31 << ((x % 3) << 3));
x_[y][x] += 986895 & (rn *= 16777619);
} ((long (*)()) dlsym(T, "XPutImage")) (d, w,
(*(long *)
((char
*) (*(long
*) ((char *)
d +
232)) +
72)), M, 0, 0, 0,
0, 1220, 616);
((long (*)()) dlsym(T, "XMapWindow")) (d, w);
((long (*)()) dlsym(T, "XFlush")) (d);
syscall(35, &N, &R);
} return 0;
}
```
А потом и на родные функции:
**После замены на ''родные'' функции:**
```
#include
int \_x[] = { 15117427, 8413248, 5878632, 13027014, 1 };
int x\_[616][1220];
extern long syscall(long, ...);
char m[19][20];
long w, N[2] = { 0, 1 << 29 };
int rn = 2166136261, \_[8][40][64] = { 0 };
long R[2];
void \*M, \*d, \*T;
void b(int t, int x, int y, int c, int l) {
if ((x >= 19 || y >= 19 || x < 0 || y < 0) || (m[y][x] == l)
|| (m[y][x] != c))
return;
m[y][x] = l;
b(t, x - 1, y, c, l);
b(t, x + 1, y, c, l);
b(t, x, y - 1, c, l);
b(t, x, y + 1, c, l);
}
void e(int t, int x, int y, int c, int l) {
if ((x >= 64 || y >= 40 || x < 0 || y < 0) || (\_[t][y][x] == l)
|| (\_[t][y][x] != c))
return;
\_[t][y][x] = l;
e(t, x - 1, y, c, l);
e(t, x + 1, y, c, l);
e(t, x, y - 1, c, l);
e(t, x, y + 1, c, l);
}
void k(int t, int x, int y, int c, int l) {
while (c--) {
\_[t][y][x++] = l;
\_[t][y++][x++] = l;
}
}
void r(int t, int x, int y, int c, int l) {
while (c--) {
\_[t][y][x--] = l;
\_[t][y++][x--] = l;
}
}
void u(int t, int x, int y, int c, int l) {
while (c--)
\_[t][y++][x] = l;
}
char \*z[8] = {
(char[]) {4},
(char[]) {6, 1 \* 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16, 0, 0,
21 + 0 \* 3 - 0, 16, 1, 63, 21 + 0 \* 3 - 0, 16, 2,
63 \* 0, 21 - 0, 4, 2, 31 + 0, 36 - 0, 4, 0 + 1,
32 - 1, 5 - 0, 16, 0, 0, 21 + 1 \* 3 - 0, 16, 1, 63,
21 + 1 \* 3 - 0, 16, 2, 63 \* 1, 21 - 0, 4, 2, 31 + 1,
36 - 0, 4, 6, 1 \* 4 + 0, 3, 31, 8 - 0, 6, 1 \* 4 + 2,
3, 33, 38 - 0, 6, 1 \* 4 + 3, 3, 30, 38 - 0, 4},
(char[]) {5, 1},
(char[]) {6, 0 \* 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16,
0, 0, 21 + 0 \* 3 - 0, 16, 1, 63,
21 + 0 \* 3 - 0, 16, 2, 63 \* 0, 21 - 0,
4, 2, 31 + 0, 36 - 0, 4, 0 + 1, 32 - 1,
5 - 0, 16, 0, 0, 21 + 1 \* 3 - 0, 16, 1,
63, 21 + 1 \* 3 - 0, 16, 2, 63 \* 1,
21 - 0, 4, 2, 31 + 1, 36 - 0, 4, 6,
0 \* 4 + 0, 3, 31, 8 - 0, 6, 0 \* 4 + 2,
3, 33, 38 - 0, 6, 0 \* 4 + 3, 3, 30,
38 - 0,
4},
(char[]) {4}, (char[]) {4},
(char[]) {6, 2 \* 4 + 1, 0 + 0, 32 - 0, 5 - 3, 16, 0, 0,
21 + 0 \* 3 - 3, 16, 1, 63, 21 + 0 \* 3 - 3, 16, 2, 63 \* 0,
21 - 3, 4, 2, 31 + 0, 36 - 3, 4, 0 + 1, 32 - 1, 5 - 3,
16, 0, 0, 21 + 1 \* 3 - 3, 16, 1, 63, 21 + 1 \* 3 - 3, 16,
2, 63 \* 1, 21 - 3, 4, 2, 31 + 1, 36 - 3, 4, 6, 2 \* 4 + 0,
3, 31, 8 - 3, 6, 2 \* 4 + 2, 3, 33, 38 - 3, 6, 2 \* 4 + 3,
3, 30, 38 - 3, 4},
(char[]) {6, 13, 0, 32, 9 + 0, 12 - 0,
0, 8 + 0 + 0, 21, 12 - 0, 1,
31, 9 + 0, 12 - 0, 1,
55 - 0 - 0, 21, 12 - 0, 0,
32, 9 + 3, 12 - 3, 0,
8 + 3 + 3, 21, 12 - 3, 1,
31, 9 + 3, 12 - 3, 1,
55 - 3 - 3, 21, 12 - 3, 6,
14 + 0, 2, 31 + 0, 13, 4,
1 - 0, 31 + 0, 16, 7, 3,
30 + 3 \* 0, 14, 6,
12 + 0 \* 4, 3, 32 - 0,
11 + 0 \* 8, 6, 14 + 1, 2,
31 + 1, 13, 4, 1 - 1,
31 + 1, 16, 7, 3,
30 + 3 \* 1, 14, 6,
12 + 1 \* 4, 3, 32 - 1,
11 + 1 \* 8,
4}
};
void d\_(int t, int p, int q) {
for (int y = 0; y < 40; y++)
for (int x = 0; x < 64; x++)
if (\_[t]
[y][x])
x\_[y + q \* 16 + p \* 16][x + 580 + p \* 32 - q \*
32] = \_[t][y][x];
}
int main(int a, char \*s[]) {
d = XOpenDisplay(0);
w = XCreateSimpleWindow(d, (\*(long \*) ((char \*) (\*(long \*) ((char \*)d + 232)) + 16)), 0, 0, 1220, 616, 1, 0, 0);
M = XCreateImage(d, (\*(long \*)((char \*) (\*(long \*) ((char \*)d + 232)) + 64)), (\*(long \*)((char \*) (\*(long \*) ((char \*)d + 232)) + 56)), 2, 0, (char \*) x\_, 1220, 616, 32, 0);
for (int i = 0; i < 8; i++) {
char \*p = z[i];
int c = 0;
while (\*p != 4) {
switch (\*p) {
case 0:
k(i, p[1], p[2], p[3], c);
p += 4;
break;
case 1:
r(i, p[1], p[2], p[3], c);
p += 4;
break;
case 2:
u(i, p[1], p[2], p[3], c);
p += 4;
break;
case 3:
e(i, p[1]
, p[2], 0, c);
p += 3;
break;
case 5:
p = z[p[1]];
break;
case 6:
c = \_x[p[1] / 4] - 1643277 \* (p[1] % 4);
p += 2;
break;
}
}
}
while (a++) {
int f = syscall(2, s[1], 0);
syscall(0, f, m, 380);
syscall(3, f);
for (int y = 0; y < 19; y++)
for (int x = 0; x < 19; x++)
if ((x % 14 == 2) && (y % 4 == 3))
m[y][x] = 46;
b(0, 2, 3, m[3][2], a & 1 ? 43 : 45);
b(0, 2, 7, m[7][2], a & 2 ? 43 : 45);
b(0, 2, 11, m[11][2], a & 4 ? 43 : 45);
b(0, 2, 15, m[15][2], a & 8 ? 43 : 45);
for (int i = 0; i < 20; i++)
for (int y = 0; y < 19; y++)
for (int x = 0; x < 19; x++)
if (m[y][x] == 62)
b(0, x + 1, y, m[y][x + 1],
!(m[y - 1][x] == 43 ? 1 : 0
|| m[y + 1][x] == 43 ? 1 : 0) ? 43 : 45);
for (int y = 0; y < 616; y++)
for (int x = 0; x < 1220; x++)
x\_[y][x] = 0;
for (int y = 0; y < 19; y++)
for (int x = 0; x < 19; x++)
d\_(((m[y][x] >> 4) & 1) << 2 | (m[y][x] & 3), x, y);
for (int y = 0; y < 19; y++)
for (int x = 0; x < 19; x++)
if ((x % 14 == 2) && (y % 4 == 3))
d\_(7, x, y);
for (int y = 0; y < 616; y++)
for (int x = 0; x < 1220; x++) {
x\_[y][x] &= 14737632 | (31 << ((x % 3) << 3));
x\_[y][x] += 986895 & (rn \*= 16777619);
}
XPutImage(d, w, (\*(long \*)((char \*) (\*(long \*) ((char \*)d + 232)) + 72)), M, 0, 0, 0, 0, 1220, 616);
XMapWindow(d, w);
XFlush(d);
syscall(35, &N, &R);
}
return 0;
}
```
#### Syscalls
Заменим системные вызовы по тому же принципу, которому мы следовали в первой части:
**Код без системных вызовов:**
```
#include
#include
#include
#include
#include
int \_x[] = { 15117427, 8413248, 5878632, 13027014, 1 };
int x\_[616][1220];
char m[19][20];
long w;
int rn = 2166136261, \_[8][40][64] = { 0 };
void \*M, \*d, \*T;
void b(int t, int x, int y, int c, int l) {
if ((x >= 19 || y >= 19 || x < 0 || y < 0) || (m[y][x] == l)
|| (m[y][x] != c))
return;
m[y][x] = l;
b(t, x - 1, y, c, l);
b(t, x + 1, y, c, l);
b(t, x, y - 1, c, l);
b(t, x, y + 1, c, l);
}
void e(int t, int x, int y, int c, int l) {
if ((x >= 64 || y >= 40 || x < 0 || y < 0) || (\_[t][y][x] == l)
|| (\_[t][y][x] != c))
return;
\_[t][y][x] = l;
e(t, x - 1, y, c, l);
e(t, x + 1, y, c, l);
e(t, x, y - 1, c, l);
e(t, x, y + 1, c, l);
}
void k(int t, int x, int y, int c, int l) {
while (c--) {
\_[t][y][x++] = l;
\_[t][y++][x++] = l;
}
}
void r(int t, int x, int y, int c, int l) {
while (c--) {
\_[t][y][x--] = l;
\_[t][y++][x--] = l;
}
}
void u(int t, int x, int y, int c, int l) {
while (c--)
\_[t][y++][x] = l;
}
char \*z[8] = {
(char[]) {4},
(char[]) {6, 1 \* 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16, 0, 0,
21 + 0 \* 3 - 0, 16, 1, 63, 21 + 0 \* 3 - 0, 16, 2,
63 \* 0, 21 - 0, 4, 2, 31 + 0, 36 - 0, 4, 0 + 1,
32 - 1, 5 - 0, 16, 0, 0, 21 + 1 \* 3 - 0, 16, 1, 63,
21 + 1 \* 3 - 0, 16, 2, 63 \* 1, 21 - 0, 4, 2, 31 + 1,
36 - 0, 4, 6, 1 \* 4 + 0, 3, 31, 8 - 0, 6, 1 \* 4 + 2,
3, 33, 38 - 0, 6, 1 \* 4 + 3, 3, 30, 38 - 0, 4},
(char[]) {5, 1},
(char[]) {6, 0 \* 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16,
0, 0, 21 + 0 \* 3 - 0, 16, 1, 63,
21 + 0 \* 3 - 0, 16, 2, 63 \* 0, 21 - 0,
4, 2, 31 + 0, 36 - 0, 4, 0 + 1, 32 - 1,
5 - 0, 16, 0, 0, 21 + 1 \* 3 - 0, 16, 1,
63, 21 + 1 \* 3 - 0, 16, 2, 63 \* 1,
21 - 0, 4, 2, 31 + 1, 36 - 0, 4, 6,
0 \* 4 + 0, 3, 31, 8 - 0, 6, 0 \* 4 + 2,
3, 33, 38 - 0, 6, 0 \* 4 + 3, 3, 30,
38 - 0,
4},
(char[]) {4}, (char[]) {4},
(char[]) {6, 2 \* 4 + 1, 0 + 0, 32 - 0, 5 - 3, 16, 0, 0,
21 + 0 \* 3 - 3, 16, 1, 63, 21 + 0 \* 3 - 3, 16, 2, 63 \* 0,
21 - 3, 4, 2, 31 + 0, 36 - 3, 4, 0 + 1, 32 - 1, 5 - 3,
16, 0, 0, 21 + 1 \* 3 - 3, 16, 1, 63, 21 + 1 \* 3 - 3, 16,
2, 63 \* 1, 21 - 3, 4, 2, 31 + 1, 36 - 3, 4, 6, 2 \* 4 + 0,
3, 31, 8 - 3, 6, 2 \* 4 + 2, 3, 33, 38 - 3, 6, 2 \* 4 + 3,
3, 30, 38 - 3, 4},
(char[]) {6, 13, 0, 32, 9 + 0, 12 - 0,
0, 8 + 0 + 0, 21, 12 - 0, 1,
31, 9 + 0, 12 - 0, 1,
55 - 0 - 0, 21, 12 - 0, 0,
32, 9 + 3, 12 - 3, 0,
8 + 3 + 3, 21, 12 - 3, 1,
31, 9 + 3, 12 - 3, 1,
55 - 3 - 3, 21, 12 - 3, 6,
14 + 0, 2, 31 + 0, 13, 4,
1 - 0, 31 + 0, 16, 7, 3,
30 + 3 \* 0, 14, 6,
12 + 0 \* 4, 3, 32 - 0,
11 + 0 \* 8, 6, 14 + 1, 2,
31 + 1, 13, 4, 1 - 1,
31 + 1, 16, 7, 3,
30 + 3 \* 1, 14, 6,
12 + 1 \* 4, 3, 32 - 1,
11 + 1 \* 8,
4}
};
void d\_(int t, int p, int q) {
for (int y = 0; y < 40; y++)
for (int x = 0; x < 64; x++)
if (\_[t]
[y][x])
x\_[y + q \* 16 + p \* 16][x + 580 + p \* 32 - q \*
32] = \_[t][y][x];
}
int main(int a, char \*s[]) {
d = XOpenDisplay(0);
w = XCreateSimpleWindow(d, (\*(long \*) ((char \*) (\*(long \*) ((char \*)d + 232)) + 16)), 0, 0, 1220, 616, 1, 0, 0);
M = XCreateImage(d, (\*(long \*)((char \*) (\*(long \*) ((char \*)d + 232)) + 64)), (\*(long \*)((char \*) (\*(long \*) ((char \*)d + 232)) + 56)), 2, 0, (char \*) x\_, 1220, 616, 32, 0);
for (int i = 0; i < 8; i++) {
char \*p = z[i];
int c = 0;
while (\*p != 4) {
switch (\*p) {
case 0:
k(i, p[1], p[2], p[3], c);
p += 4;
break;
case 1:
r(i, p[1], p[2], p[3], c);
p += 4;
break;
case 2:
u(i, p[1], p[2], p[3], c);
p += 4;
break;
case 3:
e(i, p[1]
, p[2], 0, c);
p += 3;
break;
case 5:
p = z[p[1]];
break;
case 6:
c = \_x[p[1] / 4] - 1643277 \* (p[1] % 4);
p += 2;
break;
}
}
}
while (a++) {
int f = open(s[1], 0);
read(f, m, 380);
close(f);
for (int y = 0; y < 19; y++)
for (int x = 0; x < 19; x++)
if ((x % 14 == 2) && (y % 4 == 3))
m[y][x] = 46;
b(0, 2, 3, m[3][2], a & 1 ? 43 : 45);
b(0, 2, 7, m[7][2], a & 2 ? 43 : 45);
b(0, 2, 11, m[11][2], a & 4 ? 43 : 45);
b(0, 2, 15, m[15][2], a & 8 ? 43 : 45);
for (int i = 0; i < 20; i++)
for (int y = 0; y < 19; y++)
for (int x = 0; x < 19; x++)
if (m[y][x] == 62)
b(0, x + 1, y, m[y][x + 1],
!(m[y - 1][x] == 43 ? 1 : 0
|| m[y + 1][x] == 43 ? 1 : 0) ? 43 : 45);
for (int y = 0; y < 616; y++)
for (int x = 0; x < 1220; x++)
x\_[y][x] = 0;
for (int y = 0; y < 19; y++)
for (int x = 0; x < 19; x++)
d\_(((m[y][x] >> 4) & 1) << 2 | (m[y][x] & 3), x, y);
for (int y = 0; y < 19; y++)
for (int x = 0; x < 19; x++)
if ((x % 14 == 2) && (y % 4 == 3))
d\_(7, x, y);
for (int y = 0; y < 616; y++)
for (int x = 0; x < 1220; x++) {
x\_[y][x] &= 14737632 | (31 << ((x % 3) << 3));
x\_[y][x] += 986895 & (rn \*= 16777619);
}
XPutImage(d, w, (\*(long \*)((char \*) (\*(long \*) ((char \*)d + 232)) + 72)), M, 0, 0, 0, 0, 1220, 616);
XMapWindow(d, w);
XFlush(d);
sleep(1);
}
return 0;
}
```
#### XCreateSimpleWindow и смещения
Постараемся разобрать следующую конструкцию:
```
w = XCreateSimpleWindow(d, (*(long *) ((char *) (*(long *) ((char *)d + 232)) + 16)), 0, 0, 1220, 616, 1, 0, 0);
```
Куча преобразований типов, которые, на первый взгляд, нужны лишь чтобы запутать читателя, однако каждое преобразование здесь имеет свою цель, а именно:
d — это указатель на структуру Display в контексте Xlib. Он имеет поле-массив, называемое screens и для того, чтобы получить указатель на первый элемент этого массива мы должны отсчитать некоторое количество байт (на x64 — 232) от указателя на Display вперед. Так как Display не char \*, то при прямом отсчитывании мы обсчитались бы в sizeof(long \*) байт. Поэтому приведем d к char \* и сдвинемся на 232 байта:
```
((char *)d + 232)
```
Мы получили позицию первого элемента Screens в памяти. Приведем его к полноценному указателю и разыменуем:
```
(*(long *) ((char *)d + 232))
```
Теперь внутри структуры Screens мы должны получить указатель на корневое окно, Root. Для этого отойдем от Screens на 16 байт и разыменуем конструкцию:
```
(*(long *) ((char *) (*(long *) ((char *)d + 232)) + 16))
```
Эта конструкция на самом деле каждый день используется программистами под Xlib, поскольку её общеупотребимый эквивалент — это
```
RootWindow(Display, DefaultScreen(Display))
```
Аналогичным образом заменим соответствующие смещения в других местах, чтобы получить более привычные глазу макросы (заодно поправим косяки indent):
**Код после замены смещений:**
```
#include
#include
#include
#include
#include
int \_x[] = { 15117427, 8413248, 5878632, 13027014, 1 };
int x\_[616][1220];
char m[19][20];
int rn = 2166136261, \_[8][40][64] = { 0 };
void \*T;
Display \* display;
Window window;
XImage \* image;
void b(int t, int x, int y, int c, int l) {
if ((x >= 19 || y >= 19 || x < 0 || y < 0) || (m[y][x] == l)
|| (m[y][x] != c))
return;
m[y][x] = l;
b(t, x - 1, y, c, l);
b(t, x + 1, y, c, l);
b(t, x, y - 1, c, l);
b(t, x, y + 1, c, l);
}
void e(int t, int x, int y, int c, int l) {
if ((x >= 64 || y >= 40 || x < 0 || y < 0) || (\_[t][y][x] == l)
|| (\_[t][y][x] != c))
return;
\_[t][y][x] = l;
e(t, x - 1, y, c, l);
e(t, x + 1, y, c, l);
e(t, x, y - 1, c, l);
e(t, x, y + 1, c, l);
}
void k(int t, int x, int y, int c, int l) {
while (c--) {
\_[t][y][x++] = l;
\_[t][y++][x++] = l;
}
}
void r(int t, int x, int y, int c, int l) {
while (c--) {
\_[t][y][x--] = l;
\_[t][y++][x--] = l;
}
}
void u(int t, int x, int y, int c, int l) {
while (c--)
\_[t][y++][x] = l;
}
char \*z[8] = {
(char[]) {4},
(char[]) {6, 1 \* 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16, 0, 0,
21 + 0 \* 3 - 0, 16, 1, 63, 21 + 0 \* 3 - 0, 16, 2,
63 \* 0, 21 - 0, 4, 2, 31 + 0, 36 - 0, 4, 0 + 1,
32 - 1, 5 - 0, 16, 0, 0, 21 + 1 \* 3 - 0, 16, 1, 63,
21 + 1 \* 3 - 0, 16, 2, 63 \* 1, 21 - 0, 4, 2, 31 + 1,
36 - 0, 4, 6, 1 \* 4 + 0, 3, 31, 8 - 0, 6, 1 \* 4 + 2,
3, 33, 38 - 0, 6, 1 \* 4 + 3, 3, 30, 38 - 0, 4},
(char[]) {5, 1},
(char[]) {6, 0 \* 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16,
0, 0, 21 + 0 \* 3 - 0, 16, 1, 63,
21 + 0 \* 3 - 0, 16, 2, 63 \* 0, 21 - 0,
4, 2, 31 + 0, 36 - 0, 4, 0 + 1, 32 - 1,
5 - 0, 16, 0, 0, 21 + 1 \* 3 - 0, 16, 1,
63, 21 + 1 \* 3 - 0, 16, 2, 63 \* 1,
21 - 0, 4, 2, 31 + 1, 36 - 0, 4, 6,
0 \* 4 + 0, 3, 31, 8 - 0, 6, 0 \* 4 + 2,
3, 33, 38 - 0, 6, 0 \* 4 + 3, 3, 30,
38 - 0,
4},
(char[]) {4},
(char[]) {4},
(char[]) {6, 2 \* 4 + 1, 0 + 0, 32 - 0, 5 - 3, 16, 0, 0,
21 + 0 \* 3 - 3, 16, 1, 63, 21 + 0 \* 3 - 3, 16, 2, 63 \* 0,
21 - 3, 4, 2, 31 + 0, 36 - 3, 4, 0 + 1, 32 - 1, 5 - 3,
16, 0, 0, 21 + 1 \* 3 - 3, 16, 1, 63, 21 + 1 \* 3 - 3, 16,
2, 63 \* 1, 21 - 3, 4, 2, 31 + 1, 36 - 3, 4, 6, 2 \* 4 + 0,
3, 31, 8 - 3, 6, 2 \* 4 + 2, 3, 33, 38 - 3, 6, 2 \* 4 + 3,
3, 30, 38 - 3, 4},
(char[]) {6, 13, 0, 32, 9 + 0, 12 - 0,
0, 8 + 0 + 0, 21, 12 - 0, 1,
31, 9 + 0, 12 - 0, 1,
55 - 0 - 0, 21, 12 - 0, 0,
32, 9 + 3, 12 - 3, 0,
8 + 3 + 3, 21, 12 - 3, 1,
31, 9 + 3, 12 - 3, 1,
55 - 3 - 3, 21, 12 - 3, 6,
14 + 0, 2, 31 + 0, 13, 4,
1 - 0, 31 + 0, 16, 7, 3,
30 + 3 \* 0, 14, 6,
12 + 0 \* 4, 3, 32 - 0,
11 + 0 \* 8, 6, 14 + 1, 2,
31 + 1, 13, 4, 1 - 1,
31 + 1, 16, 7, 3,
30 + 3 \* 1, 14, 6,
12 + 1 \* 4, 3, 32 - 1,
11 + 1 \* 8,
4}
};
void d\_(int t, int p, int q) {
for (int y = 0; y < 40; y++)
for (int x = 0; x < 64; x++)
if (\_[t][y][x])
x\_[y + q \* 16 + p \* 16][x + 580 + p \* 32 - q \* 32] = \_[t][y][x];
}
int main(int a, char \*s[]) {
display = XOpenDisplay(0);
window = XCreateSimpleWindow(display,
RootWindow(display, DefaultScreen(display)),
0, 0, 1220, 616, 1, 0, 0);
image = XCreateImage(display,
DefaultVisual(display, DefaultScreen(display)),
DefaultDepth(display, DefaultScreen(display)),
2, 0, (char \*) x\_, 1220, 616, 32, 0);
for (int i = 0; i < 8; i++) {
char \*p = z[i];
int c = 0;
while (\*p != 4) {
switch (\*p) {
case 0:
k(i, p[1], p[2], p[3], c);
p += 4;
break;
case 1:
r(i, p[1], p[2], p[3], c);
p += 4;
break;
case 2:
u(i, p[1], p[2], p[3], c);
p += 4;
break;
case 3:
e(i, p[1]
, p[2], 0, c);
p += 3;
break;
case 5:
p = z[p[1]];
break;
case 6:
c = \_x[p[1] / 4] - 1643277 \* (p[1] % 4);
p += 2;
break;
}
}
}
while (a++) {
int f = open(s[1], 0);
read(f, m, 380);
close(f);
for (int y = 0; y < 19; y++)
for (int x = 0; x < 19; x++)
if ((x % 14 == 2) && (y % 4 == 3))
m[y][x] = 46;
b(0, 2, 3, m[3][2], a & 1 ? 43 : 45);
b(0, 2, 7, m[7][2], a & 2 ? 43 : 45);
b(0, 2, 11, m[11][2], a & 4 ? 43 : 45);
b(0, 2, 15, m[15][2], a & 8 ? 43 : 45);
for (int i = 0; i < 20; i++)
for (int y = 0; y < 19; y++)
for (int x = 0; x < 19; x++)
if (m[y][x] == 62)
b(0, x + 1, y, m[y][x + 1],
!(m[y - 1][x] == 43 ? 1 : 0
|| m[y + 1][x] == 43 ? 1 : 0) ? 43 : 45);
for (int y = 0; y < 616; y++)
for (int x = 0; x < 1220; x++)
x\_[y][x] = 0;
for (int y = 0; y < 19; y++)
for (int x = 0; x < 19; x++)
d\_(((m[y][x] >> 4) & 1) << 2 | (m[y][x] & 3), x, y);
for (int y = 0; y < 19; y++)
for (int x = 0; x < 19; x++)
if ((x % 14 == 2) && (y % 4 == 3))
d\_(7, x, y);
for (int y = 0; y < 616; y++)
for (int x = 0; x < 1220; x++) {
x\_[y][x] &= 14737632 | (31 << ((x % 3) << 3));
x\_[y][x] += 986895 & (rn \*= 16777619);
}
XPutImage(display, window,
DefaultGC(display, DefaultScreen(display)),
image, 0, 0, 0, 0, 1220, 616);
XMapWindow(display, window);
XFlush(display);
sleep(1);
}
return 0;
}
```
#### Данные изображения
Обратим внимание, что XCreateImage требует на вход указатель на область памяти, где будут храниться данные пикселей. Для нашего вызова функции это переменная «x\_». Переименуем ее в pixdata и найдем все места, где она используется:
```
void d_(int t, int p, int q) {
for (int y = 0; y < 40; y++)
for (int x = 0; x < 64; x++)
if (_[t][y][x])
pixdata[y + q * 16 + p * 16][x + 580 + p * 32 - q * 32] = _[t][y][x]; // Очевидно, что это копирование данных из какого-то источника
}
```
```
image = XCreateImage(display,
DefaultVisual(display, DefaultScreen(display)),
DefaultDepth(display, DefaultScreen(display)),
2, 0, (char *) pixdata, 1220, 616, 32, 0); // создание изображения
```
```
for (int y = 0; y < 616; y++)
for (int x = 0; x < 1220; x++)
pixdata[y][x] = 0; // "Обнуление" пикселей, закраска черным цветом
```
```
for (int y = 0; y < 616; y++)
for (int x = 0; x < 1220; x++) { // Какая-то странная математическая операция, очевидно применяемая ко всему изображению.
pixdata[y][x] &= 14737632 | (31 << ((x % 3) << 3));
pixdata[y][x] += 986895 & (rn *= 16777619);
}
```
Вычленим блок pixdata[..] = 0 в отдельную функцию и попытаемся разобрать, что же делает первое вхождение:
```
for (int y = 0; y < 40; y++)
for (int x = 0; x < 64; x++)
if (_[t][y][x])
pixdata[y + q * 16 + p * 16][x + 580 + p * 32 - q * 32] = _[t][y][x];
```
Если присмотреться к итоговому изображению, сформированному при работе программы, то легко заметить, что 40 и 64 — это размеры отдельного «блока», из которого построена схема.
Следовательно, эта функция рисует отдельный «тайл» на канве основного изображения, а судя по индексации массива "\_" переменная «t» отвечает за индекс изображения, а p и q — за координаты x и y. Заодно переименуем "\_" в textures:
**Код на данный момент:**
```
#include
#include
#include
#include
#include
/\* Код после рефакторинга \*/
/\*! \brief Ширина изображения в пикселях \*/
#define IMAGE\_WIDTH \*1220)
/\*! \brief Высота изображения в пикселях \*/
#define IMAGE\_HEIGHT (616)
/\*! \brief Количество текстур \*/
#define TEXTURE\_COUNT (8)
/\*! \brief Ширина текстуры в пикселях \*/
#define TEXTURE\_WIDTH (64)
/\*! \brief Высота текстур в пикселях \*/
#define TEXTURE\_HEIGHT (40)
/\*! \brief Бинарные данные пикселей изображения.
\* Типизированы к int для оперирования пикселями вместо каналов \*/
int pixdata[IMAGE\_HEIGHT][IMAGE\_WIDTH];
int textures[TEXTURE\_COUNT][TEXTURE\_HEIGHT][TEXTURE\_WIDTH] = { 0 };
/\*! \brief Экземпляр дисплея Xlib \*/
Display \* display;
/\*! \brief Экземпляр главного окна Xlib \*/
Window window;
/\*! \brief Изображение для вывода на экран \*/
XImage \* image;
/\* \brief Обнуляет изображение, заполняя его черным цветом \*/
static void \_image\_reset(void) {
for (int y = 0; y < IMAGE\_HEIGHT; y++)
for (int x = 0; x < IMAGE\_WIDTH; x++)
pixdata[y][x] = 0;
}
/\*! \brief Отрисовывает текстуру на главном холсте по указанным координатам
\* \param[in] t Индекс текстуры
\* \param[in] x X координата тайла
\* \param[in] y Y координата тайла \*/
void \_texture\_draw(int t, int x, int y) {
for (int ty = 0; ty < TEXTURE\_HEIGHT; ty++)
for (int tx = 0; tx < TEXTURE\_WIDTH; tx++)
if (textures[t][ty][tx])
pixdata[ty + y \* 16 + x \* 16]
[tx + 580 + x \* 32 - y \* 32] = textures[t][ty][tx];
}
/\* Код до рефакторинга \*/
int \_x[] = { 15117427, 8413248, 5878632, 13027014, 1 };
char m[19][20];
int rn = 2166136261;
void \*T;
void b(int t, int x, int y, int c, int l) {
if ((x >= 19 || y >= 19 || x < 0 || y < 0) || (m[y][x] == l)
|| (m[y][x] != c))
return;
m[y][x] = l;
b(t, x - 1, y, c, l);
b(t, x + 1, y, c, l);
b(t, x, y - 1, c, l);
b(t, x, y + 1, c, l);
}
void e(int t, int x, int y, int c, int l) {
if ((x >= TEXTURE\_WIDTH || y >= TEXTURE\_HEIGHT ||
x < 0 || y < 0) ||
(textures[t][y][x] == l) ||
(textures[t][y][x] != c))
return;
textures[t][y][x] = l;
e(t, x - 1, y, c, l);
e(t, x + 1, y, c, l);
e(t, x, y - 1, c, l);
e(t, x, y + 1, c, l);
}
void k(int t, int x, int y, int c, int l) {
while (c--) {
textures[t][y][x++] = l;
textures[t][y++][x++] = l;
}
}
void r(int t, int x, int y, int c, int l) {
while (c--) {
textures[t][y][x--] = l;
textures[t][y++][x--] = l;
}
}
void u(int t, int x, int y, int c, int l) {
while (c--)
textures[t][y++][x] = l;
}
char \*z[8] = {
(char[]) {4},
(char[]) {6, 1 \* 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16, 0, 0,
21 + 0 \* 3 - 0, 16, 1, 63, 21 + 0 \* 3 - 0, 16, 2,
63 \* 0, 21 - 0, 4, 2, 31 + 0, 36 - 0, 4, 0 + 1,
32 - 1, 5 - 0, 16, 0, 0, 21 + 1 \* 3 - 0, 16, 1, 63,
21 + 1 \* 3 - 0, 16, 2, 63 \* 1, 21 - 0, 4, 2, 31 + 1,
36 - 0, 4, 6, 1 \* 4 + 0, 3, 31, 8 - 0, 6, 1 \* 4 + 2,
3, 33, 38 - 0, 6, 1 \* 4 + 3, 3, 30, 38 - 0, 4},
(char[]) {5, 1},
(char[]) {6, 0 \* 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16,
0, 0, 21 + 0 \* 3 - 0, 16, 1, 63,
21 + 0 \* 3 - 0, 16, 2, 63 \* 0, 21 - 0,
4, 2, 31 + 0, 36 - 0, 4, 0 + 1, 32 - 1,
5 - 0, 16, 0, 0, 21 + 1 \* 3 - 0, 16, 1,
63, 21 + 1 \* 3 - 0, 16, 2, 63 \* 1,
21 - 0, 4, 2, 31 + 1, 36 - 0, 4, 6,
0 \* 4 + 0, 3, 31, 8 - 0, 6, 0 \* 4 + 2,
3, 33, 38 - 0, 6, 0 \* 4 + 3, 3, 30,
38 - 0,
4},
(char[]) {4},
(char[]) {4},
(char[]) {6, 2 \* 4 + 1, 0 + 0, 32 - 0, 5 - 3, 16, 0, 0,
21 + 0 \* 3 - 3, 16, 1, 63, 21 + 0 \* 3 - 3, 16, 2, 63 \* 0,
21 - 3, 4, 2, 31 + 0, 36 - 3, 4, 0 + 1, 32 - 1, 5 - 3,
16, 0, 0, 21 + 1 \* 3 - 3, 16, 1, 63, 21 + 1 \* 3 - 3, 16,
2, 63 \* 1, 21 - 3, 4, 2, 31 + 1, 36 - 3, 4, 6, 2 \* 4 + 0,
3, 31, 8 - 3, 6, 2 \* 4 + 2, 3, 33, 38 - 3, 6, 2 \* 4 + 3,
3, 30, 38 - 3, 4},
(char[]) {6, 13, 0, 32, 9 + 0, 12 - 0,
0, 8 + 0 + 0, 21, 12 - 0, 1,
31, 9 + 0, 12 - 0, 1,
55 - 0 - 0, 21, 12 - 0, 0,
32, 9 + 3, 12 - 3, 0,
8 + 3 + 3, 21, 12 - 3, 1,
31, 9 + 3, 12 - 3, 1,
55 - 3 - 3, 21, 12 - 3, 6,
14 + 0, 2, 31 + 0, 13, 4,
1 - 0, 31 + 0, 16, 7, 3,
30 + 3 \* 0, 14, 6,
12 + 0 \* 4, 3, 32 - 0,
11 + 0 \* 8, 6, 14 + 1, 2,
31 + 1, 13, 4, 1 - 1,
31 + 1, 16, 7, 3,
30 + 3 \* 1, 14, 6,
12 + 1 \* 4, 3, 32 - 1,
11 + 1 \* 8,
4}
};
int main(int a, char \*s[]) {
display = XOpenDisplay(0);
window = XCreateSimpleWindow(display,
RootWindow(display, DefaultScreen(display)),
0, 0, IMAGE\_WIDTH, IMAGE\_HEIGHT, 1, 0, 0);
image = XCreateImage(display,
DefaultVisual(display, DefaultScreen(display)),
DefaultDepth(display, DefaultScreen(display)),
2, 0, (char \*) pixdata, IMAGE\_WIDTH, IMAGE\_HEIGHT, 32, 0);
for (int i = 0; i < 8; i++) {
char \*p = z[i];
int c = 0;
while (\*p != 4) {
switch (\*p) {
case 0:
k(i, p[1], p[2], p[3], c);
p += 4;
break;
case 1:
r(i, p[1], p[2], p[3], c);
p += 4;
break;
case 2:
u(i, p[1], p[2], p[3], c);
p += 4;
break;
case 3:
e(i, p[1]
, p[2], 0, c);
p += 3;
break;
case 5:
p = z[p[1]];
break;
case 6:
c = \_x[p[1] / 4] - 1643277 \* (p[1] % 4);
p += 2;
break;
}
}
}
while (a++) {
int f = open(s[1], 0);
read(f, m, 380);
close(f);
for (int y = 0; y < 19; y++)
for (int x = 0; x < 19; x++)
if ((x % 14 == 2) && (y % 4 == 3))
m[y][x] = 46;
b(0, 2, 3, m[3][2], a & 1 ? 43 : 45);
b(0, 2, 7, m[7][2], a & 2 ? 43 : 45);
b(0, 2, 11, m[11][2], a & 4 ? 43 : 45);
b(0, 2, 15, m[15][2], a & 8 ? 43 : 45);
for (int i = 0; i < 20; i++)
for (int y = 0; y < 19; y++)
for (int x = 0; x < 19; x++)
if (m[y][x] == 62)
b(0, x + 1, y, m[y][x + 1],
!(m[y - 1][x] == 43 ? 1 : 0
|| m[y + 1][x] == 43 ? 1 : 0) ? 43 : 45);
\_image\_reset();
for (int y = 0; y < 19; y++)
for (int x = 0; x < 19; x++)
\_texture\_draw(((m[y][x] >> 4) & 1) << 2 | (m[y][x] & 3), x, y);
for (int y = 0; y < 19; y++)
for (int x = 0; x < 19; x++)
if ((x % 14 == 2) && (y % 4 == 3))
\_texture\_draw(7, x, y);
for (int y = 0; y < IMAGE\_HEIGHT; y++)
for (int x = 0; x < IMAGE\_WIDTH; x++) {
pixdata[y][x] &= 14737632 | (31 << ((x % 3) << 3));
pixdata[y][x] += 986895 & (rn \*= 16777619);
}
XPutImage(display, window,
DefaultGC(display, DefaultScreen(display)),
image, 0, 0, 0, 0, IMAGE\_WIDTH, IMAGE\_HEIGHT);
XMapWindow(display, window);
XFlush(display);
sleep(1);
}
return 0;
}
```
#### Чтение карты
Выделим в отдельную функцию строки open..close, где читается содержимое выбранного файла в переменную m (которую переименуем в mapdata).
> Почему файл считается в каждом цикле? Так было короче с точки зрения кода и токенов. Около 4 дней занял процесс «утрамбовывания» кода чтобы поместиться в лимиты правил. Если читать файл только один раз то потребовалось бы дополнительное хранилище и какой-то аналог функции memcpy.
**Выделена функция \_map\_read**
```
#include
#include
#include
#include
#include
/\* Код после рефакторинга \*/
/\*! \brief Ширина изображения в пикселях \*/
#define IMAGE\_WIDTH (1220)
/\*! \brief Высота изображения в пикселях \*/
#define IMAGE\_HEIGHT (616)
/\*! \brief Сдвиг верхней грани карты от левой стороны \*/
#define IMAGE\_SHIFTX (580)
/\*! \brief Количество текстур \*/
#define TEXTURE\_COUNT (8)
/\*! \brief Ширина текстуры в пикселях \*/
#define TEXTURE\_WIDTH (64)
/\*! \brief Высота текстур в пикселях \*/
#define TEXTURE\_HEIGHT (40)
/\*! \brief Ширина грани текстуры в пикселях \*/
#define TEXTURE\_TOP\_WIDTH (64)
/\*! \brief Высота грани текстуры в пикселях \*/
#define TEXTURE\_TOP\_HEIGHT (32)
/\*! \brief Ширина эмулируемого поля \*/
#define MAP\_WIDTH (19)
/\*! \brief Высота эмулируемого поля \*/
#define MAP\_HEIGHT (19)
/\*! \brief Количество данные в файле-чертеже. Один байт добавлен для символа '\n' \*/
#define MAP\_FILEDATA ((MAP\_WIDTH + 1) \* MAP\_HEIGHT)
/\*! \brief Бинарные данные пикселей изображения.
\* Типизированы к int для оперирования пикселями вместо каналов \*/
int pixdata[IMAGE\_HEIGHT][IMAGE\_WIDTH];
/\*! \brief Текстуры блоков, отображаемых на поле \*/
int textures[TEXTURE\_COUNT][TEXTURE\_HEIGHT][TEXTURE\_WIDTH] = { 0 };
/\*! \brief Данные эмулируемого поля.
\* Один байт добавлен для упрощения обработки символа '\n' \*/
char mapdata[MAP\_HEIGHT][MAP\_WIDTH + 1];
/\*! \brief Экземпляр дисплея Xlib \*/
Display \* display;
/\*! \brief Экземпляр главного окна Xlib \*/
Window window;
/\*! \brief Изображение для вывода на экран \*/
XImage \* image;
/\* \brief Обнуляет изображение, заполняя его черным цветом \*/
static void \_image\_reset(void) {
for (int y = 0; y < IMAGE\_HEIGHT; y++)
for (int x = 0; x < IMAGE\_WIDTH; x++)
pixdata[y][x] = 0;
}
/\*! \brief Отрисовывает текстуру на главном холсте по указанным координатам
\* \param[in] t Индекс текстуры
\* \param[in] x X координата тайла
\* \param[in] y Y координата тайла \*/
static void \_texture\_draw(int t, int x, int y) {
for (int ty = 0; ty < TEXTURE\_HEIGHT; ty++)
for (int tx = 0; tx < TEXTURE\_WIDTH; tx++)
if (textures[t][ty][tx])
pixdata[ty +
y \* (TEXTURE\_TOP\_HEIGHT / 2) +
x \* (TEXTURE\_TOP\_HEIGHT / 2)]
[tx +
IMAGE\_SHIFTX +
x \* (TEXTURE\_TOP\_WIDTH / 2) -
y \* TEXTURE\_TOP\_HEIGHT] = textures[t][ty][tx];
}
/\*! \brief Читает данные файла-чертежа и загружает их в карту
\* \param[in] filename Имя файла-чертежа \*/
static void \_map\_read(const char \* filename) {
int f = open(filename, 0);
read(f, mapdata, MAP\_FILEDATA);
close(f);
}
/\* Код до рефакторинга \*/
int \_x[] = { 15117427, 8413248, 5878632, 13027014, 1 };
int rn = 2166136261;
void \*T;
void b(int t, int x, int y, int c, int l) {
if ((x >= MAP\_WIDTH || y >= MAP\_HEIGHT ||
x < 0 || y < 0) || (mapdata[y][x] == l)
|| (mapdata[y][x] != c))
return;
mapdata[y][x] = l;
b(t, x - 1, y, c, l);
b(t, x + 1, y, c, l);
b(t, x, y - 1, c, l);
b(t, x, y + 1, c, l);
}
void e(int t, int x, int y, int c, int l) {
if ((x >= TEXTURE\_WIDTH || y >= TEXTURE\_HEIGHT ||
x < 0 || y < 0) ||
(textures[t][y][x] == l) ||
(textures[t][y][x] != c))
return;
textures[t][y][x] = l;
e(t, x - 1, y, c, l);
e(t, x + 1, y, c, l);
e(t, x, y - 1, c, l);
e(t, x, y + 1, c, l);
}
void k(int t, int x, int y, int c, int l) {
while (c--) {
textures[t][y][x++] = l;
textures[t][y++][x++] = l;
}
}
void r(int t, int x, int y, int c, int l) {
while (c--) {
textures[t][y][x--] = l;
textures[t][y++][x--] = l;
}
}
void u(int t, int x, int y, int c, int l) {
while (c--)
textures[t][y++][x] = l;
}
char \*z[8] = {
(char[]) {4},
(char[]) {6, 1 \* 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16, 0, 0,
21 + 0 \* 3 - 0, 16, 1, 63, 21 + 0 \* 3 - 0, 16, 2,
63 \* 0, 21 - 0, 4, 2, 31 + 0, 36 - 0, 4, 0 + 1,
32 - 1, 5 - 0, 16, 0, 0, 21 + 1 \* 3 - 0, 16, 1, 63,
21 + 1 \* 3 - 0, 16, 2, 63 \* 1, 21 - 0, 4, 2, 31 + 1,
36 - 0, 4, 6, 1 \* 4 + 0, 3, 31, 8 - 0, 6, 1 \* 4 + 2,
3, 33, 38 - 0, 6, 1 \* 4 + 3, 3, 30, 38 - 0, 4},
(char[]) {5, 1},
(char[]) {6, 0 \* 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16,
0, 0, 21 + 0 \* 3 - 0, 16, 1, 63,
21 + 0 \* 3 - 0, 16, 2, 63 \* 0, 21 - 0,
4, 2, 31 + 0, 36 - 0, 4, 0 + 1, 32 - 1,
5 - 0, 16, 0, 0, 21 + 1 \* 3 - 0, 16, 1,
63, 21 + 1 \* 3 - 0, 16, 2, 63 \* 1,
21 - 0, 4, 2, 31 + 1, 36 - 0, 4, 6,
0 \* 4 + 0, 3, 31, 8 - 0, 6, 0 \* 4 + 2,
3, 33, 38 - 0, 6, 0 \* 4 + 3, 3, 30,
38 - 0,
4},
(char[]) {4},
(char[]) {4},
(char[]) {6, 2 \* 4 + 1, 0 + 0, 32 - 0, 5 - 3, 16, 0, 0,
21 + 0 \* 3 - 3, 16, 1, 63, 21 + 0 \* 3 - 3, 16, 2, 63 \* 0,
21 - 3, 4, 2, 31 + 0, 36 - 3, 4, 0 + 1, 32 - 1, 5 - 3,
16, 0, 0, 21 + 1 \* 3 - 3, 16, 1, 63, 21 + 1 \* 3 - 3, 16,
2, 63 \* 1, 21 - 3, 4, 2, 31 + 1, 36 - 3, 4, 6, 2 \* 4 + 0,
3, 31, 8 - 3, 6, 2 \* 4 + 2, 3, 33, 38 - 3, 6, 2 \* 4 + 3,
3, 30, 38 - 3, 4},
(char[]) {6, 13, 0, 32, 9 + 0, 12 - 0,
0, 8 + 0 + 0, 21, 12 - 0, 1,
31, 9 + 0, 12 - 0, 1,
55 - 0 - 0, 21, 12 - 0, 0,
32, 9 + 3, 12 - 3, 0,
8 + 3 + 3, 21, 12 - 3, 1,
31, 9 + 3, 12 - 3, 1,
55 - 3 - 3, 21, 12 - 3, 6,
14 + 0, 2, 31 + 0, 13, 4,
1 - 0, 31 + 0, 16, 7, 3,
30 + 3 \* 0, 14, 6,
12 + 0 \* 4, 3, 32 - 0,
11 + 0 \* 8, 6, 14 + 1, 2,
31 + 1, 13, 4, 1 - 1,
31 + 1, 16, 7, 3,
30 + 3 \* 1, 14, 6,
12 + 1 \* 4, 3, 32 - 1,
11 + 1 \* 8,
4}
};
int main(int a, char \*s[]) {
display = XOpenDisplay(0);
window = XCreateSimpleWindow(display,
RootWindow(display, DefaultScreen(display)),
0, 0, IMAGE\_WIDTH, IMAGE\_HEIGHT, 1, 0, 0);
image = XCreateImage(display,
DefaultVisual(display, DefaultScreen(display)),
DefaultDepth(display, DefaultScreen(display)),
2, 0, (char \*) pixdata, IMAGE\_WIDTH, IMAGE\_HEIGHT, 32, 0);
for (int i = 0; i < 8; i++) {
char \*p = z[i];
int c = 0;
while (\*p != 4) {
switch (\*p) {
case 0:
k(i, p[1], p[2], p[3], c);
p += 4;
break;
case 1:
r(i, p[1], p[2], p[3], c);
p += 4;
break;
case 2:
u(i, p[1], p[2], p[3], c);
p += 4;
break;
case 3:
e(i, p[1]
, p[2], 0, c);
p += 3;
break;
case 5:
p = z[p[1]];
break;
case 6:
c = \_x[p[1] / 4] - 1643277 \* (p[1] % 4);
p += 2;
break;
}
}
}
while (a++) {
\_map\_read(s[1]);
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if ((x % 14 == 2) && (y % 4 == 3))
mapdata[y][x] = 46;
b(0, 2, 3, mapdata[3][2], a & 1 ? 43 : 45);
b(0, 2, 7, mapdata[7][2], a & 2 ? 43 : 45);
b(0, 2, 11, mapdata[11][2], a & 4 ? 43 : 45);
b(0, 2, 15, mapdata[15][2], a & 8 ? 43 : 45);
for (int i = 0; i < 20; i++)
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if (mapdata[y][x] == 62)
b(0, x + 1, y, mapdata[y][x + 1],
!(mapdata[y - 1][x] == 43 ? 1 : 0
|| mapdata[y + 1][x] == 43 ? 1 : 0) ? 43 : 45);
\_image\_reset();
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
\_texture\_draw(((m[y][x] >> 4) & 1) << 2 | (mapdata[y][x] & 3), x, y);
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if ((x % 14 == 2) && (y % 4 == 3))
\_texture\_draw(7, x, y);
for (int y = 0; y < IMAGE\_HEIGHT; y++)
for (int x = 0; x < IMAGE\_WIDTH; x++) {
pixdata[y][x] &= 14737632 | (31 << ((x % 3) << 3));
pixdata[y][x] += 986895 & (rn \*= 16777619);
}
XPutImage(display, window,
DefaultGC(display, DefaultScreen(display)),
image, 0, 0, 0, 0, IMAGE\_WIDTH, IMAGE\_HEIGHT);
XMapWindow(display, window);
XFlush(display);
sleep(1);
}
return 0;
}
```
Раз уж мы затронули переменную mapdata, обратим внимание на строки и функции, где она изменяется — это функция «b», которую мы пока трогать не будем и «main» где, обратив внимание на содержимое «комплектных» файлов конфигураций проведем рефакторинг:
**После рефакторинга по mapdata**
```
#include
#include
#include
#include
#include
/\* Код после рефакторинга \*/
/\*! \brief Ширина изображения в пикселях \*/
#define IMAGE\_WIDTH (1220)
/\*! \brief Высота изображения в пикселях \*/
#define IMAGE\_HEIGHT (616)
/\*! \brief Сдвиг верхней грани карты от левой стороны \*/
#define IMAGE\_SHIFTX (580)
/\*! \brief Количество текстур \*/
#define TEXTURE\_COUNT (8)
/\*! \brief Ширина текстуры в пикселях \*/
#define TEXTURE\_WIDTH (64)
/\*! \brief Высота текстур в пикселях \*/
#define TEXTURE\_HEIGHT (40)
/\*! \brief Ширина грани текстуры в пикселях \*/
#define TEXTURE\_TOP\_WIDTH (64)
/\*! \brief Высота грани текстуры в пикселях \*/
#define TEXTURE\_TOP\_HEIGHT (32)
/\*! \brief Ширина эмулируемого поля \*/
#define MAP\_WIDTH (19)
/\*! \brief Высота эмулируемого поля \*/
#define MAP\_HEIGHT (19)
/\*! \brief Количество данные в файле-чертеже. Один байт добавлен для символа '\n' \*/
#define MAP\_FILEDATA ((MAP\_WIDTH + 1) \* MAP\_HEIGHT)
/\*! \brief Количество итераций во время расчета NOR-узлов \*/
#define MAP\_ITERATIONS (20)
/\*! \brief Содержит структуры синтаксиса файла-конфигурации \*/
enum map\_characters {
MAPCHAR\_WIRE = '.', /\*\*< Провод (ASCII = 46) \*/
MAPCHAR\_PLUS = '+', /\*\*< Провод (есть ток) (ASCII = 43) \*/
MAPCHAR\_MINUS = '-', /\*\*< Провод (нет тока) (ASCII = 45) \*/
MAPCHAR\_NOR = '>', /\*\*< NOR-элемент (ASCII = 62) \*/
}
/\*! \brief Бинарные данные пикселей изображения.
\* Типизированы к int для оперирования пикселями вместо каналов \*/
int pixdata[IMAGE\_HEIGHT][IMAGE\_WIDTH];
/\*! \brief Текстуры блоков, отображаемых на поле \*/
int textures[TEXTURE\_COUNT][TEXTURE\_HEIGHT][TEXTURE\_WIDTH] = { 0 };
/\*! \brief Данные эмулируемого поля.
\* Один байт добавлен для упрощения обработки символа '\n' \*/
char mapdata[MAP\_HEIGHT][MAP\_WIDTH + 1];
/\*! \brief Экземпляр дисплея Xlib \*/
Display \* display;
/\*! \brief Экземпляр главного окна Xlib \*/
Window window;
/\*! \brief Изображение для вывода на экран \*/
XImage \* image;
/\* \brief Обнуляет изображение, заполняя его черным цветом \*/
static void \_image\_reset(void) {
for (int y = 0; y < IMAGE\_HEIGHT; y++)
for (int x = 0; x < IMAGE\_WIDTH; x++)
pixdata[y][x] = 0;
}
/\*! \brief Отрисовывает текстуру на главном холсте по указанным координатам
\* \param[in] t Индекс текстуры
\* \param[in] x X координата тайла
\* \param[in] y Y координата тайла \*/
static void \_texture\_draw(int t, int x, int y) {
for (int ty = 0; ty < TEXTURE\_HEIGHT; ty++)
for (int tx = 0; tx < TEXTURE\_WIDTH; tx++)
if (textures[t][ty][tx])
pixdata[ty +
y \* (TEXTURE\_TOP\_HEIGHT / 2) +
x \* (TEXTURE\_TOP\_HEIGHT / 2)]
[tx +
IMAGE\_SHIFTX +
x \* (TEXTURE\_TOP\_WIDTH / 2) -
y \* TEXTURE\_TOP\_HEIGHT] = textures[t][ty][tx];
}
/\*! \brief Читает данные файла-чертежа и загружает их в карту
\* \param[in] filename Имя файла-чертежа \*/
static void \_map\_read(const char \* filename) {
int f = open(filename, 0);
read(f, mapdata, MAP\_FILEDATA);
close(f);
}
/\*! \brief Заменяет иллюстративные входы из файла-конфигурации на вход
\* в виде провода чтобы работала логика распространения фронта волны \*/
static void \_map\_wire\_inputs(void) {
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if ((x % 14 == 2) && (y % 4 == 3))
mapdata[y][x] = MAPCHAR\_WIRE;
}
/\*! \brief Включает соответствующие входы схемы в зависимости от значения
\* счетчика.
\* \param[in] counter Счетчик \*/
static void \_map\_wire\_counter(int counter) {
b(0, 2, 3, mapdata[3][2], counter & 1 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
b(0, 2, 7, mapdata[7][2], counter & 2 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
b(0, 2, 11, mapdata[11][2], counter & 4 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
b(0, 2, 15, mapdata[15][2], counter & 8 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
}
/\*! \brief Проводит расчет выходного (результирующего) тока после NOR-узла \*/
static void \_map\_process\_gates(void) {
for (int i = 0; i < MAP\_ITERATIONS; i++)
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if (mapdata[y][x] == MAPCHAR\_NOR)
b(0, x + 1, y, mapdata[y][x + 1],
!(mapdata[y - 1][x] == MAPCHAR\_PLUS ? 1 : 0
|| mapdata[y + 1][x] == MAPCHAR\_PLUS ? 1 : 0) ?
MAPCHAR\_PLUS : MAPCHAR\_MINUS);
}
/\* Код до рефакторинга \*/
int \_x[] = { 15117427, 8413248, 5878632, 13027014, 1 };
int rn = 2166136261;
void \*T;
void b(int t, int x, int y, int c, int l) {
if ((x >= MAP\_WIDTH || y >= MAP\_HEIGHT ||
x < 0 || y < 0) || (mapdata[y][x] == l)
|| (mapdata[y][x] != c))
return;
mapdata[y][x] = l;
b(t, x - 1, y, c, l);
b(t, x + 1, y, c, l);
b(t, x, y - 1, c, l);
b(t, x, y + 1, c, l);
}
void e(int t, int x, int y, int c, int l) {
if ((x >= TEXTURE\_WIDTH || y >= TEXTURE\_HEIGHT ||
x < 0 || y < 0) ||
(textures[t][y][x] == l) ||
(textures[t][y][x] != c))
return;
textures[t][y][x] = l;
e(t, x - 1, y, c, l);
e(t, x + 1, y, c, l);
e(t, x, y - 1, c, l);
e(t, x, y + 1, c, l);
}
void k(int t, int x, int y, int c, int l) {
while (c--) {
textures[t][y][x++] = l;
textures[t][y++][x++] = l;
}
}
void r(int t, int x, int y, int c, int l) {
while (c--) {
textures[t][y][x--] = l;
textures[t][y++][x--] = l;
}
}
void u(int t, int x, int y, int c, int l) {
while (c--)
textures[t][y++][x] = l;
}
char \*z[8] = {
(char[]) {4},
(char[]) {6, 1 \* 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16, 0, 0,
21 + 0 \* 3 - 0, 16, 1, 63, 21 + 0 \* 3 - 0, 16, 2,
63 \* 0, 21 - 0, 4, 2, 31 + 0, 36 - 0, 4, 0 + 1,
32 - 1, 5 - 0, 16, 0, 0, 21 + 1 \* 3 - 0, 16, 1, 63,
21 + 1 \* 3 - 0, 16, 2, 63 \* 1, 21 - 0, 4, 2, 31 + 1,
36 - 0, 4, 6, 1 \* 4 + 0, 3, 31, 8 - 0, 6, 1 \* 4 + 2,
3, 33, 38 - 0, 6, 1 \* 4 + 3, 3, 30, 38 - 0, 4},
(char[]) {5, 1},
(char[]) {6, 0 \* 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16,
0, 0, 21 + 0 \* 3 - 0, 16, 1, 63,
21 + 0 \* 3 - 0, 16, 2, 63 \* 0, 21 - 0,
4, 2, 31 + 0, 36 - 0, 4, 0 + 1, 32 - 1,
5 - 0, 16, 0, 0, 21 + 1 \* 3 - 0, 16, 1,
63, 21 + 1 \* 3 - 0, 16, 2, 63 \* 1,
21 - 0, 4, 2, 31 + 1, 36 - 0, 4, 6,
0 \* 4 + 0, 3, 31, 8 - 0, 6, 0 \* 4 + 2,
3, 33, 38 - 0, 6, 0 \* 4 + 3, 3, 30,
38 - 0,
4},
(char[]) {4},
(char[]) {4},
(char[]) {6, 2 \* 4 + 1, 0 + 0, 32 - 0, 5 - 3, 16, 0, 0,
21 + 0 \* 3 - 3, 16, 1, 63, 21 + 0 \* 3 - 3, 16, 2, 63 \* 0,
21 - 3, 4, 2, 31 + 0, 36 - 3, 4, 0 + 1, 32 - 1, 5 - 3,
16, 0, 0, 21 + 1 \* 3 - 3, 16, 1, 63, 21 + 1 \* 3 - 3, 16,
2, 63 \* 1, 21 - 3, 4, 2, 31 + 1, 36 - 3, 4, 6, 2 \* 4 + 0,
3, 31, 8 - 3, 6, 2 \* 4 + 2, 3, 33, 38 - 3, 6, 2 \* 4 + 3,
3, 30, 38 - 3, 4},
(char[]) {6, 13, 0, 32, 9 + 0, 12 - 0,
0, 8 + 0 + 0, 21, 12 - 0, 1,
31, 9 + 0, 12 - 0, 1,
55 - 0 - 0, 21, 12 - 0, 0,
32, 9 + 3, 12 - 3, 0,
8 + 3 + 3, 21, 12 - 3, 1,
31, 9 + 3, 12 - 3, 1,
55 - 3 - 3, 21, 12 - 3, 6,
14 + 0, 2, 31 + 0, 13, 4,
1 - 0, 31 + 0, 16, 7, 3,
30 + 3 \* 0, 14, 6,
12 + 0 \* 4, 3, 32 - 0,
11 + 0 \* 8, 6, 14 + 1, 2,
31 + 1, 13, 4, 1 - 1,
31 + 1, 16, 7, 3,
30 + 3 \* 1, 14, 6,
12 + 1 \* 4, 3, 32 - 1,
11 + 1 \* 8,
4}
};
int main(int a, char \*s[]) {
display = XOpenDisplay(0);
window = XCreateSimpleWindow(display,
RootWindow(display, DefaultScreen(display)),
0, 0, IMAGE\_WIDTH, IMAGE\_HEIGHT, 1, 0, 0);
image = XCreateImage(display,
DefaultVisual(display, DefaultScreen(display)),
DefaultDepth(display, DefaultScreen(display)),
2, 0, (char \*) pixdata, IMAGE\_WIDTH, IMAGE\_HEIGHT, 32, 0);
for (int i = 0; i < 8; i++) {
char \*p = z[i];
int c = 0;
while (\*p != 4) {
switch (\*p) {
case 0:
k(i, p[1], p[2], p[3], c);
p += 4;
break;
case 1:
r(i, p[1], p[2], p[3], c);
p += 4;
break;
case 2:
u(i, p[1], p[2], p[3], c);
p += 4;
break;
case 3:
e(i, p[1]
, p[2], 0, c);
p += 3;
break;
case 5:
p = z[p[1]];
break;
case 6:
c = \_x[p[1] / 4] - 1643277 \* (p[1] % 4);
p += 2;
break;
}
}
}
while (a++) {
\_map\_read(s[1]);
\_map\_wire\_inputs();
\_map\_wire\_counter(a);
\_map\_process\_gates();
\_image\_reset();
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
\_texture\_draw(((mapdata[y][x] >> 4) & 1) << 2 | (mapdata[y][x] & 3), x, y);
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if ((x % 14 == 2) && (y % 4 == 3))
\_texture\_draw(7, x, y);
for (int y = 0; y < IMAGE\_HEIGHT; y++)
for (int x = 0; x < IMAGE\_WIDTH; x++) {
pixdata[y][x] &= 14737632 | (31 << ((x % 3) << 3));
pixdata[y][x] += 986895 & (rn \*= 16777619);
}
XPutImage(display, window,
DefaultGC(display, DefaultScreen(display)),
image, 0, 0, 0, 0, IMAGE\_WIDTH, IMAGE\_HEIGHT);
XMapWindow(display, window);
XFlush(display);
sleep(1);
}
return 0;
}
```
Для того, чтобы закончить обработку работы с «mapdata» нужно ответить еще на два вопроса — что такое функция «b»:
```
void b(int t, int x, int y, int c, int l) {
if ((x >= MAP_WIDTH || y >= MAP_HEIGHT ||
x < 0 || y < 0) || (mapdata[y][x] == l)
|| (mapdata[y][x] != c))
return;
mapdata[y][x] = l;
b(t, x - 1, y, c, l);
b(t, x + 1, y, c, l);
b(t, x, y - 1, c, l);
b(t, x, y + 1, c, l);
}
```
И что происходит в блоке:
```
for (int y = 0; y < MAP_HEIGHT; y++)
for (int x = 0; x < MAP_WIDTH; x++)
_texture_draw(((mapdata[y][x] >> 4) & 1) << 2 | (mapdata[y][x] & 3), x, y);
```
#### Функция «b»
Если внимательно присмотреться к функции «b», то можно заметить, что она до боли похожа на реализацию алгоритма [flood\_fill](https://en.wikipedia.org/wiki/Flood_fill), что совпадает с ее теоретическим назначением — она «заливает» «провод» нужным состоянием, позволяя распространять фронт волны тока до конца провода. Переименуем ее и вынесем в блок «production ready».
**Flood fill**
```
#include
#include
#include
#include
#include
/\* Код после рефакторинга \*/
/\*! \brief Ширина изображения в пикселях \*/
#define IMAGE\_WIDTH (1220)
/\*! \brief Высота изображения в пикселях \*/
#define IMAGE\_HEIGHT (616)
/\*! \brief Сдвиг верхней грани карты от левой стороны \*/
#define IMAGE\_SHIFTX (580)
/\*! \brief Количество текстур \*/
#define TEXTURE\_COUNT (8)
/\*! \brief Ширина текстуры в пикселях \*/
#define TEXTURE\_WIDTH (64)
/\*! \brief Высота текстур в пикселях \*/
#define TEXTURE\_HEIGHT (40)
/\*! \brief Ширина грани текстуры в пикселях \*/
#define TEXTURE\_TOP\_WIDTH (64)
/\*! \brief Высота грани текстуры в пикселях \*/
#define TEXTURE\_TOP\_HEIGHT (32)
/\*! \brief Ширина эмулируемого поля \*/
#define MAP\_WIDTH (19)
/\*! \brief Высота эмулируемого поля \*/
#define MAP\_HEIGHT (19)
/\*! \brief Количество данные в файле-чертеже. Один байт добавлен для символа '\n' \*/
#define MAP\_FILEDATA ((MAP\_WIDTH + 1) \* MAP\_HEIGHT)
/\*! \brief Количество итераций во время расчета NOR-узлов \*/
#define MAP\_ITERATIONS (20)
/\*! \brief Содержит структуры синтаксиса файла-конфигурации \*/
enum map\_characters {
MAPCHAR\_WIRE = '.', /\*\*< Провод (ASCII = 46) \*/
MAPCHAR\_PLUS = '+', /\*\*< Провод (есть ток) (ASCII = 43) \*/
MAPCHAR\_MINUS = '-', /\*\*< Провод (нет тока) (ASCII = 45) \*/
MAPCHAR\_NOR = '>', /\*\*< NOR-элемент (ASCII = 62) \*/
};
/\*! \brief Бинарные данные пикселей изображения.
\* Типизированы к int для оперирования пикселями вместо каналов \*/
int pixdata[IMAGE\_HEIGHT][IMAGE\_WIDTH];
/\*! \brief Текстуры блоков, отображаемых на поле \*/
int textures[TEXTURE\_COUNT][TEXTURE\_HEIGHT][TEXTURE\_WIDTH] = { 0 };
/\*! \brief Данные эмулируемого поля.
\* Один байт добавлен для упрощения обработки символа '\n' \*/
char mapdata[MAP\_HEIGHT][MAP\_WIDTH + 1];
/\*! \brief Экземпляр дисплея Xlib \*/
Display \* display;
/\*! \brief Экземпляр главного окна Xlib \*/
Window window;
/\*! \brief Изображение для вывода на экран \*/
XImage \* image;
/\* \brief Обнуляет изображение, заполняя его черным цветом \*/
static void \_image\_reset(void) {
for (int y = 0; y < IMAGE\_HEIGHT; y++)
for (int x = 0; x < IMAGE\_WIDTH; x++)
pixdata[y][x] = 0;
}
/\*! \brief Отрисовывает текстуру на главном холсте по указанным координатам
\* \param[in] t Индекс текстуры
\* \param[in] x X координата тайла
\* \param[in] y Y координата тайла \*/
static void \_texture\_draw(int t, int x, int y) {
for (int ty = 0; ty < TEXTURE\_HEIGHT; ty++)
for (int tx = 0; tx < TEXTURE\_WIDTH; tx++)
if (textures[t][ty][tx])
pixdata[ty +
y \* (TEXTURE\_TOP\_HEIGHT / 2) +
x \* (TEXTURE\_TOP\_HEIGHT / 2)]
[tx +
IMAGE\_SHIFTX +
x \* (TEXTURE\_TOP\_WIDTH / 2) -
y \* TEXTURE\_TOP\_HEIGHT] = textures[t][ty][tx];
}
/\*! \brief Читает данные файла-чертежа и загружает их в карту
\* \param[in] filename Имя файла-чертежа \*/
static void \_map\_read(const char \* filename) {
int f = open(filename, 0);
read(f, mapdata, MAP\_FILEDATA);
close(f);
}
/\*! \brief Заменяет иллюстративные входы из файла-конфигурации на вход
\* в виде провода чтобы работала логика распространения фронта волны \*/
static void \_map\_wire\_inputs(void) {
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if ((x % 14 == 2) && (y % 4 == 3))
mapdata[y][x] = MAPCHAR\_WIRE;
}
/\*! \brief Производит заливку проводника нужным состоянием
\* \param[in] t Игнорируется, артефакт автогенерации кода
\* \param[in] x X-координата заливки
\* \param[in] y Y-координата заливки
\* \param[in] c Исходное состояние
\* \param[in] l Целевое состояние \*/
static void \_map\_fill(int t, int x, int y, int c, int l) {
if ((x >= MAP\_WIDTH || y >= MAP\_HEIGHT ||
x < 0 || y < 0) || (mapdata[y][x] == l)
|| (mapdata[y][x] != c))
return;
mapdata[y][x] = l;
\_map\_fill(t, x - 1, y, c, l);
\_map\_fill(t, x + 1, y, c, l);
\_map\_fill(t, x, y - 1, c, l);
\_map\_fill(t, x, y + 1, c, l);
}
/\*! \brief Включает соответствующие входы схемы в зависимости от значения
\* счетчика.
\* \param[in] counter Счетчик \*/
static void \_map\_wire\_counter(int counter) {
\_map\_fill(0, 2, 3, mapdata[3][2], counter & 1 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
\_map\_fill(0, 2, 7, mapdata[7][2], counter & 2 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
\_map\_fill(0, 2, 11, mapdata[11][2], counter & 4 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
\_map\_fill(0, 2, 15, mapdata[15][2], counter & 8 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
}
/\*! \brief Проводит расчет выходного (результирующего) тока после NOR-узла \*/
static void \_map\_process\_gates(void) {
for (int i = 0; i < MAP\_ITERATIONS; i++)
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if (mapdata[y][x] == MAPCHAR\_NOR)
\_map\_fill(0, x + 1, y, mapdata[y][x + 1],
!(mapdata[y - 1][x] == MAPCHAR\_PLUS ? 1 : 0
|| mapdata[y + 1][x] == MAPCHAR\_PLUS ? 1 : 0) ?
MAPCHAR\_PLUS : MAPCHAR\_MINUS);
}
/\* Код до рефакторинга \*/
int \_x[] = { 15117427, 8413248, 5878632, 13027014, 1 };
int rn = 2166136261;
void \*T;
void e(int t, int x, int y, int c, int l) {
if ((x >= TEXTURE\_WIDTH || y >= TEXTURE\_HEIGHT ||
x < 0 || y < 0) ||
(textures[t][y][x] == l) ||
(textures[t][y][x] != c))
return;
textures[t][y][x] = l;
e(t, x - 1, y, c, l);
e(t, x + 1, y, c, l);
e(t, x, y - 1, c, l);
e(t, x, y + 1, c, l);
}
void k(int t, int x, int y, int c, int l) {
while (c--) {
textures[t][y][x++] = l;
textures[t][y++][x++] = l;
}
}
void r(int t, int x, int y, int c, int l) {
while (c--) {
textures[t][y][x--] = l;
textures[t][y++][x--] = l;
}
}
void u(int t, int x, int y, int c, int l) {
while (c--)
textures[t][y++][x] = l;
}
char \*z[8] = {
(char[]) {4},
(char[]) {6, 1 \* 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16, 0, 0,
21 + 0 \* 3 - 0, 16, 1, 63, 21 + 0 \* 3 - 0, 16, 2,
63 \* 0, 21 - 0, 4, 2, 31 + 0, 36 - 0, 4, 0 + 1,
32 - 1, 5 - 0, 16, 0, 0, 21 + 1 \* 3 - 0, 16, 1, 63,
21 + 1 \* 3 - 0, 16, 2, 63 \* 1, 21 - 0, 4, 2, 31 + 1,
36 - 0, 4, 6, 1 \* 4 + 0, 3, 31, 8 - 0, 6, 1 \* 4 + 2,
3, 33, 38 - 0, 6, 1 \* 4 + 3, 3, 30, 38 - 0, 4},
(char[]) {5, 1},
(char[]) {6, 0 \* 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16,
0, 0, 21 + 0 \* 3 - 0, 16, 1, 63,
21 + 0 \* 3 - 0, 16, 2, 63 \* 0, 21 - 0,
4, 2, 31 + 0, 36 - 0, 4, 0 + 1, 32 - 1,
5 - 0, 16, 0, 0, 21 + 1 \* 3 - 0, 16, 1,
63, 21 + 1 \* 3 - 0, 16, 2, 63 \* 1,
21 - 0, 4, 2, 31 + 1, 36 - 0, 4, 6,
0 \* 4 + 0, 3, 31, 8 - 0, 6, 0 \* 4 + 2,
3, 33, 38 - 0, 6, 0 \* 4 + 3, 3, 30,
38 - 0,
4},
(char[]) {4},
(char[]) {4},
(char[]) {6, 2 \* 4 + 1, 0 + 0, 32 - 0, 5 - 3, 16, 0, 0,
21 + 0 \* 3 - 3, 16, 1, 63, 21 + 0 \* 3 - 3, 16, 2, 63 \* 0,
21 - 3, 4, 2, 31 + 0, 36 - 3, 4, 0 + 1, 32 - 1, 5 - 3,
16, 0, 0, 21 + 1 \* 3 - 3, 16, 1, 63, 21 + 1 \* 3 - 3, 16,
2, 63 \* 1, 21 - 3, 4, 2, 31 + 1, 36 - 3, 4, 6, 2 \* 4 + 0,
3, 31, 8 - 3, 6, 2 \* 4 + 2, 3, 33, 38 - 3, 6, 2 \* 4 + 3,
3, 30, 38 - 3, 4},
(char[]) {6, 13, 0, 32, 9 + 0, 12 - 0,
0, 8 + 0 + 0, 21, 12 - 0, 1,
31, 9 + 0, 12 - 0, 1,
55 - 0 - 0, 21, 12 - 0, 0,
32, 9 + 3, 12 - 3, 0,
8 + 3 + 3, 21, 12 - 3, 1,
31, 9 + 3, 12 - 3, 1,
55 - 3 - 3, 21, 12 - 3, 6,
14 + 0, 2, 31 + 0, 13, 4,
1 - 0, 31 + 0, 16, 7, 3,
30 + 3 \* 0, 14, 6,
12 + 0 \* 4, 3, 32 - 0,
11 + 0 \* 8, 6, 14 + 1, 2,
31 + 1, 13, 4, 1 - 1,
31 + 1, 16, 7, 3,
30 + 3 \* 1, 14, 6,
12 + 1 \* 4, 3, 32 - 1,
11 + 1 \* 8,
4}
};
int main(int a, char \*s[]) {
display = XOpenDisplay(0);
window = XCreateSimpleWindow(display,
RootWindow(display, DefaultScreen(display)),
0, 0, IMAGE\_WIDTH, IMAGE\_HEIGHT, 1, 0, 0);
image = XCreateImage(display,
DefaultVisual(display, DefaultScreen(display)),
DefaultDepth(display, DefaultScreen(display)),
2, 0, (char \*) pixdata, IMAGE\_WIDTH, IMAGE\_HEIGHT, 32, 0);
for (int i = 0; i < 8; i++) {
char \*p = z[i];
int c = 0;
while (\*p != 4) {
switch (\*p) {
case 0:
k(i, p[1], p[2], p[3], c);
p += 4;
break;
case 1:
r(i, p[1], p[2], p[3], c);
p += 4;
break;
case 2:
u(i, p[1], p[2], p[3], c);
p += 4;
break;
case 3:
e(i, p[1]
, p[2], 0, c);
p += 3;
break;
case 5:
p = z[p[1]];
break;
case 6:
c = \_x[p[1] / 4] - 1643277 \* (p[1] % 4);
p += 2;
break;
}
}
}
while (a++) {
\_map\_read(s[1]);
\_map\_wire\_inputs();
\_map\_wire\_counter(a);
\_map\_process\_gates();
\_image\_reset();
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
\_texture\_draw(((mapdata[y][x] >> 4) & 1) << 2 | (mapdata[y][x] & 3), x, y);
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if ((x % 14 == 2) && (y % 4 == 3))
\_texture\_draw(7, x, y);
for (int y = 0; y < IMAGE\_HEIGHT; y++)
for (int x = 0; x < IMAGE\_WIDTH; x++) {
pixdata[y][x] &= 14737632 | (31 << ((x % 3) << 3));
pixdata[y][x] += 986895 & (rn \*= 16777619);
}
XPutImage(display, window,
DefaultGC(display, DefaultScreen(display)),
image, 0, 0, 0, 0, IMAGE\_WIDTH, IMAGE\_HEIGHT);
XMapWindow(display, window);
XFlush(display);
sleep(1);
}
return 0;
}
```
#### Странный блок
Теперь осталось разобрать, что происходит в строке:
```
_texture_draw(((mapdata[y][x] >> 4) & 1) << 2 | (mapdata[y][x] & 3), x, y);
```
Так как мы уже построили полную таблицу состояний, которые могут находиться внутри mapdata то мы можем получить все выходные значения первого параметра:
| enum | int | Результат |
| --- | --- | --- |
| MAPCHAR\_WIRE | 46 | 2 |
| MAPCHAR\_PLUS | 43 | 3 |
| MAPCHAR\_MINUS | 45 | 1 |
| MAPCHAR\_NOR | 62 | 6 |
| MAPCHAR\_EMPTY | 32 | 0 |
Ага, то есть по итогам этого преобразования мы получаем индекс текстуры в массиве текстур.
> Для того, чтобы продумать механизм генерации из читаемого и ассоциативно понятного набора символов в индексы текстур понадобилась пара часов. Я выписал символы, которые могли означать провода и NOR-элементы а потом расписав их двоичные значения обводил кружочками уникальные области. Кроме текущего был второй вариант с более сложными вычислениями, но он длиннее, следовательно не подошел по лимиту токенов.
Замечательно, это дает нам возможность вычленить еще одну функцию и объявить enum для каждой текстуры:
**После очередного рефакторинга:**
```
#include
#include
#include
#include
#include
/\* Код после рефакторинга \*/
/\*! \brief Ширина изображения в пикселях \*/
#define IMAGE\_WIDTH (1220)
/\*! \brief Высота изображения в пикселях \*/
#define IMAGE\_HEIGHT (616)
/\*! \brief Сдвиг верхней грани карты от левой стороны \*/
#define IMAGE\_SHIFTX (580)
/\*! \brief Количество текстур \*/
#define TEXTURE\_COUNT (8)
/\*! \brief Ширина текстуры в пикселях \*/
#define TEXTURE\_WIDTH (64)
/\*! \brief Высота текстур в пикселях \*/
#define TEXTURE\_HEIGHT (40)
/\*! \brief Ширина грани текстуры в пикселях \*/
#define TEXTURE\_TOP\_WIDTH (64)
/\*! \brief Высота грани текстуры в пикселях \*/
#define TEXTURE\_TOP\_HEIGHT (32)
/\*! \brief Ширина эмулируемого поля \*/
#define MAP\_WIDTH (19)
/\*! \brief Высота эмулируемого поля \*/
#define MAP\_HEIGHT (19)
/\*! \brief Количество данные в файле-чертеже. Один байт добавлен для символа '\n' \*/
#define MAP\_FILEDATA ((MAP\_WIDTH + 1) \* MAP\_HEIGHT)
/\*! \brief Количество итераций во время расчета NOR-узлов \*/
#define MAP\_ITERATIONS (20)
/\*! \brief Содержит структуры синтаксиса файла-конфигурации \*/
enum map\_characters {
MAPCHAR\_WIRE = '.', /\*\*< Провод (ASCII = 46) \*/
MAPCHAR\_PLUS = '+', /\*\*< Провод (есть ток) (ASCII = 43) \*/
MAPCHAR\_MINUS = '-', /\*\*< Провод (нет тока) (ASCII = 45) \*/
MAPCHAR\_NOR = '>', /\*\*< NOR-элемент (ASCII = 62) \*/
MAPCHAR\_EMPTY = ' ', /\*\*< Пустой блок (ASCII = 32) \*/
};
/\*! \brief Содержит индексы текстур \*/
enum textures\_indexes {
TEXINDEX\_EMPTY = (0), /\*\*< Индекс пустой текстуры \*/
TEXINDEX\_MINUS = (1), /\*\*< Индекс текстуры "выключенного провода" \*/
TEXINDEX\_WIRE = (2), /\*\*< Индекс текстуры нейтрального провода \*/
TEXINDEX\_PLUS = (3), /\*\*< Индекс текстуры "включенного" провода \*/
/\*\*/
TEXINDEX\_NOR = (6) /\*\*< Индекс текстуры NOR-элемента \*/
};
/\*! \brief Аргументы программы \*/
enum program\_arguments {
ARG\_PROGRAM, /\*\*< Имя самой программы \*/
ARG\_BLUEPRINT /\*\*< Имя файла-чертежа \*/
};
/\*! \brief Бинарные данные пикселей изображения.
\* Типизированы к int для оперирования пикселями вместо каналов \*/
int pixdata[IMAGE\_HEIGHT][IMAGE\_WIDTH];
/\*! \brief Текстуры блоков, отображаемых на поле \*/
int textures[TEXTURE\_COUNT][TEXTURE\_HEIGHT][TEXTURE\_WIDTH] = { 0 };
/\*! \brief Данные эмулируемого поля.
\* Один байт добавлен для упрощения обработки символа '\n' \*/
char mapdata[MAP\_HEIGHT][MAP\_WIDTH + 1];
/\*! \brief Экземпляр дисплея Xlib \*/
Display \* display;
/\*! \brief Экземпляр главного окна Xlib \*/
Window window;
/\*! \brief Изображение для вывода на экран \*/
XImage \* image;
/\* \brief Обнуляет изображение, заполняя его черным цветом \*/
static void \_image\_reset(void) {
for (int y = 0; y < IMAGE\_HEIGHT; y++)
for (int x = 0; x < IMAGE\_WIDTH; x++)
pixdata[y][x] = 0;
}
/\*! \brief Конвертирует символ из чертежа в индекс текстуры
\* \param[in] elem Символ чертежа
\* \return Индекс текстуры \*/
static int \_map2texture(char elem) {
return ((elem >> 4) & 1) << 2 | (elem & 3);
}
/\*! \brief Собирает изображение из отдельных тайлов согласно карте \*/
static void \_image\_compile(void) {
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
\_texture\_draw(\_map2texture(mapdata[y][x]), x, y);
}
/\*! \brief Рисует изображение на экране \*/
static void \_image\_draw(void) {
XPutImage(display, window,
DefaultGC(display, DefaultScreen(display)),
image, 0, 0, 0, 0, IMAGE\_WIDTH, IMAGE\_HEIGHT);
XMapWindow(display, window);
XFlush(display);
}
/\*! \brief Отрисовывает текстуру на главном холсте по указанным координатам
\* \param[in] t Индекс текстуры
\* \param[in] x X координата тайла
\* \param[in] y Y координата тайла \*/
static void \_texture\_draw(int t, int x, int y) {
for (int ty = 0; ty < TEXTURE\_HEIGHT; ty++)
for (int tx = 0; tx < TEXTURE\_WIDTH; tx++)
if (textures[t][ty][tx])
pixdata[ty +
y \* (TEXTURE\_TOP\_HEIGHT / 2) +
x \* (TEXTURE\_TOP\_HEIGHT / 2)]
[tx +
IMAGE\_SHIFTX +
x \* (TEXTURE\_TOP\_WIDTH / 2) -
y \* TEXTURE\_TOP\_HEIGHT] = textures[t][ty][tx];
}
/\*! \brief Читает данные файла-чертежа и загружает их в карту
\* \param[in] filename Имя файла-чертежа \*/
static void \_map\_read(const char \* filename) {
int f = open(filename, 0);
read(f, mapdata, MAP\_FILEDATA);
close(f);
}
/\*! \brief Заменяет иллюстративные входы из файла-конфигурации на вход
\* в виде провода чтобы работала логика распространения фронта волны \*/
static void \_map\_wire\_inputs(void) {
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if ((x % 14 == 2) && (y % 4 == 3))
mapdata[y][x] = MAPCHAR\_WIRE;
}
/\*! \brief Производит заливку проводника нужным состоянием
\* \param[in] t Игнорируется, артефакт автогенерации кода
\* \param[in] x X-координата заливки
\* \param[in] y Y-координата заливки
\* \param[in] c Исходное состояние
\* \param[in] l Целевое состояние \*/
static void \_map\_fill(int t, int x, int y, int c, int l) {
if ((x >= MAP\_WIDTH || y >= MAP\_HEIGHT ||
x < 0 || y < 0) || (mapdata[y][x] == l)
|| (mapdata[y][x] != c))
return;
mapdata[y][x] = l;
\_map\_fill(t, x - 1, y, c, l);
\_map\_fill(t, x + 1, y, c, l);
\_map\_fill(t, x, y - 1, c, l);
\_map\_fill(t, x, y + 1, c, l);
}
/\*! \brief Включает соответствующие входы схемы в зависимости от значения
\* счетчика.
\* \param[in] counter Счетчик \*/
static void \_map\_wire\_counter(int counter) {
\_map\_fill(0, 2, 3, mapdata[3][2], counter & 1 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
\_map\_fill(0, 2, 7, mapdata[7][2], counter & 2 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
\_map\_fill(0, 2, 11, mapdata[11][2], counter & 4 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
\_map\_fill(0, 2, 15, mapdata[15][2], counter & 8 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
}
/\*! \brief Проводит расчет выходного (результирующего) тока после NOR-узла \*/
static void \_map\_process\_gates(void) {
for (int i = 0; i < MAP\_ITERATIONS; i++)
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if (mapdata[y][x] == MAPCHAR\_NOR)
\_map\_fill(0, x + 1, y, mapdata[y][x + 1],
!(mapdata[y - 1][x] == MAPCHAR\_PLUS ? 1 : 0
|| mapdata[y + 1][x] == MAPCHAR\_PLUS ? 1 : 0) ?
MAPCHAR\_PLUS : MAPCHAR\_MINUS);
}
/\* Код до рефакторинга \*/
int \_x[] = { 15117427, 8413248, 5878632, 13027014, 1 };
int rn = 2166136261;
void \*T;
void e(int t, int x, int y, int c, int l) {
if ((x >= TEXTURE\_WIDTH || y >= TEXTURE\_HEIGHT ||
x < 0 || y < 0) ||
(textures[t][y][x] == l) ||
(textures[t][y][x] != c))
return;
textures[t][y][x] = l;
e(t, x - 1, y, c, l);
e(t, x + 1, y, c, l);
e(t, x, y - 1, c, l);
e(t, x, y + 1, c, l);
}
void k(int t, int x, int y, int c, int l) {
while (c--) {
textures[t][y][x++] = l;
textures[t][y++][x++] = l;
}
}
void r(int t, int x, int y, int c, int l) {
while (c--) {
textures[t][y][x--] = l;
textures[t][y++][x--] = l;
}
}
void u(int t, int x, int y, int c, int l) {
while (c--)
textures[t][y++][x] = l;
}
char \*z[8] = {
(char[]) {4},
(char[]) {6, 1 \* 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16, 0, 0,
21 + 0 \* 3 - 0, 16, 1, 63, 21 + 0 \* 3 - 0, 16, 2,
63 \* 0, 21 - 0, 4, 2, 31 + 0, 36 - 0, 4, 0 + 1,
32 - 1, 5 - 0, 16, 0, 0, 21 + 1 \* 3 - 0, 16, 1, 63,
21 + 1 \* 3 - 0, 16, 2, 63 \* 1, 21 - 0, 4, 2, 31 + 1,
36 - 0, 4, 6, 1 \* 4 + 0, 3, 31, 8 - 0, 6, 1 \* 4 + 2,
3, 33, 38 - 0, 6, 1 \* 4 + 3, 3, 30, 38 - 0, 4},
(char[]) {5, 1},
(char[]) {6, 0 \* 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16,
0, 0, 21 + 0 \* 3 - 0, 16, 1, 63,
21 + 0 \* 3 - 0, 16, 2, 63 \* 0, 21 - 0,
4, 2, 31 + 0, 36 - 0, 4, 0 + 1, 32 - 1,
5 - 0, 16, 0, 0, 21 + 1 \* 3 - 0, 16, 1,
63, 21 + 1 \* 3 - 0, 16, 2, 63 \* 1,
21 - 0, 4, 2, 31 + 1, 36 - 0, 4, 6,
0 \* 4 + 0, 3, 31, 8 - 0, 6, 0 \* 4 + 2,
3, 33, 38 - 0, 6, 0 \* 4 + 3, 3, 30,
38 - 0,
4},
(char[]) {4},
(char[]) {4},
(char[]) {6, 2 \* 4 + 1, 0 + 0, 32 - 0, 5 - 3, 16, 0, 0,
21 + 0 \* 3 - 3, 16, 1, 63, 21 + 0 \* 3 - 3, 16, 2, 63 \* 0,
21 - 3, 4, 2, 31 + 0, 36 - 3, 4, 0 + 1, 32 - 1, 5 - 3,
16, 0, 0, 21 + 1 \* 3 - 3, 16, 1, 63, 21 + 1 \* 3 - 3, 16,
2, 63 \* 1, 21 - 3, 4, 2, 31 + 1, 36 - 3, 4, 6, 2 \* 4 + 0,
3, 31, 8 - 3, 6, 2 \* 4 + 2, 3, 33, 38 - 3, 6, 2 \* 4 + 3,
3, 30, 38 - 3, 4},
(char[]) {6, 13, 0, 32, 9 + 0, 12 - 0,
0, 8 + 0 + 0, 21, 12 - 0, 1,
31, 9 + 0, 12 - 0, 1,
55 - 0 - 0, 21, 12 - 0, 0,
32, 9 + 3, 12 - 3, 0,
8 + 3 + 3, 21, 12 - 3, 1,
31, 9 + 3, 12 - 3, 1,
55 - 3 - 3, 21, 12 - 3, 6,
14 + 0, 2, 31 + 0, 13, 4,
1 - 0, 31 + 0, 16, 7, 3,
30 + 3 \* 0, 14, 6,
12 + 0 \* 4, 3, 32 - 0,
11 + 0 \* 8, 6, 14 + 1, 2,
31 + 1, 13, 4, 1 - 1,
31 + 1, 16, 7, 3,
30 + 3 \* 1, 14, 6,
12 + 1 \* 4, 3, 32 - 1,
11 + 1 \* 8,
4}
};
int main(int argc, char \* args[]) {
display = XOpenDisplay(0);
window = XCreateSimpleWindow(display,
RootWindow(display, DefaultScreen(display)),
0, 0, IMAGE\_WIDTH, IMAGE\_HEIGHT, 1, 0, 0);
image = XCreateImage(display,
DefaultVisual(display, DefaultScreen(display)),
DefaultDepth(display, DefaultScreen(display)),
2, 0, (char \*) pixdata, IMAGE\_WIDTH, IMAGE\_HEIGHT, 32, 0);
for (int i = 0; i < 8; i++) {
char \*p = z[i];
int c = 0;
while (\*p != 4) {
switch (\*p) {
case 0:
k(i, p[1], p[2], p[3], c);
p += 4;
break;
case 1:
r(i, p[1], p[2], p[3], c);
p += 4;
break;
case 2:
u(i, p[1], p[2], p[3], c);
p += 4;
break;
case 3:
e(i, p[1]
, p[2], 0, c);
p += 3;
break;
case 5:
p = z[p[1]];
break;
case 6:
c = \_x[p[1] / 4] - 1643277 \* (p[1] % 4);
p += 2;
break;
}
}
}
unsigned int counter = 0;
while (counter++) {
\_map\_read(args[ARG\_BLUEPRINT]);
\_map\_wire\_inputs();
\_map\_wire\_counter(counter);
\_map\_process\_gates();
\_image\_reset();
\_image\_compile();
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if ((x % 14 == 2) && (y % 4 == 3))
\_texture\_draw(7, x, y);
for (int y = 0; y < IMAGE\_HEIGHT; y++)
for (int x = 0; x < IMAGE\_WIDTH; x++) {
pixdata[y][x] &= 14737632 | (31 << ((x % 3) << 3));
pixdata[y][x] += 986895 & (rn \*= 16777619);
}
\_image\_draw();
sleep(1);
}
return 0;
}
```
#### Текстура #7
Если присмотреться к массиву «z», то можно заметить, что он содержит 8 блоков данных, как константа количества текстур. И в нем даже есть два пробела на позициях 4 и 5, прямо как в нашем enum, скорее всего это данные текстур. Однако он содержит 8 изображений, а мы смогли «открыть» только 7. Однако, если мы будем достаточно внимательными, то мы сможем заметить, что есть участок кода, который рисует конкретно 7ю текстуру:
```
for (int y = 0; y < MAP_HEIGHT; y++)
for (int x = 0; x < MAP_WIDTH; x++)
if ((x % 14 == 2) && (y % 4 == 3))
_texture_draw(7, x, y);
```
По позиции уже можно догадаться, что это, но закомментируем эти строки и запустим приложение:
До:
После:
Теперь мы точно знаем, что это текстура отверстия на плате и можем добавить ее в список enum, вынеся её отрисовку в отдельную функцию:
**Все текстуры в сборе:**
```
#include
#include
#include
#include
#include
/\* Код после рефакторинга \*/
/\*! \brief Ширина изображения в пикселях \*/
#define IMAGE\_WIDTH (1220)
/\*! \brief Высота изображения в пикселях \*/
#define IMAGE\_HEIGHT (616)
/\*! \brief Сдвиг верхней грани карты от левой стороны \*/
#define IMAGE\_SHIFTX (580)
/\*! \brief Количество текстур \*/
#define TEXTURE\_COUNT (8)
/\*! \brief Ширина текстуры в пикселях \*/
#define TEXTURE\_WIDTH (64)
/\*! \brief Высота текстур в пикселях \*/
#define TEXTURE\_HEIGHT (40)
/\*! \brief Ширина грани текстуры в пикселях \*/
#define TEXTURE\_TOP\_WIDTH (64)
/\*! \brief Высота грани текстуры в пикселях \*/
#define TEXTURE\_TOP\_HEIGHT (32)
/\*! \brief Ширина эмулируемого поля \*/
#define MAP\_WIDTH (19)
/\*! \brief Высота эмулируемого поля \*/
#define MAP\_HEIGHT (19)
/\*! \brief Количество данные в файле-чертеже. Один байт добавлен для символа '\n' \*/
#define MAP\_FILEDATA ((MAP\_WIDTH + 1) \* MAP\_HEIGHT)
/\*! \brief Количество итераций во время расчета NOR-узлов \*/
#define MAP\_ITERATIONS (20)
/\*! \brief Содержит структуры синтаксиса файла-конфигурации \*/
enum map\_characters {
MAPCHAR\_WIRE = '.', /\*\*< Провод (ASCII = 46) \*/
MAPCHAR\_PLUS = '+', /\*\*< Провод (есть ток) (ASCII = 43) \*/
MAPCHAR\_MINUS = '-', /\*\*< Провод (нет тока) (ASCII = 45) \*/
MAPCHAR\_NOR = '>', /\*\*< NOR-элемент (ASCII = 62) \*/
MAPCHAR\_EMPTY = ' ', /\*\*< Пустой блок (ASCII = 32) \*/
};
/\*! \brief Содержит индексы текстур \*/
enum textures\_indexes {
TEXINDEX\_EMPTY = (0), /\*\*< Индекс пустой текстуры \*/
TEXINDEX\_MINUS = (1), /\*\*< Индекс текстуры "выключенного провода" \*/
TEXINDEX\_WIRE = (2), /\*\*< Индекс текстуры нейтрального провода \*/
TEXINDEX\_PLUS = (3), /\*\*< Индекс текстуры "включенного" провода \*/
/\*\*/
TEXINDEX\_NOR = (6), /\*\*< Индекс текстуры NOR-элемента \*/
TEXINDEX\_HOLE = (7) /\*\*< Индекс текстуры отверстия на плате \*/
};
/\*! \brief Аргументы программы \*/
enum program\_arguments {
ARG\_PROGRAM, /\*\*< Имя самой программы \*/
ARG\_BLUEPRINT /\*\*< Имя файла-чертежа \*/
};
/\*! \brief Бинарные данные пикселей изображения.
\* Типизированы к int для оперирования пикселями вместо каналов \*/
int pixdata[IMAGE\_HEIGHT][IMAGE\_WIDTH];
/\*! \brief Текстуры блоков, отображаемых на поле \*/
int textures[TEXTURE\_COUNT][TEXTURE\_HEIGHT][TEXTURE\_WIDTH] = { 0 };
/\*! \brief Данные эмулируемого поля.
\* Один байт добавлен для упрощения обработки символа '\n' \*/
char mapdata[MAP\_HEIGHT][MAP\_WIDTH + 1];
/\*! \brief Экземпляр дисплея Xlib \*/
Display \* display;
/\*! \brief Экземпляр главного окна Xlib \*/
Window window;
/\*! \brief Изображение для вывода на экран \*/
XImage \* image;
static void \_texture\_draw(int t, int x, int y);
/\*! \brief Создает изображение и сопутствующие сущности \*/
static void \_image\_create(void) {
display = XOpenDisplay(0);
window = XCreateSimpleWindow(display,
RootWindow(display, DefaultScreen(display)),
0, 0, IMAGE\_WIDTH, IMAGE\_HEIGHT, 1, 0, 0);
image = XCreateImage(display,
DefaultVisual(display, DefaultScreen(display)),
DefaultDepth(display, DefaultScreen(display)),
2, 0, (char \*) pixdata, IMAGE\_WIDTH, IMAGE\_HEIGHT, 32, 0);
}
/\* \brief Обнуляет изображение, заполняя его черным цветом \*/
static void \_image\_reset(void) {
for (int y = 0; y < IMAGE\_HEIGHT; y++)
for (int x = 0; x < IMAGE\_WIDTH; x++)
pixdata[y][x] = 0;
}
/\*! \brief Конвертирует символ из чертежа в индекс текстуры
\* \param[in] elem Символ чертежа
\* \return Индекс текстуры \*/
static int \_map2texture(char elem) {
return ((elem >> 4) & 1) << 2 | (elem & 3);
}
/\*! \brief Собирает изображение из отдельных тайлов согласно карте \*/
static void \_image\_compile(void) {
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
\_texture\_draw(\_map2texture(mapdata[y][x]), x, y);
}
/\*! \brief Рисует изображение на экране \*/
static void \_image\_draw(void) {
XPutImage(display, window,
DefaultGC(display, DefaultScreen(display)),
image, 0, 0, 0, 0, IMAGE\_WIDTH, IMAGE\_HEIGHT);
XMapWindow(display, window);
XFlush(display);
}
/\*! \brief Рисует отверстия на печатной плате \*/
static void \_image\_drill(void) {
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if ((x % 14 == 2) && (y % 4 == 3))
\_texture\_draw(TEXINDEX\_HOLE, x, y);
}
/\*! \brief Отрисовывает текстуру на главном холсте по указанным координатам
\* \param[in] t Индекс текстуры
\* \param[in] x X координата тайла
\* \param[in] y Y координата тайла \*/
static void \_texture\_draw(int t, int x, int y) {
for (int ty = 0; ty < TEXTURE\_HEIGHT; ty++)
for (int tx = 0; tx < TEXTURE\_WIDTH; tx++)
if (textures[t][ty][tx])
pixdata[ty +
y \* (TEXTURE\_TOP\_HEIGHT / 2) +
x \* (TEXTURE\_TOP\_HEIGHT / 2)]
[tx +
IMAGE\_SHIFTX +
x \* (TEXTURE\_TOP\_WIDTH / 2) -
y \* TEXTURE\_TOP\_HEIGHT] = textures[t][ty][tx];
}
/\*! \brief Читает данные файла-чертежа и загружает их в карту
\* \param[in] filename Имя файла-чертежа \*/
static void \_map\_read(const char \* filename) {
int f = open(filename, 0);
read(f, mapdata, MAP\_FILEDATA);
close(f);
}
/\*! \brief Заменяет иллюстративные входы из файла-конфигурации на вход
\* в виде провода чтобы работала логика распространения фронта волны \*/
static void \_map\_wire\_inputs(void) {
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if ((x % 14 == 2) && (y % 4 == 3))
mapdata[y][x] = MAPCHAR\_WIRE;
}
/\*! \brief Производит заливку проводника нужным состоянием
\* \param[in] t Игнорируется, артефакт автогенерации кода
\* \param[in] x X-координата заливки
\* \param[in] y Y-координата заливки
\* \param[in] c Исходное состояние
\* \param[in] l Целевое состояние \*/
static void \_map\_fill(int t, int x, int y, int c, int l) {
if ((x >= MAP\_WIDTH || y >= MAP\_HEIGHT ||
x < 0 || y < 0) || (mapdata[y][x] == l)
|| (mapdata[y][x] != c))
return;
mapdata[y][x] = l;
\_map\_fill(t, x - 1, y, c, l);
\_map\_fill(t, x + 1, y, c, l);
\_map\_fill(t, x, y - 1, c, l);
\_map\_fill(t, x, y + 1, c, l);
}
/\*! \brief Включает соответствующие входы схемы в зависимости от значения
\* счетчика.
\* \param[in] counter Счетчик \*/
static void \_map\_wire\_counter(int counter) {
\_map\_fill(0, 2, 3, mapdata[3][2], counter & 1 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
\_map\_fill(0, 2, 7, mapdata[7][2], counter & 2 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
\_map\_fill(0, 2, 11, mapdata[11][2], counter & 4 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
\_map\_fill(0, 2, 15, mapdata[15][2], counter & 8 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
}
/\*! \brief Проводит расчет выходного (результирующего) тока после NOR-узла \*/
static void \_map\_process\_gates(void) {
for (int i = 0; i < MAP\_ITERATIONS; i++)
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if (mapdata[y][x] == MAPCHAR\_NOR)
\_map\_fill(0, x + 1, y, mapdata[y][x + 1],
!(mapdata[y - 1][x] == MAPCHAR\_PLUS ? 1 : 0
|| mapdata[y + 1][x] == MAPCHAR\_PLUS ? 1 : 0) ?
MAPCHAR\_PLUS : MAPCHAR\_MINUS);
}
/\* Код до рефакторинга \*/
int \_x[] = { 15117427, 8413248, 5878632, 13027014, 1 };
int rn = 2166136261;
void \*T;
void e(int t, int x, int y, int c, int l) {
if ((x >= TEXTURE\_WIDTH || y >= TEXTURE\_HEIGHT ||
x < 0 || y < 0) ||
(textures[t][y][x] == l) ||
(textures[t][y][x] != c))
return;
textures[t][y][x] = l;
e(t, x - 1, y, c, l);
e(t, x + 1, y, c, l);
e(t, x, y - 1, c, l);
e(t, x, y + 1, c, l);
}
void k(int t, int x, int y, int c, int l) {
while (c--) {
textures[t][y][x++] = l;
textures[t][y++][x++] = l;
}
}
void r(int t, int x, int y, int c, int l) {
while (c--) {
textures[t][y][x--] = l;
textures[t][y++][x--] = l;
}
}
void u(int t, int x, int y, int c, int l) {
while (c--)
textures[t][y++][x] = l;
}
char \*z[8] = {
(char[]) {4},
(char[]) {6, 1 \* 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16, 0, 0,
21 + 0 \* 3 - 0, 16, 1, 63, 21 + 0 \* 3 - 0, 16, 2,
63 \* 0, 21 - 0, 4, 2, 31 + 0, 36 - 0, 4, 0 + 1,
32 - 1, 5 - 0, 16, 0, 0, 21 + 1 \* 3 - 0, 16, 1, 63,
21 + 1 \* 3 - 0, 16, 2, 63 \* 1, 21 - 0, 4, 2, 31 + 1,
36 - 0, 4, 6, 1 \* 4 + 0, 3, 31, 8 - 0, 6, 1 \* 4 + 2,
3, 33, 38 - 0, 6, 1 \* 4 + 3, 3, 30, 38 - 0, 4},
(char[]) {5, 1},
(char[]) {6, 0 \* 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16,
0, 0, 21 + 0 \* 3 - 0, 16, 1, 63,
21 + 0 \* 3 - 0, 16, 2, 63 \* 0, 21 - 0,
4, 2, 31 + 0, 36 - 0, 4, 0 + 1, 32 - 1,
5 - 0, 16, 0, 0, 21 + 1 \* 3 - 0, 16, 1,
63, 21 + 1 \* 3 - 0, 16, 2, 63 \* 1,
21 - 0, 4, 2, 31 + 1, 36 - 0, 4, 6,
0 \* 4 + 0, 3, 31, 8 - 0, 6, 0 \* 4 + 2,
3, 33, 38 - 0, 6, 0 \* 4 + 3, 3, 30,
38 - 0,
4},
(char[]) {4},
(char[]) {4},
(char[]) {6, 2 \* 4 + 1, 0 + 0, 32 - 0, 5 - 3, 16, 0, 0,
21 + 0 \* 3 - 3, 16, 1, 63, 21 + 0 \* 3 - 3, 16, 2, 63 \* 0,
21 - 3, 4, 2, 31 + 0, 36 - 3, 4, 0 + 1, 32 - 1, 5 - 3,
16, 0, 0, 21 + 1 \* 3 - 3, 16, 1, 63, 21 + 1 \* 3 - 3, 16,
2, 63 \* 1, 21 - 3, 4, 2, 31 + 1, 36 - 3, 4, 6, 2 \* 4 + 0,
3, 31, 8 - 3, 6, 2 \* 4 + 2, 3, 33, 38 - 3, 6, 2 \* 4 + 3,
3, 30, 38 - 3, 4},
(char[]) {6, 13, 0, 32, 9 + 0, 12 - 0,
0, 8 + 0 + 0, 21, 12 - 0, 1,
31, 9 + 0, 12 - 0, 1,
55 - 0 - 0, 21, 12 - 0, 0,
32, 9 + 3, 12 - 3, 0,
8 + 3 + 3, 21, 12 - 3, 1,
31, 9 + 3, 12 - 3, 1,
55 - 3 - 3, 21, 12 - 3, 6,
14 + 0, 2, 31 + 0, 13, 4,
1 - 0, 31 + 0, 16, 7, 3,
30 + 3 \* 0, 14, 6,
12 + 0 \* 4, 3, 32 - 0,
11 + 0 \* 8, 6, 14 + 1, 2,
31 + 1, 13, 4, 1 - 1,
31 + 1, 16, 7, 3,
30 + 3 \* 1, 14, 6,
12 + 1 \* 4, 3, 32 - 1,
11 + 1 \* 8,
4}
};
int main(int argc, char \* args[]) {
\_image\_create();
for (int i = 0; i < 8; i++) {
char \*p = z[i];
int c = 0;
while (\*p != 4) {
switch (\*p) {
case 0:
k(i, p[1], p[2], p[3], c);
p += 4;
break;
case 1:
r(i, p[1], p[2], p[3], c);
p += 4;
break;
case 2:
u(i, p[1], p[2], p[3], c);
p += 4;
break;
case 3:
e(i, p[1]
, p[2], 0, c);
p += 3;
break;
case 5:
p = z[p[1]];
break;
case 6:
c = \_x[p[1] / 4] - 1643277 \* (p[1] % 4);
p += 2;
break;
}
}
}
unsigned int counter = 1;
while (counter++) {
\_map\_read(args[ARG\_BLUEPRINT]);
\_map\_wire\_inputs();
\_map\_wire\_counter(counter);
\_map\_process\_gates();
\_image\_reset();
\_image\_compile();
\_image\_drill();
for (int y = 0; y < IMAGE\_HEIGHT; y++)
for (int x = 0; x < IMAGE\_WIDTH; x++) {
pixdata[y][x] &= 14737632 | (31 << ((x % 3) << 3));
pixdata[y][x] += 986895 & (rn \*= 16777619);
}
\_image\_draw();
sleep(1);
}
return 0;
}
```
#### Шейдеры
Котики из предыдущей статьи обещали шейдеры. И они тут есть. А где код, который отвечает за их обработку?
```
_image_reset(); // Рано
_image_compile(); // Рано
_image_drill(); // Рано
for (int y = 0; y < IMAGE_HEIGHT; y++)
for (int x = 0; x < IMAGE_WIDTH; x++) {
pixdata[y][x] &= 14737632 | (31 << ((x % 3) << 3));
pixdata[y][x] += 986895 & (rn *= 16777619);
}
_image_draw(); // Поздно
```
Методом исключения понимаем, что зашумленность экрана и эффект LCD-монитора дают эти две строчки. А как они работают?
Начнем с последней:
```
pixdata[y][x] += 986895 & (rn *= 16777619);
```
К каждому пикселю прибавляется значение 986895 (что в hex-варианты выглядит как 0x0f0f0f), которое перед этим было посредством операции битовое-И совмещено с результатом умножения rn на 16777619. Если бы rn было ренератором случайных чисел, то это создало бы зернистый «шум» на экране в пределах 16 градаций по каждому каналу. И раз шум появляется, значит rn и есть генератор случайных чисел. Но как это достигается?
```
int rn = 2166136261;
```
В самом начале программы переменная rn инициализируется числом 2166136261. А на каждой итерации пикселя умножается на 16777619. Это ничто иное, как генератор псевдослучайных чисел. Вот только вместо линейного хорошо изученного генератора используется алгоритм хэширования [FNV](https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function) без шага с XOR, поскольку нам не нужен конечный результат.
Остается понять, как работает предыдущая строка:
```
pixdata[y][x] &= 14737632 | (31 << ((x % 3) << 3));
```
Переведем число 14737632 в шестнадцатиричный формат, так как мы работаем с однобайтными каналами света: 0xe0e0e0. А теперь приняв x равным от 0 до 3 проведем соответствующие вычисления:
```
0xe0e0e0 | (31 << ((0 % 3) << 3)) = e0e0ff
0xe0e0e0 | (31 << ((1 % 3) << 3)) = e0ffe0
0xe0e0e0 | (31 << ((2 % 3) << 3)) = ffe0e0
```
Если теперь эти маски применить при помощи операции "&" к цвету пикселя, то мы получим, соответственно, приглушенные R и G, R и B, G и B каналы, что будет выглядеть как эффект от LCD-монитора:
**Выделим их в отдельные функции:**
```
#include
#include
#include
#include
#include
/\* Код после рефакторинга \*/
/\*! \brief Ширина изображения в пикселях \*/
#define IMAGE\_WIDTH (1220)
/\*! \brief Высота изображения в пикселях \*/
#define IMAGE\_HEIGHT (616)
/\*! \brief Сдвиг верхней грани карты от левой стороны \*/
#define IMAGE\_SHIFTX (580)
/\*! \brief Количество текстур \*/
#define TEXTURE\_COUNT (8)
/\*! \brief Ширина текстуры в пикселях \*/
#define TEXTURE\_WIDTH (64)
/\*! \brief Высота текстур в пикселях \*/
#define TEXTURE\_HEIGHT (40)
/\*! \brief Ширина грани текстуры в пикселях \*/
#define TEXTURE\_TOP\_WIDTH (64)
/\*! \brief Высота грани текстуры в пикселях \*/
#define TEXTURE\_TOP\_HEIGHT (32)
/\*! \brief Ширина эмулируемого поля \*/
#define MAP\_WIDTH (19)
/\*! \brief Высота эмулируемого поля \*/
#define MAP\_HEIGHT (19)
/\*! \brief Количество данные в файле-чертеже. Один байт добавлен для символа '\n' \*/
#define MAP\_FILEDATA ((MAP\_WIDTH + 1) \* MAP\_HEIGHT)
/\*! \brief Количество итераций во время расчета NOR-узлов \*/
#define MAP\_ITERATIONS (20)
/\*! \brief Содержит структуры синтаксиса файла-конфигурации \*/
enum map\_characters {
MAPCHAR\_WIRE = '.', /\*\*< Провод (ASCII = 46) \*/
MAPCHAR\_PLUS = '+', /\*\*< Провод (есть ток) (ASCII = 43) \*/
MAPCHAR\_MINUS = '-', /\*\*< Провод (нет тока) (ASCII = 45) \*/
MAPCHAR\_NOR = '>', /\*\*< NOR-элемент (ASCII = 62) \*/
MAPCHAR\_EMPTY = ' ', /\*\*< Пустой блок (ASCII = 32) \*/
};
/\*! \brief Содержит индексы текстур \*/
enum textures\_indexes {
TEXINDEX\_EMPTY = (0), /\*\*< Индекс пустой текстуры \*/
TEXINDEX\_MINUS = (1), /\*\*< Индекс текстуры "выключенного провода" \*/
TEXINDEX\_WIRE = (2), /\*\*< Индекс текстуры нейтрального провода \*/
TEXINDEX\_PLUS = (3), /\*\*< Индекс текстуры "включенного" провода \*/
/\*\*/
TEXINDEX\_NOR = (6), /\*\*< Индекс текстуры NOR-элемента \*/
TEXINDEX\_HOLE = (7) /\*\*< Индекс текстуры отверстия на плате \*/
};
/\*! \brief Аргументы программы \*/
enum program\_arguments {
ARG\_PROGRAM, /\*\*< Имя самой программы \*/
ARG\_BLUEPRINT /\*\*< Имя файла-чертежа \*/
};
/\*! \brief Бинарные данные пикселей изображения.
\* Типизированы к int для оперирования пикселями вместо каналов \*/
int pixdata[IMAGE\_HEIGHT][IMAGE\_WIDTH];
/\*! \brief Текстуры блоков, отображаемых на поле \*/
int textures[TEXTURE\_COUNT][TEXTURE\_HEIGHT][TEXTURE\_WIDTH] = { 0 };
/\*! \brief Данные эмулируемого поля.
\* Один байт добавлен для упрощения обработки символа '\n' \*/
char mapdata[MAP\_HEIGHT][MAP\_WIDTH + 1];
/\*! \brief Зерно генератора случайных чисел \*/
int random = 2166136261;
/\*! \brief Экземпляр дисплея Xlib \*/
Display \* display;
/\*! \brief Экземпляр главного окна Xlib \*/
Window window;
/\*! \brief Изображение для вывода на экран \*/
XImage \* image;
static void \_texture\_draw(int t, int x, int y);
/\*! \brief Создает изображение и сопутствующие сущности \*/
static void \_image\_create(void) {
display = XOpenDisplay(0);
window = XCreateSimpleWindow(display,
RootWindow(display, DefaultScreen(display)),
0, 0, IMAGE\_WIDTH, IMAGE\_HEIGHT, 1, 0, 0);
image = XCreateImage(display,
DefaultVisual(display, DefaultScreen(display)),
DefaultDepth(display, DefaultScreen(display)),
2, 0, (char \*) pixdata, IMAGE\_WIDTH, IMAGE\_HEIGHT, 32, 0);
}
/\* \brief Обнуляет изображение, заполняя его черным цветом \*/
static void \_image\_reset(void) {
for (int y = 0; y < IMAGE\_HEIGHT; y++)
for (int x = 0; x < IMAGE\_WIDTH; x++)
pixdata[y][x] = 0;
}
/\*! \brief Конвертирует символ из чертежа в индекс текстуры
\* \param[in] elem Символ чертежа
\* \return Индекс текстуры \*/
static int \_map2texture(char elem) {
return ((elem >> 4) & 1) << 2 | (elem & 3);
}
/\*! \brief Собирает изображение из отдельных тайлов согласно карте \*/
static void \_image\_compile(void) {
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
\_texture\_draw(\_map2texture(mapdata[y][x]), x, y);
}
/\*! \brief Рисует изображение на экране \*/
static void \_image\_draw(void) {
XPutImage(display, window,
DefaultGC(display, DefaultScreen(display)),
image, 0, 0, 0, 0, IMAGE\_WIDTH, IMAGE\_HEIGHT);
XMapWindow(display, window);
XFlush(display);
}
/\*! \brief Рисует отверстия на печатной плате \*/
static void \_image\_drill(void) {
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if ((x % 14 == 2) && (y % 4 == 3))
\_texture\_draw(TEXINDEX\_HOLE, x, y);
}
/\*! \brief Применяет шейдер LCD-эффекта на изображение
\* \param[in] x X-координата изображения
\* \param[in] y Y-координата изображения \*/
static void \_shader\_lcd(int x, int y) {
pixdata[y][x] &= 0xe0e0e0 | (31 << ((x % 3) << 3));
}
/\*! \brief Применяет шейдер случайного шума на изображение
\* \param[in] x X-координата изображения
\* \param[in] y Y-координата изображения \*/
static void \_shader\_noise(int x, int y) {
pixdata[y][x] += 0x0f0f0f & (random \*= 16777619);
}
/\*! \brief Накладывает на изображение различные эффекты \*/
static void \_image\_postprocess(void) {
for (int y = 0; y < IMAGE\_HEIGHT; y++)
for (int x = 0; x < IMAGE\_WIDTH; x++) {
\_shader\_lcd(x, y);
\_shader\_noise(x, y);
}
}
/\*! \brief Отрисовывает текстуру на главном холсте по указанным координатам
\* \param[in] t Индекс текстуры
\* \param[in] x X координата тайла
\* \param[in] y Y координата тайла \*/
static void \_texture\_draw(int t, int x, int y) {
for (int ty = 0; ty < TEXTURE\_HEIGHT; ty++)
for (int tx = 0; tx < TEXTURE\_WIDTH; tx++)
if (textures[t][ty][tx])
pixdata[ty +
y \* (TEXTURE\_TOP\_HEIGHT / 2) +
x \* (TEXTURE\_TOP\_HEIGHT / 2)]
[tx +
IMAGE\_SHIFTX +
x \* (TEXTURE\_TOP\_WIDTH / 2) -
y \* TEXTURE\_TOP\_HEIGHT] = textures[t][ty][tx];
}
/\*! \brief Читает данные файла-чертежа и загружает их в карту
\* \param[in] filename Имя файла-чертежа \*/
static void \_map\_read(const char \* filename) {
int f = open(filename, 0);
read(f, mapdata, MAP\_FILEDATA);
close(f);
}
/\*! \brief Заменяет иллюстративные входы из файла-конфигурации на вход
\* в виде провода чтобы работала логика распространения фронта волны \*/
static void \_map\_wire\_inputs(void) {
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if ((x % 14 == 2) && (y % 4 == 3))
mapdata[y][x] = MAPCHAR\_WIRE;
}
/\*! \brief Производит заливку проводника нужным состоянием
\* \param[in] t Игнорируется, артефакт автогенерации кода
\* \param[in] x X-координата заливки
\* \param[in] y Y-координата заливки
\* \param[in] c Исходное состояние
\* \param[in] l Целевое состояние \*/
static void \_map\_fill(int t, int x, int y, int c, int l) {
if ((x >= MAP\_WIDTH || y >= MAP\_HEIGHT ||
x < 0 || y < 0) || (mapdata[y][x] == l)
|| (mapdata[y][x] != c))
return;
mapdata[y][x] = l;
\_map\_fill(t, x - 1, y, c, l);
\_map\_fill(t, x + 1, y, c, l);
\_map\_fill(t, x, y - 1, c, l);
\_map\_fill(t, x, y + 1, c, l);
}
/\*! \brief Включает соответствующие входы схемы в зависимости от значения
\* счетчика.
\* \param[in] counter Счетчик \*/
static void \_map\_wire\_counter(int counter) {
\_map\_fill(0, 2, 3, mapdata[3][2], counter & 1 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
\_map\_fill(0, 2, 7, mapdata[7][2], counter & 2 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
\_map\_fill(0, 2, 11, mapdata[11][2], counter & 4 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
\_map\_fill(0, 2, 15, mapdata[15][2], counter & 8 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
}
/\*! \brief Проводит расчет выходного (результирующего) тока после NOR-узла \*/
static void \_map\_process\_gates(void) {
for (int i = 0; i < MAP\_ITERATIONS; i++)
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if (mapdata[y][x] == MAPCHAR\_NOR)
\_map\_fill(0, x + 1, y, mapdata[y][x + 1],
!(mapdata[y - 1][x] == MAPCHAR\_PLUS ? 1 : 0
|| mapdata[y + 1][x] == MAPCHAR\_PLUS ? 1 : 0) ?
MAPCHAR\_PLUS : MAPCHAR\_MINUS);
}
/\* Код до рефакторинга \*/
int \_x[] = { 15117427, 8413248, 5878632, 13027014, 1 };
void e(int t, int x, int y, int c, int l) {
if ((x >= TEXTURE\_WIDTH || y >= TEXTURE\_HEIGHT ||
x < 0 || y < 0) ||
(textures[t][y][x] == l) ||
(textures[t][y][x] != c))
return;
textures[t][y][x] = l;
e(t, x - 1, y, c, l);
e(t, x + 1, y, c, l);
e(t, x, y - 1, c, l);
e(t, x, y + 1, c, l);
}
void k(int t, int x, int y, int c, int l) {
while (c--) {
textures[t][y][x++] = l;
textures[t][y++][x++] = l;
}
}
void r(int t, int x, int y, int c, int l) {
while (c--) {
textures[t][y][x--] = l;
textures[t][y++][x--] = l;
}
}
void u(int t, int x, int y, int c, int l) {
while (c--)
textures[t][y++][x] = l;
}
char \*z[8] = {
(char[]) {4},
(char[]) {6, 1 \* 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16, 0, 0,
21 + 0 \* 3 - 0, 16, 1, 63, 21 + 0 \* 3 - 0, 16, 2,
63 \* 0, 21 - 0, 4, 2, 31 + 0, 36 - 0, 4, 0 + 1,
32 - 1, 5 - 0, 16, 0, 0, 21 + 1 \* 3 - 0, 16, 1, 63,
21 + 1 \* 3 - 0, 16, 2, 63 \* 1, 21 - 0, 4, 2, 31 + 1,
36 - 0, 4, 6, 1 \* 4 + 0, 3, 31, 8 - 0, 6, 1 \* 4 + 2,
3, 33, 38 - 0, 6, 1 \* 4 + 3, 3, 30, 38 - 0, 4},
(char[]) {5, 1},
(char[]) {6, 0 \* 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16,
0, 0, 21 + 0 \* 3 - 0, 16, 1, 63,
21 + 0 \* 3 - 0, 16, 2, 63 \* 0, 21 - 0,
4, 2, 31 + 0, 36 - 0, 4, 0 + 1, 32 - 1,
5 - 0, 16, 0, 0, 21 + 1 \* 3 - 0, 16, 1,
63, 21 + 1 \* 3 - 0, 16, 2, 63 \* 1,
21 - 0, 4, 2, 31 + 1, 36 - 0, 4, 6,
0 \* 4 + 0, 3, 31, 8 - 0, 6, 0 \* 4 + 2,
3, 33, 38 - 0, 6, 0 \* 4 + 3, 3, 30,
38 - 0,
4},
(char[]) {4},
(char[]) {4},
(char[]) {6, 2 \* 4 + 1, 0 + 0, 32 - 0, 5 - 3, 16, 0, 0,
21 + 0 \* 3 - 3, 16, 1, 63, 21 + 0 \* 3 - 3, 16, 2, 63 \* 0,
21 - 3, 4, 2, 31 + 0, 36 - 3, 4, 0 + 1, 32 - 1, 5 - 3,
16, 0, 0, 21 + 1 \* 3 - 3, 16, 1, 63, 21 + 1 \* 3 - 3, 16,
2, 63 \* 1, 21 - 3, 4, 2, 31 + 1, 36 - 3, 4, 6, 2 \* 4 + 0,
3, 31, 8 - 3, 6, 2 \* 4 + 2, 3, 33, 38 - 3, 6, 2 \* 4 + 3,
3, 30, 38 - 3, 4},
(char[]) {6, 13, 0, 32, 9 + 0, 12 - 0,
0, 8 + 0 + 0, 21, 12 - 0, 1,
31, 9 + 0, 12 - 0, 1,
55 - 0 - 0, 21, 12 - 0, 0,
32, 9 + 3, 12 - 3, 0,
8 + 3 + 3, 21, 12 - 3, 1,
31, 9 + 3, 12 - 3, 1,
55 - 3 - 3, 21, 12 - 3, 6,
14 + 0, 2, 31 + 0, 13, 4,
1 - 0, 31 + 0, 16, 7, 3,
30 + 3 \* 0, 14, 6,
12 + 0 \* 4, 3, 32 - 0,
11 + 0 \* 8, 6, 14 + 1, 2,
31 + 1, 13, 4, 1 - 1,
31 + 1, 16, 7, 3,
30 + 3 \* 1, 14, 6,
12 + 1 \* 4, 3, 32 - 1,
11 + 1 \* 8,
4}
};
int main(int argc, char \* args[]) {
\_image\_create();
for (int i = 0; i < 8; i++) {
char \*p = z[i];
int c = 0;
while (\*p != 4) {
switch (\*p) {
case 0:
k(i, p[1], p[2], p[3], c);
p += 4;
break;
case 1:
r(i, p[1], p[2], p[3], c);
p += 4;
break;
case 2:
u(i, p[1], p[2], p[3], c);
p += 4;
break;
case 3:
e(i, p[1]
, p[2], 0, c);
p += 3;
break;
case 5:
p = z[p[1]];
break;
case 6:
c = \_x[p[1] / 4] - 1643277 \* (p[1] % 4);
p += 2;
break;
}
}
}
unsigned int counter = 1;
while (counter++) {
\_map\_read(args[ARG\_BLUEPRINT]);
\_map\_wire\_inputs();
\_map\_wire\_counter(counter);
\_map\_process\_gates();
\_image\_reset();
\_image\_compile();
\_image\_drill();
\_image\_postprocess();
\_image\_draw();
sleep(1);
}
return 0;
}
```
#### «e», «k», «r», «u»
Осталось еще 4 функции, которые мы не исследовали и не переименовали — это «e», «k», «r» и «u». Попытаемся осмотреть их, не прибегая к поиску мест, откуда они вызываются:
```
void e(int t, int x, int y, int c, int l) {
if ((x >= TEXTURE_WIDTH || y >= TEXTURE_HEIGHT ||
x < 0 || y < 0) ||
(textures[t][y][x] == l) ||
(textures[t][y][x] != c))
return;
textures[t][y][x] = l;
e(t, x - 1, y, c, l);
e(t, x + 1, y, c, l);
e(t, x, y - 1, c, l);
e(t, x, y + 1, c, l);
}
```
Очевидно, что эта функция выглядит и работает как flood\_fill, только для массива textures, переименуем ее в \_texture\_fill.
```
void k(int t, int x, int y, int c, int l) {
while (c--) {
textures[t][y][x++] = l;
textures[t][y++][x++] = l;
}
}
void r(int t, int x, int y, int c, int l) {
while (c--) {
textures[t][y][x--] = l;
textures[t][y++][x--] = l;
}
}
```
Функции «k» и «r» на каждую заданную единицу c рисуют два пикселя значением l и перемещаются вправо или влево на два пикселя и вниз на один — значит это функции рисования изометрических линий SW и SE. Переименуем их в \_texture\_linesw и \_texture\_linese.
На данный момент уже можно догадаться, что последняя функция «u» рисует линию вертикально вниз:
```
void u(int t, int x, int y, int c, int l) {
while (c--)
textures[t][y++][x] = l;
}
```
Переименуем её в \_texture\_linedown.
**Все отдельные функции прошли рефакторинг:**
```
#include
#include
#include
#include
#include
/\* Код после рефакторинга \*/
/\*! \brief Ширина изображения в пикселях \*/
#define IMAGE\_WIDTH (1220)
/\*! \brief Высота изображения в пикселях \*/
#define IMAGE\_HEIGHT (616)
/\*! \brief Сдвиг верхней грани карты от левой стороны \*/
#define IMAGE\_SHIFTX (580)
/\*! \brief Количество текстур \*/
#define TEXTURE\_COUNT (8)
/\*! \brief Ширина текстуры в пикселях \*/
#define TEXTURE\_WIDTH (64)
/\*! \brief Высота текстур в пикселях \*/
#define TEXTURE\_HEIGHT (40)
/\*! \brief Ширина грани текстуры в пикселях \*/
#define TEXTURE\_TOP\_WIDTH (64)
/\*! \brief Высота грани текстуры в пикселях \*/
#define TEXTURE\_TOP\_HEIGHT (32)
/\*! \brief Ширина эмулируемого поля \*/
#define MAP\_WIDTH (19)
/\*! \brief Высота эмулируемого поля \*/
#define MAP\_HEIGHT (19)
/\*! \brief Количество данные в файле-чертеже. Один байт добавлен для символа '\n' \*/
#define MAP\_FILEDATA ((MAP\_WIDTH + 1) \* MAP\_HEIGHT)
/\*! \brief Количество итераций во время расчета NOR-узлов \*/
#define MAP\_ITERATIONS (20)
/\*! \brief Содержит структуры синтаксиса файла-конфигурации \*/
enum map\_characters {
MAPCHAR\_WIRE = '.', /\*\*< Провод (ASCII = 46) \*/
MAPCHAR\_PLUS = '+', /\*\*< Провод (есть ток) (ASCII = 43) \*/
MAPCHAR\_MINUS = '-', /\*\*< Провод (нет тока) (ASCII = 45) \*/
MAPCHAR\_NOR = '>', /\*\*< NOR-элемент (ASCII = 62) \*/
MAPCHAR\_EMPTY = ' ', /\*\*< Пустой блок (ASCII = 32) \*/
};
/\*! \brief Содержит индексы текстур \*/
enum textures\_indexes {
TEXINDEX\_EMPTY = (0), /\*\*< Индекс пустой текстуры \*/
TEXINDEX\_MINUS = (1), /\*\*< Индекс текстуры "выключенного провода" \*/
TEXINDEX\_WIRE = (2), /\*\*< Индекс текстуры нейтрального провода \*/
TEXINDEX\_PLUS = (3), /\*\*< Индекс текстуры "включенного" провода \*/
/\*\*/
TEXINDEX\_NOR = (6), /\*\*< Индекс текстуры NOR-элемента \*/
TEXINDEX\_HOLE = (7) /\*\*< Индекс текстуры отверстия на плате \*/
};
/\*! \brief Аргументы программы \*/
enum program\_arguments {
ARG\_PROGRAM, /\*\*< Имя самой программы \*/
ARG\_BLUEPRINT /\*\*< Имя файла-чертежа \*/
};
/\*! \brief Бинарные данные пикселей изображения.
\* Типизированы к int для оперирования пикселями вместо каналов \*/
int pixdata[IMAGE\_HEIGHT][IMAGE\_WIDTH];
/\*! \brief Текстуры блоков, отображаемых на поле \*/
int textures[TEXTURE\_COUNT][TEXTURE\_HEIGHT][TEXTURE\_WIDTH] = { 0 };
/\*! \brief Данные эмулируемого поля.
\* Один байт добавлен для упрощения обработки символа '\n' \*/
char mapdata[MAP\_HEIGHT][MAP\_WIDTH + 1];
/\*! \brief Зерно генератора случайных чисел \*/
int random = 2166136261;
/\*! \brief Экземпляр дисплея Xlib \*/
Display \* display;
/\*! \brief Экземпляр главного окна Xlib \*/
Window window;
/\*! \brief Изображение для вывода на экран \*/
XImage \* image;
static void \_texture\_draw(int t, int x, int y);
/\*! \brief Создает изображение и сопутствующие сущности \*/
static void \_image\_create(void) {
display = XOpenDisplay(0);
window = XCreateSimpleWindow(display,
RootWindow(display, DefaultScreen(display)),
0, 0, IMAGE\_WIDTH, IMAGE\_HEIGHT, 1, 0, 0);
image = XCreateImage(display,
DefaultVisual(display, DefaultScreen(display)),
DefaultDepth(display, DefaultScreen(display)),
2, 0, (char \*) pixdata, IMAGE\_WIDTH, IMAGE\_HEIGHT, 32, 0);
}
/\* \brief Обнуляет изображение, заполняя его черным цветом \*/
static void \_image\_reset(void) {
for (int y = 0; y < IMAGE\_HEIGHT; y++)
for (int x = 0; x < IMAGE\_WIDTH; x++)
pixdata[y][x] = 0;
}
/\*! \brief Конвертирует символ из чертежа в индекс текстуры
\* \param[in] elem Символ чертежа
\* \return Индекс текстуры \*/
static int \_map2texture(char elem) {
return ((elem >> 4) & 1) << 2 | (elem & 3);
}
/\*! \brief Собирает изображение из отдельных тайлов согласно карте \*/
static void \_image\_compile(void) {
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
\_texture\_draw(\_map2texture(mapdata[y][x]), x, y);
}
/\*! \brief Рисует изображение на экране \*/
static void \_image\_draw(void) {
XPutImage(display, window,
DefaultGC(display, DefaultScreen(display)),
image, 0, 0, 0, 0, IMAGE\_WIDTH, IMAGE\_HEIGHT);
XMapWindow(display, window);
XFlush(display);
}
/\*! \brief Рисует отверстия на печатной плате \*/
static void \_image\_drill(void) {
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if ((x % 14 == 2) && (y % 4 == 3))
\_texture\_draw(TEXINDEX\_HOLE, x, y);
}
/\*! \brief Применяет шейдер LCD-эффекта на изображение
\* \param[in] x X-координата изображения
\* \param[in] y Y-координата изображения \*/
static void \_shader\_lcd(int x, int y) {
pixdata[y][x] &= 0xe0e0e0 | (31 << ((x % 3) << 3));
}
/\*! \brief Применяет шейдер случайного шума на изображение
\* \param[in] x X-координата изображения
\* \param[in] y Y-координата изображения \*/
static void \_shader\_noise(int x, int y) {
pixdata[y][x] += 0x0f0f0f & (random \*= 16777619);
}
/\*! \brief Накладывает на изображение различные эффекты \*/
static void \_image\_postprocess(void) {
for (int y = 0; y < IMAGE\_HEIGHT; y++)
for (int x = 0; x < IMAGE\_WIDTH; x++) {
\_shader\_lcd(x, y);
\_shader\_noise(x, y);
}
}
/\*! \brief Отрисовывает текстуру на главном холсте по указанным координатам
\* \param[in] t Индекс текстуры
\* \param[in] x X координата тайла
\* \param[in] y Y координата тайла \*/
static void \_texture\_draw(int t, int x, int y) {
for (int ty = 0; ty < TEXTURE\_HEIGHT; ty++)
for (int tx = 0; tx < TEXTURE\_WIDTH; tx++)
if (textures[t][ty][tx])
pixdata[ty +
y \* (TEXTURE\_TOP\_HEIGHT / 2) +
x \* (TEXTURE\_TOP\_HEIGHT / 2)]
[tx +
IMAGE\_SHIFTX +
x \* (TEXTURE\_TOP\_WIDTH / 2) -
y \* TEXTURE\_TOP\_HEIGHT] = textures[t][ty][tx];
}
/\*! \brief Производит закраску области текстуры
\* \param[in] t Индекс текстуры
\* \param[in] x X-координата начала
\* \param[in] y Y-координата начала
\* \param[in] source Исходный цвет
\* \param[in] target Новый цвет \*/
static void \_texture\_fill(int t, int x, int y, int source, int target) {
if ((x >= TEXTURE\_WIDTH || y >= TEXTURE\_HEIGHT ||
x < 0 || y < 0) ||
(textures[t][y][x] == target) ||
(textures[t][y][x] != source))
return;
textures[t][y][x] = target;
\_texture\_fill(t, x - 1, y, source, target);
\_texture\_fill(t, x + 1, y, source, target);
\_texture\_fill(t, x, y - 1, source, target);
\_texture\_fill(t, x, y + 1, source, target);
}
/\*! \brief Рисует изометрическую линию по направлению SE
\* \param[in] t Индекс текстуры
\* \param[in] x X-координата начала
\* \param[in] y Y-координата начала
\* \param[in] c Длина линии по короткой стороне
\* \param[in] color Цвет рисования \*/
static void \_texture\_linese(int t, int x, int y, int c, int color) {
while (c--) {
textures[t][y][x++] = color;
textures[t][y++][x++] = color;
}
}
/\*! \brief Рисует изометрическую линию по направлению SW
\* \param[in] t Индекс текстуры
\* \param[in] x X-координата начала
\* \param[in] y Y-координата начала
\* \param[in] c Длина линии по короткой стороне
\* \param[in] color Цвет рисования \*/
static void \_texture\_linesw(int t, int x, int y, int c, int color) {
while (c--) {
textures[t][y][x--] = color;
textures[t][y++][x--] = color;
}
}
/\*! \brief Рисует линию вниз
\* \param[in] t Индекс текстуры
\* \param[in] x X-координата начала
\* \param[in] y Y-координата начала
\* \param[in] c Длина линии
\* \param[in] color Цвет рисования \*/
static void \_texture\_linedown(int t, int x, int y, int c, int color) {
while (c--)
textures[t][y++][x] = color;
}
/\*! \brief Читает данные файла-чертежа и загружает их в карту
\* \param[in] filename Имя файла-чертежа \*/
static void \_map\_read(const char \* filename) {
int f = open(filename, 0);
read(f, mapdata, MAP\_FILEDATA);
close(f);
}
/\*! \brief Заменяет иллюстративные входы из файла-конфигурации на вход
\* в виде провода чтобы работала логика распространения фронта волны \*/
static void \_map\_wire\_inputs(void) {
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if ((x % 14 == 2) && (y % 4 == 3))
mapdata[y][x] = MAPCHAR\_WIRE;
}
/\*! \brief Производит заливку проводника нужным состоянием
\* \param[in] t Игнорируется, артефакт автогенерации кода
\* \param[in] x X-координата заливки
\* \param[in] y Y-координата заливки
\* \param[in] c Исходное состояние
\* \param[in] l Целевое состояние \*/
static void \_map\_fill(int t, int x, int y, int c, int l) {
if ((x >= MAP\_WIDTH || y >= MAP\_HEIGHT ||
x < 0 || y < 0) || (mapdata[y][x] == l)
|| (mapdata[y][x] != c))
return;
mapdata[y][x] = l;
\_map\_fill(t, x - 1, y, c, l);
\_map\_fill(t, x + 1, y, c, l);
\_map\_fill(t, x, y - 1, c, l);
\_map\_fill(t, x, y + 1, c, l);
}
/\*! \brief Включает соответствующие входы схемы в зависимости от значения
\* счетчика.
\* \param[in] counter Счетчик \*/
static void \_map\_wire\_counter(int counter) {
\_map\_fill(0, 2, 3, mapdata[3][2], counter & 1 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
\_map\_fill(0, 2, 7, mapdata[7][2], counter & 2 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
\_map\_fill(0, 2, 11, mapdata[11][2], counter & 4 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
\_map\_fill(0, 2, 15, mapdata[15][2], counter & 8 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
}
/\*! \brief Проводит расчет выходного (результирующего) тока после NOR-узла \*/
static void \_map\_process\_gates(void) {
for (int i = 0; i < MAP\_ITERATIONS; i++)
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if (mapdata[y][x] == MAPCHAR\_NOR)
\_map\_fill(0, x + 1, y, mapdata[y][x + 1],
!(mapdata[y - 1][x] == MAPCHAR\_PLUS ? 1 : 0
|| mapdata[y + 1][x] == MAPCHAR\_PLUS ? 1 : 0) ?
MAPCHAR\_PLUS : MAPCHAR\_MINUS);
}
/\* Код до рефакторинга \*/
int \_x[] = { 15117427, 8413248, 5878632, 13027014, 1 };
char \*z[8] = {
(char[]) {4},
(char[]) {6, 1 \* 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16, 0, 0,
21 + 0 \* 3 - 0, 16, 1, 63, 21 + 0 \* 3 - 0, 16, 2,
63 \* 0, 21 - 0, 4, 2, 31 + 0, 36 - 0, 4, 0 + 1,
32 - 1, 5 - 0, 16, 0, 0, 21 + 1 \* 3 - 0, 16, 1, 63,
21 + 1 \* 3 - 0, 16, 2, 63 \* 1, 21 - 0, 4, 2, 31 + 1,
36 - 0, 4, 6, 1 \* 4 + 0, 3, 31, 8 - 0, 6, 1 \* 4 + 2,
3, 33, 38 - 0, 6, 1 \* 4 + 3, 3, 30, 38 - 0, 4},
(char[]) {5, 1},
(char[]) {6, 0 \* 4 + 1, 0 + 0, 32 - 0, 5 - 0, 16,
0, 0, 21 + 0 \* 3 - 0, 16, 1, 63,
21 + 0 \* 3 - 0, 16, 2, 63 \* 0, 21 - 0,
4, 2, 31 + 0, 36 - 0, 4, 0 + 1, 32 - 1,
5 - 0, 16, 0, 0, 21 + 1 \* 3 - 0, 16, 1,
63, 21 + 1 \* 3 - 0, 16, 2, 63 \* 1,
21 - 0, 4, 2, 31 + 1, 36 - 0, 4, 6,
0 \* 4 + 0, 3, 31, 8 - 0, 6, 0 \* 4 + 2,
3, 33, 38 - 0, 6, 0 \* 4 + 3, 3, 30,
38 - 0,
4},
(char[]) {4},
(char[]) {4},
(char[]) {6, 2 \* 4 + 1, 0 + 0, 32 - 0, 5 - 3, 16, 0, 0,
21 + 0 \* 3 - 3, 16, 1, 63, 21 + 0 \* 3 - 3, 16, 2, 63 \* 0,
21 - 3, 4, 2, 31 + 0, 36 - 3, 4, 0 + 1, 32 - 1, 5 - 3,
16, 0, 0, 21 + 1 \* 3 - 3, 16, 1, 63, 21 + 1 \* 3 - 3, 16,
2, 63 \* 1, 21 - 3, 4, 2, 31 + 1, 36 - 3, 4, 6, 2 \* 4 + 0,
3, 31, 8 - 3, 6, 2 \* 4 + 2, 3, 33, 38 - 3, 6, 2 \* 4 + 3,
3, 30, 38 - 3, 4},
(char[]) {6, 13, 0, 32, 9 + 0, 12 - 0,
0, 8 + 0 + 0, 21, 12 - 0, 1,
31, 9 + 0, 12 - 0, 1,
55 - 0 - 0, 21, 12 - 0, 0,
32, 9 + 3, 12 - 3, 0,
8 + 3 + 3, 21, 12 - 3, 1,
31, 9 + 3, 12 - 3, 1,
55 - 3 - 3, 21, 12 - 3, 6,
14 + 0, 2, 31 + 0, 13, 4,
1 - 0, 31 + 0, 16, 7, 3,
30 + 3 \* 0, 14, 6,
12 + 0 \* 4, 3, 32 - 0,
11 + 0 \* 8, 6, 14 + 1, 2,
31 + 1, 13, 4, 1 - 1,
31 + 1, 16, 7, 3,
30 + 3 \* 1, 14, 6,
12 + 1 \* 4, 3, 32 - 1,
11 + 1 \* 8,
4}
};
int main(int argc, char \* args[]) {
\_image\_create();
for (int i = 0; i < 8; i++) {
char \*p = z[i];
int c = 0;
while (\*p != 4) {
switch (\*p) {
case 0:
\_texture\_linese(i, p[1], p[2], p[3], c);
p += 4;
break;
case 1:
\_texture\_linesw(i, p[1], p[2], p[3], c);
p += 4;
break;
case 2:
\_texture\_linedown(i, p[1], p[2], p[3], c);
p += 4;
break;
case 3:
\_texture\_fill(i, p[1], p[2], 0, c);
p += 3;
break;
case 5:
p = z[p[1]];
break;
case 6:
c = \_x[p[1] / 4] - 1643277 \* (p[1] % 4);
p += 2;
break;
}
}
}
unsigned int counter = 1;
while (counter++) {
\_map\_read(args[ARG\_BLUEPRINT]);
\_map\_wire\_inputs();
\_map\_wire\_counter(counter);
\_map\_process\_gates();
\_image\_reset();
\_image\_compile();
\_image\_drill();
\_image\_postprocess();
\_image\_draw();
sleep(1);
}
return 0;
}
```
#### Векторная графика
Остался последний шаг — до конца разобраться, что же происходит в последнем, оставленном «на потом», switch-case:
```
for (int i = 0; i < 8; i++) {
char *p = z[i];
int c = 0;
while (*p != 4) {
switch (*p) {
case 0:
_texture_linese(i, p[1], p[2], p[3], c);
p += 4;
break;
case 1:
_texture_linesw(i, p[1], p[2], p[3], c);
p += 4;
break;
case 2:
_texture_linedown(i, p[1], p[2], p[3], c);
p += 4;
break;
case 3:
_texture_fill(i, p[1], p[2], 0, c);
p += 3;
break;
case 5:
p = z[p[1]];
break;
case 6:
c = _x[p[1] / 4] - 1643277 * (p[1] % 4);
p += 2;
break;
}
}
}
```
Теперь, когда функции имеют новые, понятные, имена, можно сказать, что этот блок кода интерпретирует данные из массива «z», и согласно инструкциям, содержащимся в нем (например 0, 5, 5, 8, 2 — «нарисовать линию South-East, от [5,5] длиной 8 пикселей по краткой стороне цветом номер 2») рисует весь набор текстур.
Вроде бы всё понятно, но ни одного указания на цвет в программе замечено не было.
```
c = _x[p[1] / 4] - 1643277 * (p[1] % 4);
```
Ага, значит массив \_x — это палитра, но в очень странном, «сжатом», формате.
```
int _x[] = { 15117427, 8413248, 5878632, 13027014, 1 };
```
Так как мы пока не знаем, сколько всего цветов используется в палитре (при установке цвета индекс как минимум делится на 4), переформатируем таблицу данных для отрисовки и группируем числа по категориям, заменив сигнатуры инструкций на константы:
**Рефакторинг таблицы векторных инструкций**
```
#include
#include
#include
#include
#include
/\* Код после рефакторинга \*/
/\*! \brief Ширина изображения в пикселях \*/
#define IMAGE\_WIDTH (1220)
/\*! \brief Высота изображения в пикселях \*/
#define IMAGE\_HEIGHT (616)
/\*! \brief Сдвиг верхней грани карты от левой стороны \*/
#define IMAGE\_SHIFTX (580)
/\*! \brief Количество текстур \*/
#define TEXTURE\_COUNT (8)
/\*! \brief Ширина текстуры в пикселях \*/
#define TEXTURE\_WIDTH (64)
/\*! \brief Высота текстур в пикселях \*/
#define TEXTURE\_HEIGHT (40)
/\*! \brief Ширина грани текстуры в пикселях \*/
#define TEXTURE\_TOP\_WIDTH (64)
/\*! \brief Высота грани текстуры в пикселях \*/
#define TEXTURE\_TOP\_HEIGHT (32)
/\*! \brief Ширина эмулируемого поля \*/
#define MAP\_WIDTH (19)
/\*! \brief Высота эмулируемого поля \*/
#define MAP\_HEIGHT (19)
/\*! \brief Количество данные в файле-чертеже. Один байт добавлен для символа '\n' \*/
#define MAP\_FILEDATA ((MAP\_WIDTH + 1) \* MAP\_HEIGHT)
/\*! \brief Количество итераций во время расчета NOR-узлов \*/
#define MAP\_ITERATIONS (20)
/\*! \brief Содержит структуры синтаксиса файла-конфигурации \*/
enum map\_characters {
MAPCHAR\_WIRE = '.', /\*\*< Провод (ASCII = 46) \*/
MAPCHAR\_PLUS = '+', /\*\*< Провод (есть ток) (ASCII = 43) \*/
MAPCHAR\_MINUS = '-', /\*\*< Провод (нет тока) (ASCII = 45) \*/
MAPCHAR\_NOR = '>', /\*\*< NOR-элемент (ASCII = 62) \*/
MAPCHAR\_EMPTY = ' ', /\*\*< Пустой блок (ASCII = 32) \*/
};
/\*! \brief Содержит индексы текстур \*/
enum textures\_indexes {
TEXINDEX\_EMPTY = (0), /\*\*< Индекс пустой текстуры \*/
TEXINDEX\_MINUS = (1), /\*\*< Индекс текстуры "выключенного провода" \*/
TEXINDEX\_WIRE = (2), /\*\*< Индекс текстуры нейтрального провода \*/
TEXINDEX\_PLUS = (3), /\*\*< Индекс текстуры "включенного" провода \*/
/\*\*/
TEXINDEX\_NOR = (6), /\*\*< Индекс текстуры NOR-элемента \*/
TEXINDEX\_HOLE = (7) /\*\*< Индекс текстуры отверстия на плате \*/
};
/\*! \brief Список инструкций векторного интерпретатора \*/
enum textures\_instructions {
TEXVEC\_LINESE = (0), /\*\*< Линия SE \*/
TEXVEC\_LINESW = (1), /\*\*< Линия SW \*/
TEXVEC\_LINEDW = (2), /\*\*< Линия вниз \*/
TEXVEC\_FILL = (3), /\*\*< Заливка \*/
TEXVEC\_EXIT = (4), /\*\*< Конец списка инструкций \*/
TEXVEC\_REPEAT = (5), /\*\*< Повтор инструкций другой текстуры \*/
TEXVEC\_COLOR = (6) /\*\*< Выбор цвета \*/
};
/\*! \brief Аргументы программы \*/
enum program\_arguments {
ARG\_PROGRAM, /\*\*< Имя самой программы \*/
ARG\_BLUEPRINT /\*\*< Имя файла-чертежа \*/
};
/\*! \brief Бинарные данные пикселей изображения.
\* Типизированы к int для оперирования пикселями вместо каналов \*/
int pixdata[IMAGE\_HEIGHT][IMAGE\_WIDTH];
/\*! \brief Текстуры блоков, отображаемых на поле \*/
int textures[TEXTURE\_COUNT][TEXTURE\_HEIGHT][TEXTURE\_WIDTH] = { 0 };
/\*! \brief Данные эмулируемого поля.
\* Один байт добавлен для упрощения обработки символа '\n' \*/
char mapdata[MAP\_HEIGHT][MAP\_WIDTH + 1];
/\*! \brief Зерно генератора случайных чисел \*/
int random = 2166136261;
/\*! \brief Экземпляр дисплея Xlib \*/
Display \* display;
/\*! \brief Экземпляр главного окна Xlib \*/
Window window;
/\*! \brief Изображение для вывода на экран \*/
XImage \* image;
/\*! \brief Векторные инструкции для рисования текстур \*/
static const char \* vecdata[TEXTURE\_COUNT] = {
/\* TEXINDEX\_EMPTY \*/
(char[]) { TEXVEC\_EXIT },
/\* TEXINDEX\_MINUS \*/
(char[]) { TEXVEC\_COLOR, 5, TEXVEC\_LINESE, 32, 5, 16,
TEXVEC\_LINESE, 0, 21, 16, TEXVEC\_LINESW, 63, 21, 16,
TEXVEC\_LINEDW, 0, 21, 4, TEXVEC\_LINEDW, 31, 36, 4,
TEXVEC\_LINESW, 31, 5, 16, TEXVEC\_LINESE, 0, 24, 16,
TEXVEC\_LINESW, 63, 24, 16, TEXVEC\_LINEDW, 63, 21, 4,
TEXVEC\_LINEDW, 32, 36, 4, TEXVEC\_COLOR, 4,
TEXVEC\_FILL, 31, 8, TEXVEC\_COLOR, 6,
TEXVEC\_FILL, 33, 38, TEXVEC\_COLOR, 7,
TEXVEC\_FILL, 30, 38, TEXVEC\_EXIT },
/\* TEXINDEX\_WIRE \*/
(char[]) { TEXVEC\_REPEAT, 1 },
/\* TEXINDEX\_PLUS \*/
(char[]) { TEXVEC\_COLOR, 1, TEXVEC\_LINESE, 32, 5, 16,
TEXVEC\_LINESE, 0, 21, 16, TEXVEC\_LINESW, 63, 21, 16,
TEXVEC\_LINEDW, 63, 21, 4, TEXVEC\_LINEDW, 31, 36, 4,
TEXVEC\_LINESW, 31, 5, 16, TEXVEC\_LINESE, 0, 24, 16,
TEXVEC\_LINESW, 63, 24, 16, TEXVEC\_LINEDW, 63, 21, 4,
TEXVEC\_LINEDW, 32, 36, 4, TEXVEC\_COLOR, 0,
TEXVEC\_FILL, 31, 8, TEXVEC\_COLOR, 2,
TEXVEC\_FILL, 33, 38, TEXVEC\_COLOR, 3,
TEXVEC\_FILL, 30, 38, TEXVEC\_EXIT },
/\* Не используется \*/
(char[]) { TEXVEC\_EXIT },
/\* Не используется \*/
(char[]) { TEXVEC\_EXIT },
/\* TEXINDEX\_NOR \*/
(char[]) { TEXVEC\_COLOR, 9, TEXVEC\_LINESE, 32, 2, 16,
TEXVEC\_LINESE, 0, 18, 16, TEXVEC\_LINESW, 63, 18, 16,
TEXVEC\_LINEDW, 0, 18, 4, TEXVEC\_LINEDW, 31, 33, 4,
TEXVEC\_LINESW, 31, 2, 16, TEXVEC\_LINESE, 0, 21, 16,
TEXVEC\_LINESW, 63, 21, 16, TEXVEC\_LINEDW, 63, 18, 4,
TEXVEC\_LINEDW, 32, 33, 4, TEXVEC\_COLOR, 8,
TEXVEC\_FILL, 31, 5, TEXVEC\_COLOR, 10,
TEXVEC\_FILL, 33, 35, TEXVEC\_COLOR, 11,
TEXVEC\_FILL, 30, 35, TEXVEC\_EXIT },
/\* TEXINDEX\_HOLE \*/
(char[]) { TEXVEC\_COLOR, 13, TEXVEC\_LINESE, 32, 9, 12,
TEXVEC\_LINESE, 8, 21, 12, TEXVEC\_LINESW, 31, 9, 12,
TEXVEC\_LINESW, 55, 21, 12, TEXVEC\_LINESE, 32, 12, 9,
TEXVEC\_LINESE, 14, 21, 9, TEXVEC\_LINESW, 31, 12, 9,
TEXVEC\_LINESW, 49, 21, 9, TEXVEC\_COLOR, 14,
TEXVEC\_LINEDW, 31, 13, 4, TEXVEC\_LINESW, 31, 16, 7,
TEXVEC\_FILL, 30, 14, TEXVEC\_COLOR, 12,
TEXVEC\_FILL, 32, 11, TEXVEC\_COLOR, 15,
TEXVEC\_LINEDW, 32, 13, 4, TEXVEC\_LINESE, 32, 16, 7,
TEXVEC\_FILL, 33, 14, TEXVEC\_COLOR, 16,
TEXVEC\_FILL, 31, 19, TEXVEC\_EXIT }
};
static void \_texture\_draw(int t, int x, int y);
/\*! \brief Создает изображение и сопутствующие сущности \*/
static void \_image\_create(void) {
display = XOpenDisplay(0);
window = XCreateSimpleWindow(display,
RootWindow(display, DefaultScreen(display)),
0, 0, IMAGE\_WIDTH, IMAGE\_HEIGHT, 1, 0, 0);
image = XCreateImage(display,
DefaultVisual(display, DefaultScreen(display)),
DefaultDepth(display, DefaultScreen(display)),
2, 0, (char \*) pixdata, IMAGE\_WIDTH, IMAGE\_HEIGHT, 32, 0);
}
/\* \brief Обнуляет изображение, заполняя его черным цветом \*/
static void \_image\_reset(void) {
for (int y = 0; y < IMAGE\_HEIGHT; y++)
for (int x = 0; x < IMAGE\_WIDTH; x++)
pixdata[y][x] = 0;
}
/\*! \brief Конвертирует символ из чертежа в индекс текстуры
\* \param[in] elem Символ чертежа
\* \return Индекс текстуры \*/
static int \_map2texture(char elem) {
return ((elem >> 4) & 1) << 2 | (elem & 3);
}
/\*! \brief Собирает изображение из отдельных тайлов согласно карте \*/
static void \_image\_compile(void) {
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
\_texture\_draw(\_map2texture(mapdata[y][x]), x, y);
}
/\*! \brief Рисует изображение на экране \*/
static void \_image\_draw(void) {
XPutImage(display, window,
DefaultGC(display, DefaultScreen(display)),
image, 0, 0, 0, 0, IMAGE\_WIDTH, IMAGE\_HEIGHT);
XMapWindow(display, window);
XFlush(display);
}
/\*! \brief Рисует отверстия на печатной плате \*/
static void \_image\_drill(void) {
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if ((x % 14 == 2) && (y % 4 == 3))
\_texture\_draw(TEXINDEX\_HOLE, x, y);
}
/\*! \brief Применяет шейдер LCD-эффекта на изображение
\* \param[in] x X-координата изображения
\* \param[in] y Y-координата изображения \*/
static void \_shader\_lcd(int x, int y) {
pixdata[y][x] &= 0xe0e0e0 | (31 << ((x % 3) << 3));
}
/\*! \brief Применяет шейдер случайного шума на изображение
\* \param[in] x X-координата изображения
\* \param[in] y Y-координата изображения \*/
static void \_shader\_noise(int x, int y) {
pixdata[y][x] += 0x0f0f0f & (random \*= 16777619);
}
/\*! \brief Накладывает на изображение различные эффекты \*/
static void \_image\_postprocess(void) {
for (int y = 0; y < IMAGE\_HEIGHT; y++)
for (int x = 0; x < IMAGE\_WIDTH; x++) {
\_shader\_lcd(x, y);
\_shader\_noise(x, y);
}
}
/\*! \brief Отрисовывает текстуру на главном холсте по указанным координатам
\* \param[in] t Индекс текстуры
\* \param[in] x X координата тайла
\* \param[in] y Y координата тайла \*/
static void \_texture\_draw(int t, int x, int y) {
for (int ty = 0; ty < TEXTURE\_HEIGHT; ty++)
for (int tx = 0; tx < TEXTURE\_WIDTH; tx++)
if (textures[t][ty][tx])
pixdata[ty +
y \* (TEXTURE\_TOP\_HEIGHT / 2) +
x \* (TEXTURE\_TOP\_HEIGHT / 2)]
[tx +
IMAGE\_SHIFTX +
x \* (TEXTURE\_TOP\_WIDTH / 2) -
y \* TEXTURE\_TOP\_HEIGHT] = textures[t][ty][tx];
}
/\*! \brief Производит закраску области текстуры
\* \param[in] t Индекс текстуры
\* \param[in] x X-координата начала
\* \param[in] y Y-координата начала
\* \param[in] source Исходный цвет
\* \param[in] target Новый цвет \*/
static void \_texture\_fill(int t, int x, int y, int source, int target) {
if ((x >= TEXTURE\_WIDTH || y >= TEXTURE\_HEIGHT ||
x < 0 || y < 0) ||
(textures[t][y][x] == target) ||
(textures[t][y][x] != source))
return;
textures[t][y][x] = target;
\_texture\_fill(t, x - 1, y, source, target);
\_texture\_fill(t, x + 1, y, source, target);
\_texture\_fill(t, x, y - 1, source, target);
\_texture\_fill(t, x, y + 1, source, target);
}
/\*! \brief Рисует изометрическую линию по направлению SE
\* \param[in] t Индекс текстуры
\* \param[in] x X-координата начала
\* \param[in] y Y-координата начала
\* \param[in] c Длина линии по короткой стороне
\* \param[in] color Цвет рисования \*/
static void \_texture\_linese(int t, int x, int y, int c, int color) {
while (c--) {
textures[t][y][x++] = color;
textures[t][y++][x++] = color;
}
}
/\*! \brief Рисует изометрическую линию по направлению SW
\* \param[in] t Индекс текстуры
\* \param[in] x X-координата начала
\* \param[in] y Y-координата начала
\* \param[in] c Длина линии по короткой стороне
\* \param[in] color Цвет рисования \*/
static void \_texture\_linesw(int t, int x, int y, int c, int color) {
while (c--) {
textures[t][y][x--] = color;
textures[t][y++][x--] = color;
}
}
/\*! \brief Рисует линию вниз
\* \param[in] t Индекс текстуры
\* \param[in] x X-координата начала
\* \param[in] y Y-координата начала
\* \param[in] c Длина линии
\* \param[in] color Цвет рисования \*/
static void \_texture\_linedown(int t, int x, int y, int c, int color) {
while (c--)
textures[t][y++][x] = color;
}
/\*! \brief Читает данные файла-чертежа и загружает их в карту
\* \param[in] filename Имя файла-чертежа \*/
static void \_map\_read(const char \* filename) {
int f = open(filename, 0);
read(f, mapdata, MAP\_FILEDATA);
close(f);
}
/\*! \brief Заменяет иллюстративные входы из файла-конфигурации на вход
\* в виде провода чтобы работала логика распространения фронта волны \*/
static void \_map\_wire\_inputs(void) {
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if ((x % 14 == 2) && (y % 4 == 3))
mapdata[y][x] = MAPCHAR\_WIRE;
}
/\*! \brief Производит заливку проводника нужным состоянием
\* \param[in] t Игнорируется, артефакт автогенерации кода
\* \param[in] x X-координата заливки
\* \param[in] y Y-координата заливки
\* \param[in] c Исходное состояние
\* \param[in] l Целевое состояние \*/
static void \_map\_fill(int t, int x, int y, int c, int l) {
if ((x >= MAP\_WIDTH || y >= MAP\_HEIGHT ||
x < 0 || y < 0) || (mapdata[y][x] == l)
|| (mapdata[y][x] != c))
return;
mapdata[y][x] = l;
\_map\_fill(t, x - 1, y, c, l);
\_map\_fill(t, x + 1, y, c, l);
\_map\_fill(t, x, y - 1, c, l);
\_map\_fill(t, x, y + 1, c, l);
}
/\*! \brief Включает соответствующие входы схемы в зависимости от значения
\* счетчика.
\* \param[in] counter Счетчик \*/
static void \_map\_wire\_counter(int counter) {
\_map\_fill(0, 2, 3, mapdata[3][2], counter & 1 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
\_map\_fill(0, 2, 7, mapdata[7][2], counter & 2 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
\_map\_fill(0, 2, 11, mapdata[11][2], counter & 4 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
\_map\_fill(0, 2, 15, mapdata[15][2], counter & 8 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
}
/\*! \brief Проводит расчет выходного (результирующего) тока после NOR-узла \*/
static void \_map\_process\_gates(void) {
for (int i = 0; i < MAP\_ITERATIONS; i++)
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if (mapdata[y][x] == MAPCHAR\_NOR)
\_map\_fill(0, x + 1, y, mapdata[y][x + 1],
!(mapdata[y - 1][x] == MAPCHAR\_PLUS ? 1 : 0
|| mapdata[y + 1][x] == MAPCHAR\_PLUS ? 1 : 0) ?
MAPCHAR\_PLUS : MAPCHAR\_MINUS);
}
/\* Код до рефакторинга \*/
int \_x[] = { 15117427, 8413248, 5878632, 13027014, 1 };
int main(int argc, char \* args[]) {
\_image\_create();
for (int tex = 0; tex < TEXTURE\_COUNT; tex++) {
char \* ptr = vecdata[tex];
int c = 0;
while (\*ptr != TEXVEC\_EXIT) {
switch (\*ptr) {
case TEXVEC\_LINESE:
\_texture\_linese(tex, ptr[1], ptr[2], ptr[3], c);
ptr += 4;
break;
case TEXVEC\_LINESW:
\_texture\_linesw(tex, ptr[1], ptr[2], ptr[3], c);
ptr += 4;
break;
case TEXVEC\_LINEDW:
\_texture\_linedown(tex, ptr[1], ptr[2], ptr[3], c);
ptr += 4;
break;
case TEXVEC\_FILL:
\_texture\_fill(tex, ptr[1], ptr[2], 0, c);
ptr += 3;
break;
case TEXVEC\_REPEAT:
ptr = vecdata[ptr[1]];
break;
case TEXVEC\_COLOR:
c = \_x[ptr[1] / 4] - 1643277 \* (ptr[1] % 4);
ptr += 2;
break;
}
}
}
unsigned int counter = 1;
while (counter++) {
\_map\_read(args[ARG\_BLUEPRINT]);
\_map\_wire\_inputs();
\_map\_wire\_counter(counter);
\_map\_process\_gates();
\_image\_reset();
\_image\_compile();
\_image\_drill();
\_image\_postprocess();
\_image\_draw();
sleep(1);
}
return 0;
}
```
Максимальное число, которое стоит после инструкции «TEXVEC\_COLOR» — это 16. Напишем [простейший](https://onlinegdb.com/Hy95lQdQP) код, чтобы получить всю таблицу:
Теперь, имея на руках палитру в расшифрованном виде мы можем заменить функцию её использования и написать расшифровки для цветов в константной таблице, а заодно и выделить функцию создания текстур:
**Полный код после рефакторинга:**
```
#include
#include
#include
#include
#include
/\* Код после рефакторинга \*/
/\*! \brief Ширина изображения в пикселях \*/
#define IMAGE\_WIDTH (1220)
/\*! \brief Высота изображения в пикселях \*/
#define IMAGE\_HEIGHT (616)
/\*! \brief Сдвиг верхней грани карты от левой стороны \*/
#define IMAGE\_SHIFTX (580)
/\*! \brief Количество текстур \*/
#define TEXTURE\_COUNT (8)
/\*! \brief Ширина текстуры в пикселях \*/
#define TEXTURE\_WIDTH (64)
/\*! \brief Высота текстур в пикселях \*/
#define TEXTURE\_HEIGHT (40)
/\*! \brief Ширина грани текстуры в пикселях \*/
#define TEXTURE\_TOP\_WIDTH (64)
/\*! \brief Высота грани текстуры в пикселях \*/
#define TEXTURE\_TOP\_HEIGHT (32)
/\*! \brief Ширина эмулируемого поля \*/
#define MAP\_WIDTH (19)
/\*! \brief Высота эмулируемого поля \*/
#define MAP\_HEIGHT (19)
/\*! \brief Количество данные в файле-чертеже. Один байт добавлен для символа '\n' \*/
#define MAP\_FILEDATA ((MAP\_WIDTH + 1) \* MAP\_HEIGHT)
/\*! \brief Количество итераций во время расчета NOR-узлов \*/
#define MAP\_ITERATIONS (20)
/\*! \brief Содержит структуры синтаксиса файла-конфигурации \*/
enum map\_characters {
MAPCHAR\_WIRE = '.', /\*\*< Провод (ASCII = 46) \*/
MAPCHAR\_PLUS = '+', /\*\*< Провод (есть ток) (ASCII = 43) \*/
MAPCHAR\_MINUS = '-', /\*\*< Провод (нет тока) (ASCII = 45) \*/
MAPCHAR\_NOR = '>', /\*\*< NOR-элемент (ASCII = 62) \*/
MAPCHAR\_EMPTY = ' ', /\*\*< Пустой блок (ASCII = 32) \*/
};
/\*! \brief Содержит индексы текстур \*/
enum textures\_indexes {
TEXINDEX\_EMPTY = (0), /\*\*< Индекс пустой текстуры \*/
TEXINDEX\_MINUS = (1), /\*\*< Индекс текстуры "выключенного провода" \*/
TEXINDEX\_WIRE = (2), /\*\*< Индекс текстуры нейтрального провода \*/
TEXINDEX\_PLUS = (3), /\*\*< Индекс текстуры "включенного" провода \*/
/\*\*/
TEXINDEX\_NOR = (6), /\*\*< Индекс текстуры NOR-элемента \*/
TEXINDEX\_HOLE = (7) /\*\*< Индекс текстуры отверстия на плате \*/
};
/\*! \brief Список инструкций векторного интерпретатора \*/
enum textures\_instructions {
TEXVEC\_LINESE = (0), /\*\*< Линия SE \*/
TEXVEC\_LINESW = (1), /\*\*< Линия SW \*/
TEXVEC\_LINEDW = (2), /\*\*< Линия вниз \*/
TEXVEC\_FILL = (3), /\*\*< Заливка \*/
TEXVEC\_EXIT = (4), /\*\*< Конец списка инструкций \*/
TEXVEC\_REPEAT = (5), /\*\*< Повтор инструкций другой текстуры \*/
TEXVEC\_COLOR = (6) /\*\*< Выбор цвета \*/
};
/\*! \brief Аргументы программы \*/
enum program\_arguments {
ARG\_PROGRAM, /\*\*< Имя самой программы \*/
ARG\_BLUEPRINT /\*\*< Имя файла-чертежа \*/
};
/\*! \brief Бинарные данные пикселей изображения.
\* Типизированы к int для оперирования пикселями вместо каналов \*/
int pixdata[IMAGE\_HEIGHT][IMAGE\_WIDTH];
/\*! \brief Текстуры блоков, отображаемых на поле \*/
int textures[TEXTURE\_COUNT][TEXTURE\_HEIGHT][TEXTURE\_WIDTH] = { 0 };
/\*! \brief Данные эмулируемого поля.
\* Один байт добавлен для упрощения обработки символа '\n' \*/
char mapdata[MAP\_HEIGHT][MAP\_WIDTH + 1];
/\*! \brief Зерно генератора случайных чисел \*/
int random = 2166136261;
/\*! \brief Экземпляр дисплея Xlib \*/
Display \* display;
/\*! \brief Экземпляр главного окна Xlib \*/
Window window;
/\*! \brief Изображение для вывода на экран \*/
XImage \* image;
/\*! \brief Палитра цветов для векторной отрисовки
\* \note Черный имеет цвет {001} для отличия от "прозрачного" черного {000} \*/
static const int texturepalette[] = {
/\* Светлее ▁▁▂▂▃▃▄▄▅▅▆▆▇▇██ Темнее \*/
/\* Светло-коричневый \*/ 0xe6ac73, 0xcd9966, 0xb48659, 0x9b734c,
/\* Темно-коричневый \*/ 0x806040, 0x674d33, 0x4e3a26, 0x352719,
/\* Зеленый \*/ 0x59b368, 0x40a05b, 0x278d4e, 0x0e7a41,
/\* Серый \*/ 0xc6c6c6, 0xadb3b9, 0x94a0ac, 0x7b8d9f,
/\* Черный \*/ 0x000001
};
/\*! \brief Векторные инструкции для рисования текстур \*/
static const char \* vecdata[TEXTURE\_COUNT] = {
/\* TEXINDEX\_EMPTY \*/
(char[]) { TEXVEC\_EXIT },
/\* TEXINDEX\_MINUS \*/
(char[]) { TEXVEC\_COLOR, 5, TEXVEC\_LINESE, 32, 5, 16,
TEXVEC\_LINESE, 0, 21, 16, TEXVEC\_LINESW, 63, 21, 16,
TEXVEC\_LINEDW, 0, 21, 4, TEXVEC\_LINEDW, 31, 36, 4,
TEXVEC\_LINESW, 31, 5, 16, TEXVEC\_LINESE, 0, 24, 16,
TEXVEC\_LINESW, 63, 24, 16, TEXVEC\_LINEDW, 63, 21, 4,
TEXVEC\_LINEDW, 32, 36, 4, TEXVEC\_COLOR, 4,
TEXVEC\_FILL, 31, 8, TEXVEC\_COLOR, 6,
TEXVEC\_FILL, 33, 38, TEXVEC\_COLOR, 7,
TEXVEC\_FILL, 30, 38, TEXVEC\_EXIT },
/\* TEXINDEX\_WIRE \*/
(char[]) { TEXVEC\_REPEAT, 1 },
/\* TEXINDEX\_PLUS \*/
(char[]) { TEXVEC\_COLOR, 1, TEXVEC\_LINESE, 32, 5, 16,
TEXVEC\_LINESE, 0, 21, 16, TEXVEC\_LINESW, 63, 21, 16,
TEXVEC\_LINEDW, 63, 21, 4, TEXVEC\_LINEDW, 31, 36, 4,
TEXVEC\_LINESW, 31, 5, 16, TEXVEC\_LINESE, 0, 24, 16,
TEXVEC\_LINESW, 63, 24, 16, TEXVEC\_LINEDW, 63, 21, 4,
TEXVEC\_LINEDW, 32, 36, 4, TEXVEC\_COLOR, 0,
TEXVEC\_FILL, 31, 8, TEXVEC\_COLOR, 2,
TEXVEC\_FILL, 33, 38, TEXVEC\_COLOR, 3,
TEXVEC\_FILL, 30, 38, TEXVEC\_EXIT },
/\* Не используется \*/
(char[]) { TEXVEC\_EXIT },
/\* Не используется \*/
(char[]) { TEXVEC\_EXIT },
/\* TEXINDEX\_NOR \*/
(char[]) { TEXVEC\_COLOR, 9, TEXVEC\_LINESE, 32, 2, 16,
TEXVEC\_LINESE, 0, 18, 16, TEXVEC\_LINESW, 63, 18, 16,
TEXVEC\_LINEDW, 0, 18, 4, TEXVEC\_LINEDW, 31, 33, 4,
TEXVEC\_LINESW, 31, 2, 16, TEXVEC\_LINESE, 0, 21, 16,
TEXVEC\_LINESW, 63, 21, 16, TEXVEC\_LINEDW, 63, 18, 4,
TEXVEC\_LINEDW, 32, 33, 4, TEXVEC\_COLOR, 8,
TEXVEC\_FILL, 31, 5, TEXVEC\_COLOR, 10,
TEXVEC\_FILL, 33, 35, TEXVEC\_COLOR, 11,
TEXVEC\_FILL, 30, 35, TEXVEC\_EXIT },
/\* TEXINDEX\_HOLE \*/
(char[]) { TEXVEC\_COLOR, 13, TEXVEC\_LINESE, 32, 9, 12,
TEXVEC\_LINESE, 8, 21, 12, TEXVEC\_LINESW, 31, 9, 12,
TEXVEC\_LINESW, 55, 21, 12, TEXVEC\_LINESE, 32, 12, 9,
TEXVEC\_LINESE, 14, 21, 9, TEXVEC\_LINESW, 31, 12, 9,
TEXVEC\_LINESW, 49, 21, 9, TEXVEC\_COLOR, 14,
TEXVEC\_LINEDW, 31, 13, 4, TEXVEC\_LINESW, 31, 16, 7,
TEXVEC\_FILL, 30, 14, TEXVEC\_COLOR, 12,
TEXVEC\_FILL, 32, 11, TEXVEC\_COLOR, 15,
TEXVEC\_LINEDW, 32, 13, 4, TEXVEC\_LINESE, 32, 16, 7,
TEXVEC\_FILL, 33, 14, TEXVEC\_COLOR, 16,
TEXVEC\_FILL, 31, 19, TEXVEC\_EXIT }
};
static void \_texture\_draw(int t, int x, int y);
/\*! \brief Создает изображение и сопутствующие сущности \*/
static void \_image\_create(void) {
display = XOpenDisplay(0);
window = XCreateSimpleWindow(display,
RootWindow(display, DefaultScreen(display)),
0, 0, IMAGE\_WIDTH, IMAGE\_HEIGHT, 1, 0, 0);
image = XCreateImage(display,
DefaultVisual(display, DefaultScreen(display)),
DefaultDepth(display, DefaultScreen(display)),
2, 0, (char \*) pixdata, IMAGE\_WIDTH, IMAGE\_HEIGHT, 32, 0);
}
/\* \brief Обнуляет изображение, заполняя его черным цветом \*/
static void \_image\_reset(void) {
for (int y = 0; y < IMAGE\_HEIGHT; y++)
for (int x = 0; x < IMAGE\_WIDTH; x++)
pixdata[y][x] = 0;
}
/\*! \brief Конвертирует символ из чертежа в индекс текстуры
\* \param[in] elem Символ чертежа
\* \return Индекс текстуры \*/
static int \_map2texture(char elem) {
return ((elem >> 4) & 1) << 2 | (elem & 3);
}
/\*! \brief Собирает изображение из отдельных тайлов согласно карте \*/
static void \_image\_compile(void) {
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
\_texture\_draw(\_map2texture(mapdata[y][x]), x, y);
}
/\*! \brief Рисует изображение на экране \*/
static void \_image\_draw(void) {
XPutImage(display, window,
DefaultGC(display, DefaultScreen(display)),
image, 0, 0, 0, 0, IMAGE\_WIDTH, IMAGE\_HEIGHT);
XMapWindow(display, window);
XFlush(display);
}
/\*! \brief Рисует отверстия на печатной плате \*/
static void \_image\_drill(void) {
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if ((x % 14 == 2) && (y % 4 == 3))
\_texture\_draw(TEXINDEX\_HOLE, x, y);
}
/\*! \brief Применяет шейдер LCD-эффекта на изображение
\* \param[in] x X-координата изображения
\* \param[in] y Y-координата изображения \*/
static void \_shader\_lcd(int x, int y) {
pixdata[y][x] &= 0xe0e0e0 | (31 << ((x % 3) << 3));
}
/\*! \brief Применяет шейдер случайного шума на изображение
\* \param[in] x X-координата изображения
\* \param[in] y Y-координата изображения \*/
static void \_shader\_noise(int x, int y) {
pixdata[y][x] += 0x0f0f0f & (random \*= 16777619);
}
/\*! \brief Накладывает на изображение различные эффекты \*/
static void \_image\_postprocess(void) {
for (int y = 0; y < IMAGE\_HEIGHT; y++)
for (int x = 0; x < IMAGE\_WIDTH; x++) {
\_shader\_lcd(x, y);
\_shader\_noise(x, y);
}
}
/\*! \brief Отрисовывает текстуру на главном холсте по указанным координатам
\* \param[in] t Индекс текстуры
\* \param[in] x X координата тайла
\* \param[in] y Y координата тайла \*/
static void \_texture\_draw(int t, int x, int y) {
for (int ty = 0; ty < TEXTURE\_HEIGHT; ty++)
for (int tx = 0; tx < TEXTURE\_WIDTH; tx++)
if (textures[t][ty][tx])
pixdata[ty +
y \* (TEXTURE\_TOP\_HEIGHT / 2) +
x \* (TEXTURE\_TOP\_HEIGHT / 2)]
[tx +
IMAGE\_SHIFTX +
x \* (TEXTURE\_TOP\_WIDTH / 2) -
y \* TEXTURE\_TOP\_HEIGHT] = textures[t][ty][tx];
}
/\*! \brief Производит закраску области текстуры
\* \param[in] t Индекс текстуры
\* \param[in] x X-координата начала
\* \param[in] y Y-координата начала
\* \param[in] source Исходный цвет
\* \param[in] target Новый цвет \*/
static void \_texture\_fill(int t, int x, int y, int source, int target) {
if ((x >= TEXTURE\_WIDTH || y >= TEXTURE\_HEIGHT ||
x < 0 || y < 0) ||
(textures[t][y][x] == target) ||
(textures[t][y][x] != source))
return;
textures[t][y][x] = target;
\_texture\_fill(t, x - 1, y, source, target);
\_texture\_fill(t, x + 1, y, source, target);
\_texture\_fill(t, x, y - 1, source, target);
\_texture\_fill(t, x, y + 1, source, target);
}
/\*! \brief Рисует изометрическую линию по направлению SE
\* \param[in] t Индекс текстуры
\* \param[in] x X-координата начала
\* \param[in] y Y-координата начала
\* \param[in] c Длина линии по короткой стороне
\* \param[in] color Цвет рисования \*/
static void \_texture\_linese(int t, int x, int y, int c, int color) {
while (c--) {
textures[t][y][x++] = color;
textures[t][y++][x++] = color;
}
}
/\*! \brief Рисует изометрическую линию по направлению SW
\* \param[in] t Индекс текстуры
\* \param[in] x X-координата начала
\* \param[in] y Y-координата начала
\* \param[in] c Длина линии по короткой стороне
\* \param[in] color Цвет рисования \*/
static void \_texture\_linesw(int t, int x, int y, int c, int color) {
while (c--) {
textures[t][y][x--] = color;
textures[t][y++][x--] = color;
}
}
/\*! \brief Рисует линию вниз
\* \param[in] t Индекс текстуры
\* \param[in] x X-координата начала
\* \param[in] y Y-координата начала
\* \param[in] c Длина линии
\* \param[in] color Цвет рисования \*/
static void \_texture\_linedown(int t, int x, int y, int c, int color) {
while (c--)
textures[t][y++][x] = color;
}
/\*! \brief Создает все текстуры, интерпретатор векторных инструкций \*/
static void \_textures\_create(void) {
for (int tex = 0; tex < TEXTURE\_COUNT; tex++) {
const char \* ptr = vecdata[tex];
int c = 0;
while (\*ptr != TEXVEC\_EXIT) {
switch (\*ptr) {
case TEXVEC\_LINESE:
\_texture\_linese(tex, ptr[1], ptr[2], ptr[3], c);
ptr += 4;
break;
case TEXVEC\_LINESW:
\_texture\_linesw(tex, ptr[1], ptr[2], ptr[3], c);
ptr += 4;
break;
case TEXVEC\_LINEDW:
\_texture\_linedown(tex, ptr[1], ptr[2], ptr[3], c);
ptr += 4;
break;
case TEXVEC\_FILL:
\_texture\_fill(tex, ptr[1], ptr[2], 0, c);
ptr += 3;
break;
case TEXVEC\_REPEAT:
ptr = vecdata[ptr[1]];
break;
case TEXVEC\_COLOR:
c = texturepalette[ptr[1]];
ptr += 2;
break;
}
}
}
}
/\*! \brief Читает данные файла-чертежа и загружает их в карту
\* \param[in] filename Имя файла-чертежа \*/
static void \_map\_read(const char \* filename) {
int f = open(filename, 0);
read(f, mapdata, MAP\_FILEDATA);
close(f);
}
/\*! \brief Заменяет иллюстративные входы из файла-конфигурации на вход
\* в виде провода чтобы работала логика распространения фронта волны \*/
static void \_map\_wire\_inputs(void) {
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if ((x % 14 == 2) && (y % 4 == 3))
mapdata[y][x] = MAPCHAR\_WIRE;
}
/\*! \brief Производит заливку проводника нужным состоянием
\* \param[in] t Игнорируется, артефакт автогенерации кода
\* \param[in] x X-координата заливки
\* \param[in] y Y-координата заливки
\* \param[in] c Исходное состояние
\* \param[in] l Целевое состояние \*/
static void \_map\_fill(int t, int x, int y, int c, int l) {
if ((x >= MAP\_WIDTH || y >= MAP\_HEIGHT ||
x < 0 || y < 0) || (mapdata[y][x] == l)
|| (mapdata[y][x] != c))
return;
mapdata[y][x] = l;
\_map\_fill(t, x - 1, y, c, l);
\_map\_fill(t, x + 1, y, c, l);
\_map\_fill(t, x, y - 1, c, l);
\_map\_fill(t, x, y + 1, c, l);
}
/\*! \brief Включает соответствующие входы схемы в зависимости от значения
\* счетчика.
\* \param[in] counter Счетчик \*/
static void \_map\_wire\_counter(int counter) {
\_map\_fill(0, 2, 3, mapdata[3][2], counter & 1 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
\_map\_fill(0, 2, 7, mapdata[7][2], counter & 2 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
\_map\_fill(0, 2, 11, mapdata[11][2], counter & 4 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
\_map\_fill(0, 2, 15, mapdata[15][2], counter & 8 ? MAPCHAR\_PLUS : MAPCHAR\_MINUS);
}
/\*! \brief Проводит расчет выходного (результирующего) тока после NOR-узла \*/
static void \_map\_process\_gates(void) {
for (int i = 0; i < MAP\_ITERATIONS; i++)
for (int y = 0; y < MAP\_HEIGHT; y++)
for (int x = 0; x < MAP\_WIDTH; x++)
if (mapdata[y][x] == MAPCHAR\_NOR)
\_map\_fill(0, x + 1, y, mapdata[y][x + 1],
!(mapdata[y - 1][x] == MAPCHAR\_PLUS ? 1 : 0
|| mapdata[y + 1][x] == MAPCHAR\_PLUS ? 1 : 0) ?
MAPCHAR\_PLUS : MAPCHAR\_MINUS);
}
int main(int argc, char \* args[]) {
\_image\_create();
\_textures\_create();
unsigned int counter = 1;
while (counter++) {
\_map\_read(args[ARG\_BLUEPRINT]);
\_map\_wire\_inputs();
\_map\_wire\_counter(counter);
\_map\_process\_gates();
\_image\_reset();
\_image\_compile();
\_image\_drill();
\_image\_postprocess();
\_image\_draw();
sleep(1);
}
return 0;
}
```
Эпилог
------
[Вот и всё.](https://github.com/codemeow/ioccc2020/blob/master/nor/refactored.c) Несмотря на то, что я не занял никаких призовых мест, это был достаточно любопытный опыт (умерший за два дня до начала приема работ HDD этому поспособствовал). Было что-то неправильное в том, чтобы писать код, максимально не читаемый и одновременно абсолютно валидный с точки зрения языка. Однако нельзя сказать, что это было неинтересно. Когда утилита, подсчитывающая токены говорит, что код нарушает правила превышая лимит на 2000+ токенов, а ты не знаешь, как его сократить — это вызов. Когда размер файла превышает лимиты, а ты хочешь добавить какой-то графический эффект — это вызов. Это было трудно, вместить столько функционала, и тем слаще было читать вывод утилиты, которая после нескольких сотен исправлений наконец-таки сказала, что код можно выгружать. Я бы порекомендовал читателям поучаствовать в конкурсе хотя бы просто для того, чтобы приобщиться и испытать свои силы.
Да, никаких наград или призов это не дает, но зато вы будете знать, что под ником zhestokyshveller на сайте IOCCC скрываетесь вы. | https://habr.com/ru/post/516296/ | null | ru | null |
# Git: много хуков полезных и разных
Статья является вольным переводом вот [этого материала](http://krisjordan.com/essays/setting-up-push-to-deploy-with-git). Любителям длинных и заумных первоисточников можно сразу читать оригинал.
Когда перед нами ставится задача при изменении кодбейса, например, в Github-репозитории выполнить пересборку/перезапуск какого-нибудь приложения на каком-то нашем окружении, то первое, что приходит на ум в качестве возможного триггера такой пересборки, это предоставляемый тем же гитхабом механизм веб-хуков: при наступлении какого-либо события с нашим удаленным репозиторием (т.к. появление нового коммита в какой-нибудь его отслеживаемой ветке) гитхаб задействует соответствующий веб-хук и «дернет» указанный в его настройках сервис, который и запустит процесс пересборки/перезапуска нашего приложения. Это стандартный широкоиспользуемый и простой механизм для таких случаев, все так делают, и все такое…
Но что, если наше приложение живет на хосте, доступ к которому по каким-то причинам гитхабу не положен? Например, хост находится в закрытой сети или за NAT'ом и недоступен из интернета?
В этом случае можно воспользоваться механизмом локальных хуков самого Git, о котором (механизме), как выясняется, мало кто знает даже из тех, кто использует Git уже довольно продолжительное время.
Когда мы создаем локальный репозиторий (инициализируем пустой, клонируем удаленный, ...), то в папке .git, что в его корне, или в самом корне, если это bare-репозиторий, присутствует папка hooks. После инициализации репозитория в этой папке сохраняются шаблоны хуков для различных событий, таких как, например: post-merge, post-receive, post-update и др.
Полное описание поддерживаемых событий для хуков можно найти, например, [тут](http://git-scm.com/book/ru/v1/Настройка-Git-Перехватчики-в-Git).
Мы воспользуемся этим механизмом и реализуем простенькую push-to-deploy схему для нашего горемычного приложения.
Нам понадобится два локальных репозитория. Создадим их, например, по указанным путям:
1. /opt/repo-dev/example-repo/
2. /opt/repo-remote.git/
Первый репозиторий — это клон нашего удаленного репозитория example-repo на гитхабе.
Второй — это bare репозиторий, копия первого, который будет служить нам исключительно для обработки события post-update при появлении обновлений в удаленном репозитории. Итак, как же мы это реализуем?
Схема очень проста (предположим, мы отслеживаем ветку test, а приложение наше это node.js, управляемый менеджером pm2):
1. Периодически обновляем первый локальный репозиторий до состояния, полностью соотвествующего состоянию удаленного репозитория.
2. Из первого локального репозитория обновляем второй.
3. Как только HEAD у нас переместился — появился новый коммит — во втором репозитории будет задействован хук post-update, который выполняется при появлении любых изменений в репозитории, и который и выполнит необходимые действия по ребилду и рестарту приложения.
Для этого мы делаем следующее:
1. В первом локальном репозитории добавляем remote — второй локальный репозиторий:
```
cd /opt/repo-dev/example-repo/ && git remote add prod /opt/repo-remote.git
```
Теперь мы можем выполнять git push из первого локального репозитория во второй.
2. В папке /opt/repo-remote.git/hooks/ создаем файл post-update и делаем его исполняемым:
```
touch /opt/repo-remote.git/hooks/post-update && chmod +x /opt/repo-remote.git/hooks/post-update
```
Это обычный шел-скрипт, но согласно внутренней конвенции Git *без расширения .sh*!
Давайте добавим в него несколько команд:
```
#!/bin/bash
cd /opt/repo-remote.git
/usr/bin/git --work-tree=/opt/repo/example-repo/ checkout -f origin/test
cd /opt/repo/example-repo/
/usr/bin/npm install
/usr/local/bin/pm2 restart all
```
Что делает скрипт? Сначала просто выгружает working tree нашего bare репозитория в папку с нашим работающим приложением, а затем пересобирает зависимости и рестартует сервисы pm2. Как видите, никакой магии.
3. Настраиваем cron, который каждые n минут будет обновлять первый репозиторий из удаленного:
```
git fetch origin && git reset --hard -f origin/test
```
Т.о. теперь наш хост будет являться регулярным инициатором проверки удаленного репозитория — а не появились ли там обновления?
Прошу заметить, что обновляем локальный репозиторий мы не путем git pull, а путем git reset --hard. Делается это для того, чтобы исключить необходимость мерджей при определенном содержимом очередного коммита — мы делаем локальный репозиторий полной копией удаленного.
4. Сразу после синхронизации первого локального репозитория с удаленным мы делаем пуш всех изменений в наш псевдо-удаленный второй локальный репозиторий:
```
git push prod test
```
Вот и все. Как только наш псевдо-удаленный локальный репозиторий получает ненулевые изменения, Git дергает свой хук post-update, который выполняет соответствующий скрипт. И мы получаем простенькую рабочую схему push-to-deploy, которую при желании можно и дальше усовершенствовать в соответствии с нашими потребностями.
«Зачем городить такую неудобоваримую монструозную схему?!» — спросите вы. Я сначала задавался этим же вопросом, но оказалось, что с существующим перечнем хуков Git'а только так мы сможем вызвать необходимую обработку при любом обновлении нашей ветки в удаленном репозитории. Нужный нам хук post-update предназначен для выполнения на remote репозитории (а часть хуков предназначена для выполнения на локальном репозитории). И мы таким вот не очень изящным способом это псевдо-удаленный репозиторий и сэмулировали. Возможно в скором времени появится еще какой-нибудь более удобный хук, выполняющийся локально, и схему можно будет упростить. Но пока так.
В заключение хочу дать несколько советов тем, кто решит это реализовать у себя и, столкнувшись с проблемами неработающего хука или каких-то его частей, будет яростно проклинать меня, Git, автора оригинальной статьи и всех остальных по списку:
1. Помните про специфику работы cron — программы в нем по умолчанию запускаются совсем не в том окружении, которое вы, вероятно, ожидаете.
2. Проверяйте версии ваших утилит (npm, node etc) при вызове их из скриптов и по cron — они могут быть не такими, как при ручном запуске из-за различия путей к исполняемым файлам в переменных окружения, например. А запуск других их версий может приводить к непрогнозируемым результатам.
3. Потратьте 20 минут на просмотр очередной серии Simpsons и возвращайтесь к экспериментам с новыми силами и хорошим настроением
Буду рад любым замечаниям и уточнениям по существу.
Хорошего всем дня! | https://habr.com/ru/post/329804/ | null | ru | null |
# Полный обзор webpack
[](https://habr.com/ru/company/piter/blog/710844/)
Поскольку грань между веб-сайтами и веб-приложениями продолжает размываться, возможности и проблемы для разработчиков становятся все более сложными. В связи с тем, что веб-приложения в значительной степени зависят от JavaScript, клиентской части приходится справляться со все большими нагрузками. Одним из лучших способов справиться с дополнительной нагрузкой является **использование системы модулей**, например, webpack. Системы модулей облегчают разработчикам организацию процессов, а также обеспечивают быструю и эффективную передачу контента пользователям.
Важность организации никогда нельзя недооценивать; она приносит пользу не только отдельным программистам, но и всем, кто будет использовать ту же базу кода в будущем. Если вы решили управлять своим кодом с помощью модулей, вам нужен сборщик модулей, и нет лучшего сборщика, чем webpack.
Что такое webpack?
------------------
Webpack генерирует статические ресурсы, которые представляют собой модули с зависимостями. Существует несколько популярных программ для создания модулей JavaScript, включая [Browserify](https://browserify.org/), [rollup](https://rollupjs.org/guide/en/) и [jspm](https://jspm.org/), но webpack остается фаворитом, поскольку он трактует веб-ресурсы как модули с зависимостями.
Согласно [сайту](https://webpack.github.io/) webpack, этот пакет модулей создавался со следующими целями:
* Обеспечить беспрецедентную свободу кастомизации.
* Сократить время начальной загрузки.
* Для разделения деревьев зависимостей на фрагменты, которые загружаются по требованию.
* Чтобы позволить каждому статическому ресурсу быть модулем.
* Чтобы обеспечить интеграцию сторонних библиотек в качестве модулей.
Если вы никогда раньше не видели конфигурационных файлов webpack, то на первый взгляд они могут показаться пугающими; однако, как только вы поймете синтаксис и основную философию, лежащую в основе бандлера, их чтение покажется вам второй натурой. Во-первых, вам необходимо **понять два основных принципа**:
1. В webpack **модулем может быть любая сущность**. Это касается и JS-файлов, и CSS, и изображений, и HTML. Следовательно, любой объект может быть разделен на небольшие, управляемые фрагменты для повторного использования.
2. webpack загружает только то, что вам нужно, когда вам это нужно. Другие сборщики модулей обычно объединяют все модули для создания одного большого файла bundle.js. Такие файлы могут достигать **15 МБ** для динамических веб-приложений, и их загрузка занимает много времени. В отличие от них, webpack генерирует несколько небольших файлов «bundle», что позволяет ему загружать части приложения [асинхронно](https://www.keycdn.com/support/prefer-async-resources). Таким образом, пользователям не нужно ждать неоправданно долго, чтобы начать работу с приложением.
История версий
--------------
Новая версия, webpack 2.2.0, была выпущена в начале 2017 года, и команда разработчиков просит пользователей [оставить отзывы](https://webpack.js.org/vote/) о том, улучшение каких функций они хотели бы видеть. Это руководство будет в основном посвящено оригинальному воплощению webpack 2, поскольку версии в основном одинаковые. Создатели опубликовали подробное руководство для тех, кто хочет [перейти на webpack 2](https://webpack.js.org/migrate), если вы все еще используете версию 1, так как она уже устарела.
Различия в новой версии будут рассмотрены в конце этой статьи или по мере их возникновения.
Начало работы
-------------
webpack лучше всего работает с [npm](https://www.npmjs.com/), поэтому данное руководство будет посвящено установке на npm. Вы можете найти более подробную информацию о [настройке webpack](https://webpack.js.org/guides/getting-started/) на их сайте; однако, ввиду того, что приведенные ниже примеры предполагают установку npm, могут быть различия между этим руководством и другими примерами, которые вы увидите в других местах.
Конфигурация webpack — настолько плотная тема, что можно написать целую книгу на эту тему. На самом деле, кто-то уже [написал книгу об этом](https://survivejs.com/webpack/introduction/). Конкретные настройки, которые вам понадобятся, будут в значительной степени зависеть от вашего конкретного проекта. Поэтому в данном руководстве мы рассмотрим только основы и укажем вам правильное направление для изучения более технических тем.
Установка
---------
Для установки webpack вам необходимо поставить [node.js](https://nodejs.org/en/). После этого просто введите в командную строку следующее:
```
npm install -g webpack
```
webpack теперь должен быть доступен в любом месте. Вы можете убедиться в том, что он действительно был установлен, открыв терминал и набрав webpack.
Настройка базовой компиляции
----------------------------
Чтобы продемонстрировать работу webpack на самом базовом уровне, вам потребуется создать два отдельных файла: entry.js и index.html.
```
entry.js
document.write("Hello World.");
index.html
```
Когда эти два файла созданы, вы можете выполнить следующую команду в консоли: webpack ./entry.js bundle.js. С помощью этой команды webpack ссылается на файл entry.js и в итоге создает файл bundle.js.
Как определить файл конфигурации
--------------------------------
Установка — это только первый шаг; вам предстоит еще многое настроить, прежде чем вы сможете приступить к созданию сложных сборок. Как только вы начнете добавлять модули JS, CSS и тому подобное, запуск из командной строки станет непрактичным, вот почему нам нужен файл конфигурации.
В webpack файл config — это модуль common.js, в котором вы можете хранить всю важную информацию о вашей сборке. Чтобы определить базовый конфигурационный файл, создайте файл webpack.config.js в корневом каталоге и вставьте в него следующий код:
```
module.exports = {
entry: "./entry.js",
output: {
filename: "bundle.js"
}
}
```
В приведенном выше коде необходимо понять две принципиальные составляющие: где находится точка входа и точка вывода. Точка входа соответствует имени файла верхнего уровня или массива файлов, которые нужны для вашей сборки. В данном случае точкой входа является ваш главный файл entry.js. Точка вывода — это ключевое имя файла, в данном случае, bundle.js, для файла, собрать который вы поручаете webpack. Теперь вернитесь в командную строку и введите:
```
webpack
```
При наличии файла webpack.config команда должна создать ваше приложение, используя содержащуюся в этом файле информацию.
Как отслеживать изменения
-------------------------
В webpack есть множество удобных шорткатов, позволяющих не тратить время на многократное решение одних и тех же задач. Например, вместо того чтобы набирать webpack в командной строке каждый раз, когда вы хотите скомпилировать код, вы можете приказать webpack отслеживать изменения, чтобы всякий раз, когда вы изменяете код в редакторе, он **автоматически компилировался**.
Есть несколько способов настроить такую функцию. Первый вариант — ввести в командную строку следующее:
```
webpack –watch
```
Теперь при каждом изменении команда webpack должна автоматически перезапускаться.
В качестве альтернативы вы можете настроить режим наблюдения. В режиме наблюдения каталог проекта проверяется каждый раз, когда выполняется команда webpack. Вы можете включить режим наблюдения, открыв свой конфигурационный файл и вставив следующее:
```
module.exports = {
entry: './entry.js',
output: {
filename: './bundle.js'
},
watch: true
};
```
Загрузчики
----------
Сам по себе webpack может интерпретировать только файлы .js. Поэтому нам нужен способ преобразования ресурсов, например, изображений и CSS, в модули JavaScript. Вот тут-то и приходят на помощь загрузчики.
webpack не поставляется с предустановленными загрузчиками, поэтому вам придется **установить те, которые нужны для вашего конкретного проекта**. Это может показаться неудобным, однако включение всех загрузчиков по умолчанию приведет к тому, что webpack будет перегружен зависимостями, поэтому подбор минимально необходимой конфигурации, делает сборку более эффективной.
Загрузчики можно объединять в цепочки. Среди прочего, это позволяет вам преобразовывать файлы SCSS в CSS перед преобразованием CSS в JavaScript. Вы также можете создавать свои собственные загрузчики; однако все, что вам нужно, скорее всего, уже сделано сообществом webpack, поэтому ознакомьтесь с [полным списком загрузчиков](https://webpack.js.org/loaders/), прежде чем пытаться создать свой собственный.
Как собрать цепочку загрузчиков
-------------------------------
Объединение нескольких загрузчиков для работы с одним файлом может быть выполнено двумя способами. Первый способ — разделить загрузчики восклицательным знаком. В качестве альтернативы можно также использовать массив загрузчиков. Помните, что загрузчики обрабатываются справа налево.
Прежде чем вы сможете загрузить CSS, вам понадобятся два загрузчика: css-loader и style-loader Первый загружает содержимое файла, а второй вставляет его. Если вы следовали этому руководству, вы можете установить их, введя в командную строку следующее:
```
npm install --save-dev css-loader style-loader
```
Теперь, когда загрузчики установлены, вы можете обработать ваш CSS-файл с помощью следующего кода:
```
module.exports = {
// ...
module: {
loaders: [
{
test: /.css$/,
exclude: /node_modules/,
loader: 'style!css'
}
],
}
};
```
Плагины
-------
Загрузчики — не то же самое, что плагины. Тогда как загрузчики работают на уровне отдельных файлов во время или до создания сборки, плагины работают на уровне фрагментов в конце процесса. Особенно полезным плагином является [uglifyJSPlugin](https://github.com/mishoo/UglifyJS), который уменьшает размер файла путем обфускации содержимого вашего bundle.js. Еще один важный плагин — [extract-text-webpack-plugin](https://github.com/webpack-contrib/extract-text-webpack-plugin), который собирает весь CSS в одном месте, а затем выносит его во внешний файл styles.css. На GitHub есть их [обширный список](https://github.com/webpack/docs/wiki/list-of-plugins).
Поддержка ES6
-------------
Если вы все еще используете webpack 1 и кодите с использованием стандартов ES6, то вам нужен инструмент транспиляции, такой как babel, чтобы убедиться, что ваш код работает в большинстве браузеров. webpack 2 поддерживает транспиляцию ES6 из коробки, поэтому вы можете пропустить этот шаг, если используете последнюю версию.
Чтобы webpack мог конвертировать ES6 в ES5 с помощью babel, вам понадобятся три вещи: [babel-loader](https://github.com/babel/babel-loader), [babel-core](https://www.npmjs.com/package/babel-core) и [babel-preset-2015](https://www.npmjs.com/package/babel-preset-es2015). Установите эти зависимости с помощью следующей команды:
```
npm install --save-dev babel-loader babel-core babel-preset-es2015
```
Теперь вы можете добавить загрузчик модулей в конфигурационный файл с помощью следующего кода:
```
module.exports = {
// ...
module: {
loaders: [
{
test: /.js$/,
exclude: /node_modules/,
loader: 'babel',
query: {
presets: ['es2015']
}
}
],
}
};
```
Загрузчик модулей — это массив, который ищет указанные файлы для организации их последующей загрузки.
В приведенном выше коде вы приказываете webpack искать вне каталога node\_modules, такие файлы, которые заканчиваются на .js, а затем запускать их через загрузчик babel. Babel должен использовать предустановленную es2015.
Ваш персональный сервер разработки
----------------------------------
Пока вы работаете, webpack может создать удобный сервер разработки, чтобы вы могли организовать ревью своего кода. Сервер автоматически распознает изменения и обновляет браузер всякий раз, когда компилируется пакет. Чтобы установить его, выполните в командной строке следующие действия:
```
npm install webpack-dev-server -g
```
После установки сервера запустите команду webpack-dev-server из каталога проекта. Она должна выполняться непрерывно. После этого ваш проект должен быть доступен для просмотра по адресу [http://locаlhоst:8080/webpack-dev-server/](http://loc%D0%B0lh%D0%BEst:8080/webpack-dev-server/).
Оптимизация производительности
------------------------------
Прежде чем ваши скрипты и стили будут готовы к продакшену, необходимо минифицировать ваши сборки. Это можно сделать с помощью очень простой команды. Из корня проекта выполните:
```
webpack -p
```
[Минификация](https://www.keycdn.com/support/how-to-minify-css-js-and-html) позволяет избавиться от ненужных символов в исходном коде, добившись более эффективной работы.
Как работает webpack?
---------------------
Естественно, вам может быть интересно, каков webpack в сравнении с другими сборщиками модулей. К счастью, разработчики составили таблицу с подробным описанием [различий между webpack и аналогичными инструментами](https://webpack.js.org/comparison/).
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| Характеристика | Webpack/
webpack | Jbruke/
requirejs | Substack/
node-browserify | Jspm/
jspm-cli | Rollup/
rollup |
| CommonJS require | Да | Только в оболочке define | Да | Да | Commonjs-plugin |
| CommonJS require.resolve | Да | Нет | Нет | Нет | Нет |
| CommonJS exports | Да | Только в оболочке define | Да | Да | Commonjs-plugin |
| AMD define | Да | Да | deamdify | Да | Amd-plugin |
| AMD require | Да | Да | Нет | Да | Нет |
| AMD require loads on demand | Да | С ручной настройкой | Нет | Да | Нет |
| ES2015 import/export | Да (вер. 2) | Нет | Нет | Да | Да |
| Генерация одной сборки | Да | Да | Да | Да | Да |
| Загрузка каждого файла отдельно | Нет | Да | Нет | Да | Нет |
| Множественные сборки | Да | С ручной настройкой | С ручной настройкой | Да | Нет |
| Дополнительные фрагменты загружаются по требованию | Да | Да | Нет | System.import | Нет |
| Создание нескольких страниц с помощью общей сборки | С ручной настройкой | Да | С ручной настройкой | С помощью арифметики сборок | Нет |
Ниже изложены некоторые дополнительные наблюдения:
### webpack vs Gulp
Сравнивать webpack и Gulp — все равно что сравнивать яблоки и апельсины. [Gulp](https://gulpjs.com/) не является сборщиком модулей, как webpack; это программа для выполнения задач. Они могут использоваться вместе, но вам не нужен Gulp, если вы знаете, как использовать webpack. За исключением модульных тестов и линтинга, **webpack может справиться практически с любой задачей, которую может выполнить Gulp**, поэтому многие разработчики предпочитают вообще отказаться от использования менеджера задач.
Конечно, иногда сроки поджимают, и у вас нет времени на изучение всех тонкостей инструментов, с которыми вам приходится работать. Если вы новичок в webpack, но знакомы с Gulp, не стесняйтесь использовать оба этих инструмента, пока вы учитесь максимально использовать потенциал webpack. Поскольку webpack требует времени на настройку, использование менеджера задач, такого как Gulp, может помочь вам в трудную минуту; это только сделает обременит ваш проект.
### webpack vs Browserify
Проводились различные тесты, сравнивая [webpack с Browserify](https://perkframework.com/v1/blog/webpack-vs-browserify-the-ultimate-showdown.html), и разработчики обнаружили, что webpack, безусловно, быстрее. На самом деле, webpack может пересобрать уже существующие пакеты примерно **на 40 процентов быстрее, чем Browserify**. Это особенно полезно, так как вам не нужно многократно обновлять страницу, чтобы увидеть изменения по мере их внесения.
С другой стороны, когда речь заходит о создании оптимизированной конечной сборки, преимущество остается за Browserify. После минификации сборка Browserify может быть примерно **на 40 процентов меньше, чем аналогичная сборка webpack**. Поэтому некоторые разработчики используют webpack по умолчанию для сред разработки, а Browserify оставляют по умолчанию для продакшен-сборок.
Что в webpack 2?
----------------
Webpack 2 может похвастаться некоторыми значительными улучшениями, которые [разработчики описали очень подробно](https://medium.com/webpack/webpack-2-and-beyond-40520af9067f#.wku086c5p).
Прежде всего, **babel больше не нужен для транспиляции операторов импорта и экспорта**. Теперь вы можете анализировать эти инструкции, что позволит вам воспользоваться преимуществами новой функции встряхивания дерева. Эта функция выявляет неиспользуемый код и избавляется от него, что приводит к созданию более компактных сборок.
Итог
----
Если вы планируете работать с большими командами разработчиков над созданием веб-приложений для тысяч пользователей, то вам стоит освоить webpack. Даже если вы в основном работаете в одиночку над личными проектами, вы можете извлечь большую пользу, используя этот мощный сборщик модулей. webpack очень сильно вырос с момента появления и растет быстрее по сравнению с альтернативами, как видно из приведенной ниже диаграммы трендов.
Если у вас нет опыта работы с webpack, но вы понимаете важность сборщиков модулей, попробуйте настроить базовую конфигурацию webpack, как описано в этом руководстве.
**P.S.**
На сайте издательства продолжается [распродажа в честь Старого Нового года](https://habr.com/ru/company/piter/blog/710284/). | https://habr.com/ru/post/710844/ | null | ru | null |
# Запуск ОС Андроид с SD-карты для устройств на процессоре Amlogic S912
В статье детально, с приведением исходного кода, описывается работа, проведенная по переносу и запуску с SD-карты программной прошивки с ОС Андроид для устройств на процессоре Amlogic S912.
Мне нравятся миниатюрные компьютеры, выполненные по технологии система на чипе (SOC). За крошечные размеры и небольшое энергопотребление по сравнению с персональными компьютерами. Используя такие устройства, можно решать широкий круг задач. На миникомпьютеры можно установить как ОС Android (так делает большинство производителей данных "игрушек"), так и различные дистрибутивы Linux или Chrome OS.
Моя текущая работа — это разработка приложений для Андроид. В этой работе очень желательны тесты на реальных устройствах на различных версиях системы. Есть у меня пара миникомпьютеров от компаний Rockchip и Amlogic, на которых я также выполняю свои тесты. Андроид, как операционная система, довольно динамично развивается и сейчас на рынке используются ее модификации от 4.4 до 10 версии. А на подходе уже Андроид 11-й версии.
Многие компании, занимающиеся разработкой телеприставок на базе Андроид, вынуждены иметь недолгий срок сопровождения свои детищ в виду быстрого развития как аппаратных, так и программных средств. Один из моих основных рабочих инструментов для тестов — это приставка KM8P на процессоре S912 с двумя гигабайтами ОЗУ и предустановленной операционной системой Андроид версии 7.1. Время идет, и за пару-тройку лет на рынке последовательно появились версии 8.1, 9.0 и 10.0 ОС Андроид.
Очень хотелось бы потестировать свое приложение под этими самыми версиями. Но что делать? Или нужно покупать зверушки на новых процессорах и версиях Андроид, или заниматься самостоятельной адаптацией новых версий Андроида на имеющихся устройствах. Первый путь легок и прост: заплатив не очень большую сумму, проблема легко решается. Но легких путей мы не ищем, поэтому выбираем второй путь. Второй путь гораздо труднее, но интереснее. К тому же, и сам чип S912 является отличным 8-ядерным процессором, не намного уступающим по производительности новейшим процессорам Amlogic на чипе S905x.
Итак, был выбран второй вариант, как более интересный и отвечающий моим потребностям. Встал вопрос: а каким путем пойти? Текущая версия Андроид 7.1 под капотом имеет ядро Linux 3.14.29 и ПЗУ NAND на чипе SK Hynix H27UCG8T2ETR, для которого Amlogic разработала собственный драйвер aml\_nftl\_dev.ko.
Все новейшие версии Андроид базируются на ядре 4.9. И желательно использовать именно его. Однако, политика Amlogic такова, что последние несколько лет SDK Android компания предоставляет только юридическим компаниям, занимающимся производством устройств на базе чипов Amlogic.
Тем не менее, на просторах github'а можно найти исходники ядра 4.9 на основе SDK Android от Amlogic 2017-18 года. Например, [**git-репозитарий**](https://github.com/khadas/linux/tree/khadas-vims-pie) компании Khadas. Однако, дело, в том, что драйвер aml\_nftl\_dev для версии ядра 4.9 отсутствует. Что делать? Адаптировать данный драйвер для ядра 4.9? Но помимо адаптации драйвера, придется также править так называемое дерево устройств ядра. Это трудный путь.
Множество устройств на процессоре S912 имеет более современное ПЗУ с контроллером EMMC. К счастью, для обладателей таких устройств совсем недавно (в июне-июле 2020 года) появились прошивки на Андроид 9, собранные энтузиастами (ознакомиться можно [**здесь**](https://4pda.ru/forum/index.php?showtopic=998873&st=0#entry97732150) и [**здесь**](https://daivietpda.com/2020/07/rom-atv9-android-9-0-cho-amlogic-s912/)). Я не мог воспользоваться данными прошивками в виду отсутствия на моем устройстве чипа EMMC. Однако, прекрасно понимал, что имея на приставке слот для SD-карточки, для работы с которым используется все тот же драйвер MMC, что и для работы с микросхемой EMMC, можно попытаться использовать SD-карту вместо ПЗУ.
К сожалению, ситуация осложнялась тем, что Amlogic изначально не предусмотрел старт системы с SD-карты. Тем не менее, кое-что было. Amlogic реализовала возможность обновления прошивок с SD-карты. Эта и другие возможности были достигнуты компанией Amlogic путем существенной доработки загрузчика u-boot под свои нужды. В частности, имеется возможность запустить ядро системы с FAT-раздела SD-карты. Итак, было принято решение выяснить, можно ли адаптировать драйвер MMC для возможности старта с SD-карты. Я погрузился в изучение исходного кода драйвера.
Изучая исходный код, я выяснил, во-первых, что драйвер для монтирования загрузочного раздела ограничивается работой только с микросхемой EMMC, а остальные устройства игнорирует. А такими устройствами как раз является SDMMC-слот и SDIO-порт. А почему бы не изменить код так, чтобы драйвер не пропускал устройство SDMMC, а продолжал бы с ним работать, как с EMMC?
Во-вторых, было определено, что разработчики Amlogic используют собственную структуру данных для хранения таблицы разделов диска и записывают ее по некоторому смещению на диске. Структура данных несложная, в ней хранится смещение, имя, размер и некоторые другие характеристики раздела. После определения типа устройства, драйвер читает таблицу разделов на диске и создает блочные устройства в системе согласно этой таблице.
Получается, что разрешив драйверу работать с SDMMC, как с EMMC и записав таблицу разделов по заранее известному адресу на SD-карте, я смогу, таким образом, сымитировать EMMC и загрузить систему с SD-карты! Подумал, почему бы не сделать утилиту, которая будет записывать таблицу разделов в нужном формате и при необходимости проверять ее корректность. Сказано — сделано. Тем более, что сделать ее было несложно, благо практически вся инфраструктура уже была описана в исходном коде драйвера. Исходный код утилиты размещен на github'е, [**репозиторий amlpt**](https://github.com/pro777s/amlpt). Утилита создана в ОС Ubuntu. Но, думаю, при необходимости, ее не сложно будет перенести и на Windows.
Для начала нужно заполнить параметры таблицы разделов в файле mmcparts\_a9.c, указав там имена, смещения, размеры и тип разделов. Для обычных разделов указывается тип — 0x1, для разделов типа cache — 0x2, а для разделов типа data — 0x4. За начальное смещение первого раздела я взял значение 0x2800000 (40Мб). Далее заполнил имена, размеры и типы разделов в структурах partitions согласно таблице разделов из дерева устройств. Для 9-го Андроида таких разделов насчиталось 17.
Заполнив данные в файле mmcparts\_a9.c, создаем утилиту для записи таблицы разделов, запустив скрипт make\_amlptwrt.sh. Данный скрипт создает исполняемый файл amlptwrt, с помощью которого можно сформировать двоичный файл mmc\_parts.bin. Это и есть наша таблица разделов, которую читает драйвер MMC. Аналогично запускаем скрипт make\_amlptrdr.sh для создания утилиты чтения таблицы разделов amlptrdr, с помощью которой мы можем проверить правильность заполнения данной таблицы. После запуска amlptrdr в консоли отобразится таблица разделов с именами, смещениями и размерами в мегабайтах. Примерно так:
**Таблица разделов**
> @>:~/AML/amlpt$ ./amlptrdr
>
> [mmc\_verify\_partition\_tbl] mmc read partition OK!
>
> show\_mmc\_partitions
>
> [disk p01] logo offset 40 Mb, size 8 Mb
>
> [disk p02] recovery offset 48 Mb, size 24 Mb
>
> [disk p03] misc offset 72 Mb, size 8 Mb
>
> [disk p04] dtbo offset 80 Mb, size 8 Mb
>
> [disk p05] cri\_data offset 88 Mb, size 8 Mb
>
> [disk p06] rsv offset 96 Mb, size 16 Mb
>
> [disk p07] metadata offset 112 Mb, size 16 Mb
>
> [disk p08] vbmeta offset 128 Mb, size 2 Mb
>
> [disk p09] param offset 130 Mb, size 16 Mb
>
> [disk p10] boot offset 146 Mb, size 16 Mb
>
> [disk p11] tee offset 162 Mb, size 32 Mb
>
> [disk p12] vendor offset 194 Mb, size 130 Mb
>
> [disk p13] odm offset 324 Mb, size 128 Mb
>
> [disk p14] system offset 452 Mb, size 1350 Mb
>
> [disk p15] product offset 1802 Mb, size 128 Mb
>
> [disk p16] cache offset 1930 Mb, size 1120 Mb
>
> [disk p17] data offset 3050 Mb, size 4050 Mb
Для того, чтобы драйвер MMC заработал с устройством SDMMC, я внес два небольших исправления в исходный код драйвера, в файл [**drivers/amlogic/mmc/emmc\_partitions.c**](https://github.com/khadas/linux/blob/khadas-vims-pie/drivers/amlogic/mmc/emmc_partitions.c):
а) Во-первых, разрешаем драйверу работать с устройствами, отличными от EMMC. Для этого меняем функцию [**is\_card\_emmc**](https://github.com/khadas/linux/blob/b0e0d3314f5e06edcc00dff8cdceec5cd223f2d7/drivers/amlogic/mmc/emmc_partitions.c#L971) следующим образом:
```
static int is_card_emmc(struct mmc_card *card)
{
//struct mmc_host *mmc = card->host;
// emmc port, so it must be an eMMC or TSD
//if (!strcmp(mmc_hostname(mmc), "emmc"))
return 1;
//else
// return 0;
//return mmc->is_emmc_port;
}
```
Конечно, это самое никчемное изменение, которое можно было придумать, но для достижения моей цели этого достаточно. Как говорится, матушка-лень впереди планеты всей.
б) Определяем смещение, по которому будет читаться таблица разделов. Правку делаем в функции [**mmc\_read\_partition\_tbl**](https://github.com/khadas/linux/blob/b0e0d3314f5e06edcc00dff8cdceec5cd223f2d7/drivers/amlogic/mmc/emmc_partitions.c#L719):
```
//start_blk = get_reserve_partition_off(card);
start_blk = MMC_BOOT_PARTITION_SIZE + MMC_BOOT_PARTITION_RESERVED;
```
Если посмотрим на исходный код драйвера, то сумма констант MMC\_BOOT\_PARTITION\_SIZE + MMC\_BOOT\_PARTITION\_RESERVED равна 36 Мб. Следует отметить, что данные правки подходят для моего варианта, когда в устройстве отсутствует чип EMMC или в дереве устройств он отключен. Для других случаев придется придумывать более корректный вариант правок.
Итак, смещение, по которому будет записана таблица разделов на SD-карте равна 36 Мб. Для того, чтобы разместить нашу таблицу разделов, созданную утилитой amlptwrt, на SD-карте достаточно выполнить команду:
```
// 36M = 37748736 bytes = 73728 sectors
sudo dd if=mmc_parts.bin of=/dev/sdb seek=73728 bs=512
```
При этом предполагается, что /dev/sdb — это SD-карта.
Далее компилируем ядро, создаем boot.img с нулевым initrd и примерно такими параметрами ядра:
```
root=/dev/mmcblk0p14 rootfstype=ext4 rootwait
```
Вспомним, что u-boot от Amlogic умеет стартовать ядро Linux c SD-карты с раздела FAT. Создаем на SD-карте в самом начале раздел FAT размером 32 Мб. Этого вполне достаточно для размещения нашего boot.img и dtb.img. В дереве устройств dtb.img необходимо отключить EMMC, чтобы нашей SD-карте было присвоено имя /dev/mmcblk0. Или не отключать, но тогда нужно будет изменить в boot.img параметры ядра, чтобы ядро смогло успешно подключить системный раздел, который в данном случае будет иметь имя /dev/mmcblk0p14.
И, как заключительная часть марлезонского балета, осталось записать разделы Андроид-прошивки на SD-карту. Для этого распаковываем прошивку и записываем на SD-карту подходящие разделы согласно смещениям в таблице разделов:
**Запись разделов на SD-карту**
```
// logo
sudo dd if=logo.PARTITION of=/dev/sdb bs=1M seek=40 conv=sync,fsync status=progress
// recovery
sudo dd if=recovery.PARTITION of=/dev/sdb bs=1M seek=48 conv=sync,fsync status=progress
// misc
sudo dd if=/dev/zero of=/dev/sdb bs=1M seek=72 count=8 conv=sync,fsync status=progress
// dtbo
sudo dd if=dtbo.PARTITION of=/dev/sdb bs=1M seek=80 conv=sync,fsync status=progress
// cri_data
sudo dd if=/dev/zero of=/dev/sdb bs=1M seek=88 count=8 conv=sync,fsync status=progress
// rsv
sudo dd if=/dev/zero of=/dev/sdb bs=1M seek=96 count=16 conv=sync,fsync status=progress
// metadata
sudo dd if=/dev/zero of=/dev/sdb bs=1M seek=112 count=16 conv=sync,fsync status=progress
// vbmeta
sudo dd if=vbmeta.PARTITION of=/dev/sdb bs=1M seek=128 conv=sync,fsync status=progress
// param
sudo dd if=/dev/zero of=/dev/sdb bs=1M seek=130 count=16 conv=sync,fsync status=progress
// boot
sudo dd if=boot.PARTITION of=/dev/sdb bs=1M seek=146 conv=sync,fsync status=progress
// tee
sudo dd if=/dev/zero of=/dev/sdb bs=1M seek=162 count=32 conv=sync,fsync status=progress
// vendor
sudo dd if=vendor.img of=/dev/sdb bs=1M seek=194 conv=sync,fsync status=progress
// odm
sudo dd if=odm.img of=/dev/sdb bs=1M seek=324 conv=sync,fsync status=progress
// system
sudo dd if=system.img of=/dev/sdb bs=1M seek=452 conv=sync,fsync status=progress
// product
sudo dd if=product.img of=/dev/sdb bs=1M seek=1802 conv=sync,fsync status=progress
```
Те разделы, которые отсутствуют в прошивке, я просто заполнял нулями. Некоторые разделы, такие как system или vendor и некоторые другие, могут являться sparse-разделами. Их предварительно необходимо преобразовать в обычные разделы:
```
simg2img system.PARTITION system.img
```
С разделами cache и data нужно поступить немного по-другому. Смотрим нашу таблицу разделов, созданную утилитой amlptwrt, и с помощью программы fdisk создаем соответствующие разделы с нужными смещениями и размерами на SD-карте и форматируем их в файловую систему ext4:
```
sudo mkfs.ext4 /dev/sdb2
sudo mkfs.ext4 /dev/sdb3
```
После форматирования, с помощью той же утилиты fdisk, удаляем уже ненужные разделы /dev/sdb2 и /dev/sdb3.
Чтобы загрузчик u-boot распознал, что нужно загрузиться именно с SD-карты, размещаем в FAT-разделе файл aml\_autoscript. Сам файл aml\_autoscript может быть создан с помощью утилиты mkimage из простого текстового файла следующего содержания:
```
if mmcinfo; then fatload mmc 0 ${loadaddr} boot.img; fatload mmc 0 ${dtb_mem_addr} dtb.img; bootm; fi;
```
Вот и все, что необходимо для переноса прошивки с Андроид на борту на SD-карту.
Несколько прошивок, которые были сделаны по данному методу, опубликованы [**в соответствующей теме**](https://4pda.ru/forum/index.php?showtopic=998873&view=findpost&p=100366180) на форуме 4PDA. Если что-то непонятно, задавайте вопросы в комментариях. Чем смогу — помогу.
За сим позвольте откланяться и удачи всем в переносе прошивок! | https://habr.com/ru/post/525116/ | null | ru | null |
# Особенности загрузки объектов из карты формата KML на карту Яндекса
В API Яндекс.Карт есть [средства для загрузки географических данных](http://tech.yandex.ru/maps/doc/jsapi/2.1/dg/concepts/geoxml-docpage/) в формате XML. API поддерживает карты в двух форматах: YMapsML и KML. В документации по технологиям Яндекса есть [пример](http://tech.yandex.ru/maps/jsbox/2.1/geoxml_display), илюстрирующий работу с этим форматами.
Глядя на этот пример, можно предположить, что с точки зрения API оба формата эквивалентны, и работа с ними ничем не отличается. Тем более Яндекс предоставляет конструктор карт, в котором каждой карте автоматически назначаются ссылки на оба формата. Эти ссылки отличаются только суффиксом. Карта в формате YMapsML оканчивается на символ /, а адрес той же карты в формате KML на конце содержит символы ".kml".
Независимо от формата XML загрузка геообъектов будет выглядеть так:
```
var map = new ymaps.Map("map", {
center: [-25.89, 135.32],
zoom: 4,
controls: ["zoomControl"]
});
var url = "http://maps.yandex.ru/export/usermaps/4c4r9MAwI8DLmJKv1H--R0_bvQmHNLDz/";
ymaps.geoXml.load(url).then(function (res) {
map.geoObjects.add(res.geoObjects);
});
```
Но если нам понадобится что-то сделать с объектами при загрузке, то мы обнаружим, что формат имеет значение. Предположим, что мы хотим поменять цвет контура у объекта с определенным именем.
**Пример загрузки YMapsML**
```
var url = "http://maps.yandex.ru/export/usermaps/4c4r9MAwI8DLmJKv1H--R0_bvQmHNLDz/";
ymaps.geoXml.load(url).then(function (res) {
res.geoObjects.each(function (obj) {
if (obj.properties.get("name") == "Бассов пролив") {
obj.options.set("strokeColor", "0066ffff");
}
});
map.geoObjects.add(res.geoObjects);
});
```
Оказывается, что если мы заменим адрес на формат KML, то данный код работать не будет, потому что коллекция объектов, загруженная из формата KML отличается от той, что получается при загрузке YMapsML. При загрузке KML получается коллекция объектов, состоящая из одного геобъекта, который сам является коллекцией. И вот этот вложенный объект уже содержит геообъекты, нарисованные на карте.
Поэтому для обработки коллекции, загруженной из KML надо написать вот такой код:
**Пример загрузки KML**
```
var url = "http://maps.yandex.ru/export/usermaps/4c4r9MAwI8DLmJKv1H--R0_bvQmHNLDz.kml";
ymaps.geoXml.load(url).then(function (res) {
res.geoObjects.each(function (obj) {
obj.each(function (nested) {
if (nested.properties.get("name") == "Бассов пролив") {
nested.options.set("strokeColor", "0066ffff");
}
});
});
map.geoObjects.add(res.geoObjects);
});
```
А чтобы наш код не зависел от формата, надо его еще немного усложнить:
**Загрузка из любого формата**
```
var modifyObj = function (obj) {
if (obj.properties.get("name") == "Бассов пролив") {
obj.options.set("strokeColor", "0066ffff");
}
}
ymaps.geoXml.load(url).then(function (res) {
res.geoObjects.each(function (obj) {
if ("each" in obj && typeof obj.each == "function") {
obj.each(function (nested) { modifyObj(nested); });
} else {
modifyObj(obj);
}
});
map.geoObjects.add(res.geoObjects);
});
``` | https://habr.com/ru/post/242697/ | null | ru | null |
# Как компьютерное зрение помогает определить координаты спутниковых снимков
*Привет, Хабр!
Меня зовут Андрей, и я data scientist. В этой статье расскажу о том, как я занял второе место в конкурсе «Цифровой прорыв» с решением по автоматизации привязки фотографии к географическому положению. Главный инсайт — базовые решения не всегда хороши и проверены. Спойлер — самодеятельность и использование современных подходов помогают победить :) Расскажу на своем опыте, как не сделать свое решение хуже базового, и проанализирую подходы других участников.*
Информация о задаче, проблема
-----------------------------
Я выбрал задачу от института МФТИ, посвященную аэрофотоснимкам. В геодезии ряд задач можно решить с помощью спутниковых снимков. Однако в экстренных ситуациях, связанных с поиском очагов пожара или пропавших людей, сопоставление спутникового снимка с масштабами реальной местности занимает слишком много времени и не дает достоверной информации в режиме онлайн. Для точной обработки информации и обеспечения безопасности внедряется искусственный интеллект. Я занял второе место, предложив одно из лучших решений по автоматизации привязки фотографии к географическому положению. Эта разработка призвана помочь и ускорить геодезические работы, например, при выявлении чрезвычайных ситуаций или вырубки лесов.
Для лучшего понимания задачи стоит ознакомиться с основными терминами.
* **Подложка** — крайне большое изображение по высоте и ширине с географической привязкой к местности, т.е. координаты каждого пикселя известны или их можно вычислить. Как правило, на изображении размещена большая площадь земли (квадратные километры и более).
* **Аэрофотоснимок** — изображение со спутника или беспилотного летательного аппарата, направление камеры при фотографировании смотрело вертикально вниз. Имеет существенно меньшее разрешение в сравнении с подложкой. По сути фотография, сделанная на обычный фотоаппарат. Главная особенность в том, что аэрофотоснимок сделан в отличное от подложки время, время года, или даже в совершенно другой год или на разной высоте.
* **Перекрытие** — положение изображений, при котором одна и та же площадь местности видна на двух и более аэрофотоснимках. Взаимное ориентирование разновременных снимков разного разрешения подразумевает под собой сопоставление снимков и получение их географической привязки за счет ручного сопоставления оператором с картой.
**Цель решения** — найти местоположение и ориентацию снимка на подложке.
Исходные данные и метрика качества
----------------------------------
В качестве данных выступают 800 аэрофотоснимков фиксированного размера 1024х1024, аннотации к ним, в которых указаны координаты снимка относительно подложки, и угол поворота и изображение самой подложки с расширением 10496x10496. Примечательно, что снимки сделаны в разные временные промежутки и при различных погодных условиях. Например, часть поверхности может быть скрыта облаками или могут присутствовать объекты, которых нет на подложке.
Пример подложкиПример аэрофотоснимкаРезультат матчингаДля оценки качества решения организаторами была предложена собственная метрика, которая определяет разницу между предсказанным центром, углом поворота фотографии и их оригинальными значениями.
относительная разница между предсказанной и истинной координатой центра по оси Ox. относительная разница между предсказанной и истинной координатой центра по оси Oy.среднее относительное отклонение положения предсказанного центра от истинного.относительное отклонение предсказанного угла поворота от истинного значения.### Базовое решение
Организаторами было представлено базовое решение, которое основывалось на обучении нейронной сети, принимающей на вход аэрофотоснимок и на выходе возвращающей координаты этого снимка на подложке и угол поворота.
Однако, чтобы это решение хотя бы запустилось, было необходимо дописать и где-то исправить его код. Переписав решение под себя, я получил метрику около 0.89, уже оказавшись на 4 месте в таблице с результатами.
Однако спустя пару дней один из участников выложил переписанный baseline в открытый доступ и множество людей начало получать хорошие метрики прогоняя и подкручивая код этого решения.
Так я упал на 7 место..
### Улучшение базового решения
Позже я стал добавлять различные небольшие улучшения в процесс обучения и тестового прогона, однако это не дало большого прироста и не вернуло на лидирующие позиции. Некоторые из улучшений, которые я пробовал:
* Аугментация данных с добавлением облаков с помощью библиотеки imgaug. Работает очень долго: около 0.2 сек на одну фотографию размера 1024x1024, при том, что другие аугментации отрабатывают за тысячные доли секунды.
* Test time augmentation (TTA) - агрегация предсказаний модели из исходного и аугментированных изображения тестового датасета ([пример](https://towardsdatascience.com/test-time-augmentation-tta-and-how-to-perform-it-with-keras-4ac19b67fb4d)). Такой подход повышает точность предсказаний, но замедляет общее время работы в несколько раз.
* Обучение нескольких моделей на разных размерах изображения и усреднение их предсказаний.
* Передача предсказаний разных моделей в еще одну модель регрессии (stacking).
### Финальное решение
Позже я решил отойти от кода базового решения и написать все самостоятельно, хоть и по похожему сценарию (по-прежнему обучал нейронную сеть, предсказывающую координаты изображения на подложке и угол поворота). Валидацию я проводил на части тренировочного сета, не применяя к нему аугментаций. Т.к. подложка и фотографии тренировочного и тестового набора были взяты из более поздних периодов, при применении аугментаций со старой подложкой для валидации локальные метрики и метрики на платформе могли бы сильно отличаться. В моем случае локальная метрика была 0.99, а на платформе 0.98.
#### Аугментации
Первым делом я написал аугментацию поворота изображения с использованием информации с подложки (то есть не появлялось черных полос при повороте), это позволило значительно расширить тренировочный набор данных.
Примеры аугментаций:
На локальной валидациионной выборке такой подход уже дал существенный прирост в метриках, однако я по-прежнему был неудовлетворен.
#### Метрика
Во всех предыдущих экспериментах для обучение нейронной сети я использовал либо MAE, либо MSE в качестве функций потерь. Теперь я решил попробовать оптимизировать метрику соревнования напрямую, и данный подход также дал прирост в качестве.
```
class RegressionLoss(torch.nn.Module):
def __init__(self) -> None:
super().__init__()
def forward(self, y_pred, y_true):
# input shape (batch_size, 5)
batch_size = y_pred.shape[0]
x_center_true = (y_true[..., 0] + y_true[..., 2]) / 2
y_center_true = (y_true[..., 1] + y_true[..., 3]) / 2
x_center_pred = (y_pred[..., 0] + y_pred[..., 2]) / 2
y_center_pred = (y_pred[..., 1] + y_pred[..., 3]) / 2
x_metr = torch.abs(x_center_true - x_center_pred)
y_metr = torch.abs(y_center_true - y_center_pred)
angle_metr = torch.abs(y_true[..., 4] - y_pred[..., 4])
metric = 1 - (
0.7 * 0.5 * (x_metr + y_metr)
+ 0.3 * torch.min(angle_metr, torch.abs(angle_metr - 360))
)
return -(metric.sum() / (batch_size + 1))
```
#### Модель
После работы над данными и метриками было решено перебрать разные модели, предобученные на датасете ImageNet. Смотрел как CNN, так и различные вариации Vision transformer, в итоге лучше всего себя показали модели семейства RegNet. Основная идея заключается в том, что мы можем выбирать множество моделей из пространства проектирования, создавая распределение моделей и используя инструменты классической статистики для анализа пространства проектирования. Данный подход отличается от нейросетевого поиска архитектуры (NAS), где целью является нахождение единственной лучшей модели из всего пространства. Подробнее про данный подход можно прочитать в официальной [статье](https://arxiv.org/pdf/2003.13678.pdf) авторов. Веса и реализацию моделей на PyTorch можно посмотреть по [ссылке](https://pytorch.org/vision/stable/models/regnet.html).
#### Дополнительные техники
Также в процесс обучения и тестирования были добавлены техники, представленные в статье [torchvision](https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/). Каждая из них позволяет немного повысить качество предсказаний модели. Техника, дающая самый большой прирост в качестве заключается в том, что на этапе обучения модели используется разрешение входных фотографий 224x224, а на этапе тестирования сначала делают resize изображения до 256x256 и затем вырезают центр изображения того же размера, что и при обучении (224x224). Подробнее о том, как изменение размера входных изображений во время инференса влияет на качество описано в [статье](https://arxiv.org/pdf/1906.06423.pdf).
#### Ансамбль
Выложив свое новое решение, я оказался на 2 месте с тестовым качеством около 0.985. Было радостно, однако результаты 3 и 4 места были сильно близки к моим. Хотелось немного оторваться, чтобы уменьшить шанс проиграть им на закрытой части тестовой выборки, которая открывается уже после окончания соревнования. Соревнование уже подходило к концу и не было времени внедрять новые подходы, поэтому я просто объединил свое улучшения базового решения с новыми. Добавление стекинга моделей и TTA дало прирост метрики на 0.25, сильно замедлив скорость работы алгоритма. Однако в соревновании не было условий про скорость работы, поэтому я оставил такой подход =)
Полученные результаты
---------------------
В итоге за 7 дней было разработано решение на основе нейронной сети с метрикой выше 0.98 на private set и 2 местом в таблице результатов.
Подходы других участников
-------------------------
Уже после соревнования я узнал, что лучше всего (почти 1.0 на private set) с данной задачей справляются алгоритмы, основанные на классическом подходе с использованием [SIFT](https://docs.opencv.org/4.x/dc/dc3/tutorial_py_matcher.html), который заключается в поиске ключевых точек и сопоставлении их векторных описаний. Однако в своем базовом варианте такой алгоритм плохо работает при сильных поворотах изображений, а в нашей задаче поворот мог достигать 360 градусов.
Автор [решения](https://github.com/ifserge/aerial-image-matching), занявшего 1 место, использовал афинно-инвариантный [A-SIFT](https://www.ipol.im/pub/art/2011/my-asift/), что позволило решить данную проблему. Также в данном решении представлено улучшение, позволяющее эффективно находить ключевые точки даже при условиях высокой облачности, которая периодически встречается в тестовом датасете.
Также мне показалось интересным и нестандартным [решение](https://lodmedia.hb.bizmrg.com/presentations/768037/768820/General_presentation.pdf), занявшее 4 место. Оно базируется на свойстве сверточных блоков реагировать на определенные паттерны входного изображения (если паттерн входного изображения совпадает с ядром, то свертка дает максимальный результат).
Используя это свойство, вместо того, чтобы обучать нейронную сеть на большом количестве данных, можно взять простейшую сверточную сеть из одного слоя, не обучать ее, а в качестве ядер весов использовать предварительно обработанные снимки из датасета.
Таким образом, сверточный слой будет содержать кол-во ядер равное количеству снимков, которые мы хотим проверить, на вход слою будет подаваться подложка, а на выходе будет массив активаций.
Так как в данном подходе мы не можем получить информацию об ориентации снимка, придется перебирать все возможные ориентации подложки.
Такое решение будет работать сильно дольше остальных, однако в нем интересно, то, что вообще отсутствует стадия обучения.
Подходы остальных участников соревнования можно посмотреть на [странице с результатами](https://hacks-ai.ru/championships/758453).
Итог
----
Перед тем как брать baseline от авторов задачи и/или бежать скорее обучать нейронки, разберитесь в предметной области и в том, какие подходы сейчас являются для нее популярными и двигайтесь от этого, но не бойтесь применять нестандартные подходы к решению.
По ссылкам можно ознакомиться с кодом и презентацией моего решения:
* <https://github.com/traptrip/ai-areal-photo>
* [Привязка аэроснимков к местности. Андрей Попов](https://lodmedia.hb.bizmrg.com/presentations/746594/768820/hacksAI2022.pdf) | https://habr.com/ru/post/696422/ | null | ru | null |
# leOS — многозадачное ядро для Arduino
Итальянский разработчик [Леонардо Милиани](http://www.leonardomiliani.com/?author=1) выложил в открытый доступ исходники leOS (little embedded operating system) – маленького многозадачного ядра для Arduino. В своем блоге он пишет:
> To be honest, it should more correct to say that leOS is actually something that is halfway a simple prototype of an real-time operating system (RTOS) and a scheduler. [...]
>
> leOS can run simple tasks that don’t require excessive CPU time but it can be useful in all of those situations where the user wants to let a task run itself out of the main loop.
>
>
Ядро leOS обеспечивает диспетчеризацию вызовов пользовательских функций согласно заданным временным интервалам. Для этого leOS использует аппаратный Timer2 для отсчета интервалов между вызовами пользовательских функций, поэтому теряется доступ к функциям ШИМ на пинах D3 и D11. В ядре используется 64-битный счетчик, так что переполнение планировщика произойдет только через 584 942 417 лет.
Для использования leOS необходимо подключить библиотеку и создать экземпляр класса:
```
#include "leOS.h"
leOS myOS;
```
Подключение пользовательской функции к планировщику выполняется с помощью метода *addTask()*:
```
void setup() {
myOS.begin();
myOS.addTask(myFunction, interval);
....
}
```
Больше информации и исходные коды leOS можно найти [здесь](http://www.leonardomiliani.com/?p=516&lang=en). | https://habr.com/ru/post/150443/ | null | ru | null |
# Статья-рецепт про удобную разработку на GWT в IDEA с помощью DCEVM
В IDEA 13-ой версии, в отличие от Eclipse, при запуске проекта GWT с помощью стандартного плагина (и, как в последствие выяснилось, и без него, а просто запуск GWT DevMode — приложение для запуска в режиме разработки и debug'а, а конкретно com.google.gwt.dev.DevMode из gwt-dev.jar — как Java Application) при изменении UI кода нужно обновлять браузер, что бы изменения сработали. В случае GWT это очень критично — так как при обновлении страницы происходит повторное подключение к Code Server (сервер с исходным кодом проекта, нужен, что бы можно производить debug Java кода), а это занимает от 10 секунд до нескольких минут. Здесь я расскажу о способе, как менять код практически без перезагрузки страницы.
Пример кода, на котором происходит ошибка:
```
IButton b = new IButton("Кнопка", new ClickHandler() {
@Override
public void onClick(ClickEvent event) {
changedMethod();
}
});
void changedMethod() {
// Этот код можно изменить в run time.
Window.alert("Изменяемый текст");
}
```
Здесь в ClickHandler вызывается метод changedMethod(). При изменении тела этого метода, изменения в браузере не применяются без перезагрузки страницы. Т.е., например, если запустить приложение в котором будет эта кнопка, то при изменении текста «Изменяемый текст» на «Изменяемый текст 2» и нажатии на кнопку всё равно появится сообщение «Изменяемый текст». При обновлении страницы в браузере, изменения применятся.
Причина в том, что при обновлении классов hot swap (технология «горячей» замены кода, без перезапуска приложения) не срабатывает и не загружает изменённые классы, какие-бы мелкие изменения там не происходили.
Но есть расширенна «реализация» hot swap, которая позволяет ему работать — Dynamic Code Evolution VM (далее DCEVM), модификация JRE HotSpot для возможности загружать изменённые классы. От простого hot swap, который предоставляет JRE (и который в IDEA почему-то не работает) отличается большими возможностями — можно вносить изменения не только в тело метода, но и в его сигнатуру, а так же удалять/добавлять методы в классе и менять иерархию классов. Удалять и добавлять классы нельзя. [ssw.jku.at/Research/Papers/Wuerthinger10a/Wuerthinger10a.pdf](http://ssw.jku.at/Research/Papers/Wuerthinger10a/Wuerthinger10a.pdf)
Вообще есть plugin DCEVM для IDEA — но он включает в себя только JRE, а она нам не подойдёт по двум причинам:
1) Для запуска GWT plugin'а в IDEA нельзя указать JRE, под которой будет запускаться — будет запускаться под JDK проекта.
2) Если всё же запустить DevMode, как Java Application и явно указать ему JRE DCEVM (как раз эта JRE появится после установки plugin'а), то DevMode не запуститься, так как не сможет запустить Swing. Судя по всему эта JRE не работает со Swing'ом.
Оригинальная версия находится:
[ssw.jku.at/dcevm](http://ssw.jku.at/dcevm/)
Но она уже как 3 года не поддерживается и не работает на Java 7 и 8, поэтому есть fork в котором это исправлено:
[github.com/dcevm/dcevm](https://github.com/dcevm/dcevm)
Качать от сюда: [dcevm.github.io](https://dcevm.github.io/)
Я брал full версию Java 7 update 51, build 3.
Ставить нужно на JDK, под которой происходит разработка — она указана в настройках проекта. Ставить именно в JDK, т.к. из него потом запускается GWT plugin, ну и в дальнейшем будет работать для всех проектов. Установка по нажатию на кнопку «Replaced by DCEVM».
Ставил на Oracle HotSpot JDK 1.7.0\_67 x32 запущенный на win 7 x64.
А дальше GWT приложение запускаем как обычно под debug'ом. После изменения класса выполняем Run->Reload Changed Classes и, если ошибок при компиляции нет, новые классы загрузятся (это будет указано в окне Event Log — что то вроде "<название конфигурации запуска>: 1 classes reloaded").
Вообще, DCEVM подходит не только для GWT, а для всех случаев, когда hot swap не работает. Так что можно попробовать его на других проектах.
##### GWT 2.7 и отказ от plugin для браузера.
Возможно, в GWT планируют отказаться от поддержки DevMode и plugin'ов для браузеров — уже сейчас GWT plugin для FireFox работает только максимум на 26 версии, а plugin для Chrome страшно тормозит. Поэтому я разрабатываю на FF 26.
На замену ему уже существует SuperDevMode ( [www.gwtproject.org/articles/superdevmode.html](http://www.gwtproject.org/articles/superdevmode.html) ). Вкратце, вместо исполнения клиентского Java кода, в режиме разработки, он позволяет компилировать Java код в JS и подгружать его в браузер. Т.е. фактически исполнятся будет JS, как и в production. Соотношение между JS и Java кодом работает с помощью Source Maps (технология в браузере, с помощью которой можно произвести соответствие строк кода между JS и кода, который в этот JS скомпилирован — для GWT это Java код) [developer.chrome.com/devtools/docs/javascript-debugging#source-maps](https://developer.chrome.com/devtools/docs/javascript-debugging#source-maps).
Но то, как позиционируется и реализована разработка в режиме SuperDevMode пока не подходит для реального применения. Есть несколько очень серьёзных минусов:
1) Сейчас компилирование изменённого модуля происходит полностью, в не зависимости от того, изменили ли 1 класс или несколько. Для маленьких модулей это не проблема, но в случае больших модулей компиляция достигает 5-10 минут. И это, само собой, при отключение permutation и всего прочего.
2) Debug этого кода непривычен — вместо обычного debug'а в IDE, предлагают использовать debug JS в самом браузере. Пример: [geekbybit.blogspot.ru/2013/03/diy-working-with-gwt-codeserver-tomcat.html](http://geekbybit.blogspot.ru/2013/03/diy-working-with-gwt-codeserver-tomcat.html)
В GWT 2.7 говорится об исправлении первого минуса — обещают ввести инкрементальную компиляцию. [blog.oio.de/2014/03/31/upcoming-gwt-releases-2-7-3-0-2014-beyond](http://blog.oio.de/2014/03/31/upcoming-gwt-releases-2-7-3-0-2014-beyond/)
И новая версия IDEA (начиная с 14-ой версии включено будет по-умолчанию) подготовила для нас приятный сюрприз — работу с SourceMaps [docs.google.com/document/d/1Sf9lahq0jr0AsxR74ZE-Lntf0y5ZNk0104mhD8ozEuM/edit](https://docs.google.com/document/d/1Sf9lahq0jr0AsxR74ZE-Lntf0y5ZNk0104mhD8ozEuM/edit), [youtrack.jetbrains.com/issue/WEB-4429#comment=27-620687](http://youtrack.jetbrains.com/issue/WEB-4429#comment=27-620687)
Способ пока сырой, но это только начало.
Так что в дальнейшем, будет разрабатывать уже на SuperDevMode, благо для удобной разработки с помощью него делается очень много.
P.S. Благодарность Andrey Dernov из JetBrains за помощь в исследовании проблемы. | https://habr.com/ru/post/236075/ | null | ru | null |
# ChaiScript — скриптовый язык для C++
Когда возникает потребность внедрить скриптовый язык в проект на C++, первым делом большинство людей вспоминает Lua. В этой статье его не будет, я расскажу о другом, не менее удобном и легком в освоении языке под названием ChaiScript.
#### Небольшое предисловие
Сам я наткнулся на ChaiScript случайно, когда смотрел [один из докладов](https://youtu.be/uzF4u9KgUWI) Jason'а Turner'a, одного из создателей языка. Меня это заинтересовало, и в тот момент, когда нужно было выбрать скриптовый язык в проект, я решил — почему бы не попробовать ChaiScript? Результат меня приятно удивил (о моем личном опыте будет написано ближе к концу статьи), однако, как бы странно это ни звучало, на хабре не оказалось ни одной статьи, в которой хоть как-то бы упоминался этот язык, и я решил, что было бы неплохо написать о нем. У языка конечно есть [документация](https://github.com/ChaiScript/ChaiScript/blob/develop/cheatsheet.md) и [официальный сайт](http://chaiscript.com/), но из наблюдений далеко не каждый будет ее читать, да и формат статьи многим (включая меня) ближе.
Сначала мы поговорим о синтаксисе языка и всех его фичах, потом о том, как внедрить его в ваш проект C++, а в конце я расскажу немного о своем опыте. Если какая-то часть вас не интересует, или вы хотите прочитать статью в другом порядке, можете воспользоваться оглавлением:
* [Синтаксис ChaiScript](#syntax)
* [Внедрение в C++](#cppchai)
* [Личный опыт](#myexp)
Синтаксис языка
---------------
Язык ChaiScript очень похож на C++ и JS своим синтаксисом. Прежде всего, он, как и подавляющее большинство скриптовых языков, является динамически-типизированным, однако в отличие от JavaScript, имеет строгую типизацию (никаких `1 + "2"`). Также есть встроенный сборщик мусора, язык является полностью интерпретируемым, позволяя исполнять код построчно, без компиляции в байткод. Имеет поддержку исключений (причем совместную, позволяя ловить их как внутри скрипта, так и в C++), лямбда-функции, перегрузку операторов. Не чувствителен к пробелам, позволяя писать как в одну строку через точку-с-запятой, так и в стиле python, разделяя выражения новой строкой.
#### Примитивные типы
ChaiScript по умолчанию хранит целочисленные переменные как int, вещественные как double, а строки с помощью std::string. Сделано это прежде всего для того, чтобы обеспечить совместимость с вызывающим кодом. В языке даже есть суффиксы у чисел, чтобы мы могли явно указать, какого типа является наша переменная:
```
/*
переменные в chaiscript объявляются как в js
тип указывать не нужно, достаточно var / auto
`;` в конце строки по желанию
*/
var myInt = 1 // int
var myLongLong = 1ll // long long int
var myFloating = 3.3 // double
var myBoolean = false // bool
var myString = "hello world!\n" // std::string
```
Менять тип переменных просто так не выйдет, скорее всего вам необходимо будет определить свой оператор `=` для этих типов, иначе вы рискуете либо вызвать исключение (об этом мы поговорим позже), либо стать жертвой округления, так:
```
var integer = 3
integer = 5.433
print(integer) // печатает 5 за счет округления double при присвоении в int!
integer = true // вызывает исключение - не оператора `=` для (int, bool)
```
Тем не менее, вы можете объявить переменную, не присвоив ей значение, в таком случае в ней будет лежать своеобразный undefined до того момента, пока ей не будет присвоено значение.
#### Встроенные контейнеры
В языке предусмотрено два контейнера — Vector и Map. Работают они очень схоже с аналогами в C++ (std::vector и std::map соответственно), однако не требуют указания типа, потому что могут хранить любой. Индексировать Vector можно как обычно с помощью int'ов, а вот Map требует ключом обязательно строку. Видимо вдохновившись python, авторы также добавили возможность быстро объявлять контейнеры в коде с помощью следующего синтаксиса:
```
var v = [ 1, 2, 3u, 4ll, "16", `+` ] // массив с элементами разных типов
var m = [ "key1" : 1, "key2": "Bob" ]; // словарь с произвольными типами-значениями
var M = Map() // создает пустой словарь
var V = Vector() // создает пустой массив
// в массив можно добавлять элементы в стиле C++ вектора:
v.push_back(123)
// есть нужно добавить ссылку, можно воспользоваться отдельной функцией
v.push_back_ref(m); // m - произвольный объект
// в словарь добавлять также легко
m["key"] = 3
// по ссылке можно через ссылочное присваивание (reference assignment):
m["key"] := m // теперь словарь хранит ссылку на объект
```
Оба этих класса почти в полной мере повторяют свои аналоги в C++, за исключением итераторов, ведь вместо них существует специальные классы Range и Const\_Range. К слову, все контейнеры передаются по ссылке даже если вы пользуетесь присваиванием через =, что для меня весьма странно, так как для всех остальных типов происходит копирование по значению.
#### Условные конструкции
Почти все конструкции условий и циклов можно описать буквально в одном примере кода:
```
var a = 5
var b = -1
// классический if-else
if (a > b) {
print("a > b")
} else if (a == b){
print("a == b")
} else {
print("a < b")
}
// switch - раскрывается как набор if-ов
// Можно проверять переменную любого типа
// Без break исполнение также проваливается вниз, как и в C++
var str = "hello"
switch(str)
{
case("hi") { print("hi!"); break; }
case("hello") { print("hello!" break; }
case("bye") { print("bye-bye!") break; }
default { print("what have you said?") }
}
var x = true
// фигурные скобки должны всегда присутствовать, даже если в теле одна строка
while (x) {
print("x was true")
x = false;
}
// цикл в стиле C. По желанию можно объявить одну переменную в начале, после идет булево выражение, в конце любое выражение, исполняющееся каждую итерацию
for (var i = 0; i < 10; ++i) // есть только пре-инкеремент, значение увеличивается сразу
{
print(i); // печатаем 0 ... 9 в 10 строк
}
// ranged-for loop
for(element : [1, 2, 3, 4, 5])
{
puts(element) // печатает подряд 12345
}
// для гурманов: прямиком из C++17 if-init statements:
if(var x = get_value(); x < 10) {
print(x) // x является локальной переменной внутри if
}
```
Думаю, люди, знакомые с C++, нового ничего не нашли. Это не удивительно, ведь ChaiScript позиционируется, как легкий для «сишников» в освоении язык, и поэтому заимствует всем известные классические конструкции. Авторы решили выделить даже два ключевых слова для объявления переменных — `var` и `auto`, на случай, если вам очень уж сильно нравятся плюсы с auto.
#### Контекст выполнения
В ChaiScript есть локальный и глобальный контекст. Код исполняется сверху вниз построчно, однако его можно вынести в функции и вызвать позднее (но не раньше!). Переменные, объявленные внутри функций или условий/циклов по умолчанию не видны извне, но вы можете изменить это поведение, используя идентификатор `global` вместо `var`. Глобальные переменные отличаются от обычных тем, что, во-первых: видны за пределами локального контекста, а, во-вторых: могут быть заново объявлены (если при повторном объявлении не задается значение, то оно остается прежним)
```
// простая функция на языке chaiscript
def foo(x)
{
global G = 2
print(x)
}
foo(0) // вызов foo(x), G = 2
print(G) // печатает 2
global G = 3 // теперь G = 3, повторное объявление global - не ошибка!
```
К слову, если у вас есть переменная, и нужно проверить, присвоено ли ей значение, воспользуйтесь встроенной функцией `is_var_undef`, возвращающей true, если переменная undefined.
#### Интерполяция строк
Базовые объекты или пользовательские, у которых определен метод `to_string()`, могут быть помещены в строку с помощью синтаксиса `${object}`. Это позволяет избежать лишних конкатенаций строк и в целом выглядит намного опрятней:
```
var x = 3
var y = 4
// печатает sum of 3 + 4 = 7
print("sum of ${x} + ${y} = ${x + y}")
```
Vector, Map, MapPair и все примитивы также поддерживают эту функцию. Vector выводится в формате `[o1, o2, ...]`, Map как `[, , ...]`, а MapPair: .
#### Функции и их нюансы
Функции ChaiScript — такие же объекты, как и все остальное. Их можно захватывать, присваивать переменным, делать вложенными в другие функции и передавать как аргумент. Также для них вы можете указать тип входных значений (то чего так не хватало динамически-типизированным языкам!), для этого надо указать тип перед объявлением параметра функции. Если при вызове параметр можно преобразовать в указанный, то произойдет преобразование по правилам C++, иначе генерируется исключение:
```
def adder(int x, int y)
{
return x + y
}
def adder(bool x, bool y)
{
return x || y
}
adder(1, 2) // ок, результат 3
adder(1.22, -3.7) // ок, результат 1 + (-3) = 2
adder(true, true) // ок, результат true
adder(true, 3) // ошибка, нет подходящей функции adder(bool, int)
```
Функциям в языке также можно задавать условия вызова (call guard). Если он не соблюдается, вызывается исключение, иначе выполняется вызов. Также отмечу, что если функция не имеет return-statement'а в конце, то вернется последнее выражение. Очень удобно для небольших подпрограмм:
```
def div(x, y) : y != 0 { x / y } // если `y` не равен нулю - вернуть результат деления `x` на `y`
print(div(2, 0.5)) // печатает 4.0
print(div(2, 0)) // ошибка, `y` равен 0!
```
#### Классы и Dynamic\_Object
ChaiScript имеет зачатки ООП, что является несомненным плюсом в случае, если вам необходимо манипулировать сложными объектами. В языке присутствует особый тип — Dynamic\_Object. По факту все экземпляры классов и пространства имен являются именно Dynamic\_Object с заранее заданными свойствами. Динамический объект позволяет добавлять к нему поля по ходу выполнения скрипта, а после обращаться к ним:
```
var obj = Dynamic_Object();
obj.x = 3;
obj.f = fun(arg) { print(this.x + arg); } // теперь obj имеет метод f (внутри него можно обращаться к `x`
obj.f(-3); // печатает 0
```
Классы определяются достаточно просто. Им можно задать поля, методы, конструкторы. Из интересного — через специальную функцию `set_explicit(object, value)` можно «зафиксировать» поля объекта, запретив добавление новых методов или атрибутов после объявления класса (обычно это делается в конструкторе):
```
class Widget
{
var id; // атрибут id
def Widget() { this.id= 0 } // конструктор без параметров
def Widget(id) { this.id = id } // конструктор с 1 параметров
def get_id() { id } // метод класса
}
var w = Widget(10)
print(w.get_id()) // печатает 10 (w.id)
print(w.get_id) // также печатает 10, скобки могут быть опущены если нет параметров
set_explicit(w, true) // зафиксировать объект класса
w.x = 3 // вызовет ошибку так как у Widget нет поля x
```
Важный момент — по факту методы класса это лишь функции, у которых первый аргумент — объект класса с явно указанным типом. Поэтому следующий код эквивалентен добавлению метода в существующий класс:
```
def set_id(Widget w, id) { w.id = id }
w.set_id(9) // w.id = 9
set_id(w, 9) // тоже самое, w.id = 9
```
Кто знаком с C#, может заменить, что больно похоже это на метод расширения, и будет недалек от истины. Таким образом, в языке вы можете добавить новый функционал даже для встроенных классов, к примеру для строки или int'а. Также авторы предлагают хитрый способ перегрузки операторов: чтобы его сделать, необходимо окружить символ оператора с помощью `, как в примере ниже:
```
// перегрузка оператора + для двух объектов типа Widget
def `+`(Widget w1, Widget w2)
{
print("merging two widgets!")
}
var widget1 = Widget()
var widget2 = Widget()
widget1 + widget2 // без функции выше генерируется исключение
// оператор также можно захватить как функцию и вызвать:
var plus = `+`
print(plus(1, 7)) // печатает 8
```
#### Пространства имен
Говоря о пространстве имен в ChaiScript, стоит иметь в виду, что это по существу классы, которые всегда находятся в глобальном контексте. Вы можете создать их с помощью функции `namespace(name)`, а после добавить необходимые функции и классы. По умолчанию в языке нет никаких библиотек, однако вы можете их установить с помощью расширений, о которых мы поговорим чуть позже. В целом, инициализация пространства имен может выглядеть так:
```
namespace("math") // создаем пространство имен math
// добавим функций
math.square = fun(x) { x * x }
math.hypot_squared= fun(x, y) { math.square(x) + math.square(y) }
print(math.square(4)) // печатает 16
print(math.hypot_squared(3, 4)) // печатает 25
```
#### Лямбда выражения и другие фичи
Лямбда выражения в ChaiScript подобны тем, что мы знаем из C++. Для них используется ключевое слово **fun**, и они также требуют явного указания захватываемых переменных, однако делают это всегда по ссылке. Также в языке есть функция bind, которая позволяет привязать значения к параметрам функции:
```
var func_object = fun(x) { x * x }
func_object(9) // печатает 81
var name = "John"
var greet = fun[name]() { "Hello, " + name }
print(greet()) // печатает Hello, John
name = "Bob"
print(greet()) // печатает Hello, Bob
var message = bind(fun(msg, name) { msg + " from " + name }, _, "ChaiScript");
print(message("Hello")) // печатает Hello from ChaiScript
```
#### Исключения
Во время выполнения скрипта могут возникнуть исключения. Они могут быть как перехвачены в самом ChaiScript (что мы здесь и обсудим), так и в C++. Синтаксис абсолютно идентичен с плюсами, вы можете даже выкидывать число или строку:
```
try {
eval(x + 1) // x не существует
} catch (e) {
print("Error during evaluation"))
}
// можно ловить C++ исключения внутри ChaiScript
// Так как Vector - обертка над std::vector, то он кидает std::exception при обращении за пределы массива
try {
var vec = [1, 2]
var val = vec[3] // обращение за пределы массива
} catch (e) {
print("index out of range: " + e.what()); // e.what преобразуется в строку ChaiScript
}
// к сatch можно добавить guard так же как для функций, проверяется условие после `:`
try {
throw(5.2)
} catch(e) : is_type(e, "int") {
print("Int: ${e}"); // только если `e` это int
} catch(e) : is_type(e, "double") {
print("Double: ${e}"); // если `e` это double
}
```
По-хорошему, вы должны определить свой класс исключений и кидать его. О том, как его перехватывать в C++, мы поговорим во втором разделе. Для исключений интерпретатора ChaiScript генерирует свои исключения, такие как eval\_error, bad\_boxed\_cast и т.п.
#### Константы интерпретатора
К моему удивлению в языке оказалось и некое подобие макросов компилятора — их всего 4 и все они служат для выявления контекста и по большей части используются для обработки ошибок:
| | |
| --- | --- |
| \_\_LINE\_\_ | текущая строка, если код исполняется не из файла, то '1' |
| \_\_FILE\_\_ | текущий файл, если код вызывается не из файла, то "\_\_EVAL\_\_" |
| \_\_CLASS\_\_ | текущий класс или «NOT\_IN\_CLASS» |
| \_\_FUNC\_\_ | текущая функция или «NOT\_IN\_FUNCTION» |
#### Перехват ошибок
Если функция, которую вы вызываете, не была объявлена, вызывается исключение. Если для вас это неприемлемо, вы можете определить специальную функцию — `method_missing(object, func_name, params)`, которая будет вызвана с соответствующими аргументами в случае ошибки:
```
def method_missing(Widget w, string name, Vector v)
{
print("widget method ${name} with params {v} was not found")
}
w = Widget()
w.invoke_error(1, 2, 3) // печатает widget method invoke_error with params [1, 2, 3] was not found
```
#### Built-in функции
В ChaiScript определяется множество встроенных функций, и в статье хотелось бы рассказать об особо полезных. Среди них: `eval(str)`, `eval_file(filename)`, `to_json(object)`, `from_json(str)`:
```
var x = 3
var y = 5
var res = eval("x * y") // res = 15, в eval используется контекст вызывающего кода
// можем запустить скрипт из файла:
// через eval_file
eval_file("source.chai")
// или через use, последний гарантирует, что повторный вызов с тем же файлом игнорируется
use("source.chai")
// to_json превращает объект в Map и возвращает строку
var w = Widget(0)
var j = to_json(w) // j = "{ "id" : 0 }"
// from_json преобразует строку в Map (к сожалению, не в объект)
var m = from_json("
{
"x": 0,
"y": 3,
"z": 2
}")
print(m) // печатает Map как [, , ]
```
Внедрение в C++
---------------
#### Установка
ChaiScript является header-only библиотекой C++, построенной на шаблонах. Соответственно для установки вам всего лишь нужно сделать clone [репозитория](https://github.com/ChaiScript/ChaiScript) или просто поместить все файлы из [этой папки](https://github.com/ChaiScript/ChaiScript/tree/develop/include/chaiscript) в ваш проект. Так как в зависимости от IDE все это делается по-разному и уже давно детально расписано на форумах, далее будем предполагать, что у вас получилось подключить библиотеку, и код с include-ом: `#include` компилируется.
#### Вызов кода C++ и загрузка скрипта
Минимальный пример кода с использованием ChaiScript выглядит как показано ниже. Мы определяем простую функцию в C++, принимающую std::string и возвращающую измененную строку, а затем добавляем ссылку на нее в объект ChaiScript, чтобы в нем вызвать. Компиляция может занять значительное время, но связано это прежде всего с тем, что инстанцирование большого количества шаблонов для компилятора дело не из легких:
```
#include
#include
std::string greet\_name(const std::string& name)
{
return "hello, " + name;
}
int main()
{
chaiscript::ChaiScript chai; // объект chaiscript
chai.add(chaiscript::fun(&greet\_name), "greet"); // добавляем функцию как greet
// мгновенный eval с выводом результата в консоль
chai.eval(R"(
print(greet("John"));
)");
}
```
Надеюсь у вас получилось, и вы увидели результат выполнения функции. Сразу хочу отметить один нюанс — если вы объявите объект ChaiScript как статический, то получите неприятную ошибку времени выполнения. Связано это с тем, что язык по умолчанию поддерживает многопоточность и хранит локальные переменные потока, к которым обращается в своем деструкторе. Однако, уничтожаются они раньше, чем вызывается деструктор статического экземпляра, и в итоге мы имеем ошибку access violation или segmentation fault. Исходя из [issue на github](https://github.com/ChaiScript/ChaiScript/issues/338), самым простым решением будет просто поставить **`#define CHAISCRIPT_NO_THREADS`** в настройках компилятора или перед включением файла библиотеки, тем самым отключив многопоточность. Как я понял, пофиксить эту ошибку так и не удалось.
Теперь разберем детально, как же происходит взаимодействие С++ и ChaiScript. В библиотеке определена специальная шаблонная функция `fun`, которая может принимать указатель на функцию, функтор или указатель на переменную класса, а затем возвращать специальный объект, хранящий состояние. В качестве примера определим в C++ коде класс Widget и попробуем по-разному связать его с ChaiScript:
```
class Widget
{
int Id;
public:
Widget(int id) : Id(id) { }
int GetId() const { return this->Id; }
};
std::string ToString(const Widget& w)
{
return "widget #" + std::to_string(w.GetId());
}
int main()
{
chaiscript::ChaiScript chai;
Widget w(2); // создадим Widget в C++ коде
chai.add(chaiscript::fun([&w] { return w; }), "get_widget"); // захватим его в лямбду и передадим в скрипт
chai.add(chaiscript::fun(ToString), "to_string"); // внешняя функция
chai.add(chaiscript::fun(&Widget::GetId), "get_id"); // метод класса
// для примера вызовем код, который получает Widget и вызывает сначала GetId, а затем неявно to_string, который мы перегрузили
chai.eval(R"(
var w = get_widget()
print(w.get_id) // печатает 2
print(w) // печатает widget #2
)");
}
```
Как видите, ChaiScript абсолютно спокойно работает с неизвестными ему классами C++ и умеет вызывать их методы. Если же вы где-то в коде ошибетесь, скорее всего скрипт выкинет исключение рода `error in function dispatch`, что совсем не критично. Однако не только функции можно импортировать, давайте посмотрим, как добавить переменную в скрипт средствами библиотеки. Для этого выберем задачу чуть потруднее — импортировать std::vector. В этом нам помогут функция `chaiscript::var` и метод `add_global`. Также добавим public-поле `Data` в наш Widget, чтобы посмотреть, как импортировать поле класса:
```
class Widget
{
int Id;
public:
int Data = 0;
Widget(int id) noexcept : Id(id) { }
int GetId() const { return this->Id; }
};
std::string ToString(const Widget& w)
{
return "widget #" + std::to_string(w.GetId()) +
" with data: " + std::to_string(w.Data);
int main()
{
chaiscript::ChaiScript chai;
std::vector W; // зададим массив из Widget
W.emplace\_back(1);
W.emplace\_back(2);
W.emplace\_back(3);
chai.add(chaiscript::fund(ToString), "to\_string");
chai.add(chaiscript::fun(&Widget::Data), "data"); // указатель на поле класса
// добавим глобальный объект в ChaiScript
chai.add\_global(chaiscript::var(std::ref(W)), "widgets"); // избегаем копирования с помощью std::ref
chai.add(chaiscript::fun(&std::vector::size), "size"); // размер массива
// индексация. Пояснение к этим двум строкам дано ниже
using IndexFuncType = Widget& (std::vector::\*)(const size\_t);
chai.add(chaiscript::fun(IndexFuncType(&std::vector::operator[])), "[]");
chai.eval(R"(
for(var i = 0; i < vec.size; ++i)
{
vec[i].data = i \* 2;
print(vec[i])
}
)");
}
```
Код выше выводит на экран: **`widget #1 with data: 0`, `widget #2 with data: 2`, `widget #3 with data: 4`**. Мы добавили в ChaiScript указатель на поле класса, и так как поле оказалось примитивным типом, мы изменить его значение. Также для работы с `std::vector` было добавлено несколько его методов, среди которых — `operator[]`. Те, кто хорошо знакомы с STL, знают, что метода индексации у `std::vector` два — один возвращает константную ссылку, другой — простую ссылку. Именно поэтому для перегруженных функций нужно явно указывать их тип — иначе возникает неоднозначность, и компилятор выдаст ошибку.
Библиотека предоставляет еще несколько методов для добавления объектов, но все они практически идентичны, поэтому рассматривать их подробно не вижу смысла. В качестве небольшой подсказки приведу код ниже:
```
chai.add(chaiscript::var(x), "x"); // x копируется в ChaiScript
chai.add(chaiscript::var(std::ref(x), "x"); // по ссылке, можно изменять из C++ и ChaiScript
auto shared_x = std::make_shared(5);
chai.add(chaiscript::var(shared\_x), "x"); // shared\_ptr существует пока есть указатели в C++ или ChaiScript
chai.add(chaiscript::const\_var(x), "x"); // копируется в ChaiScript и становится константой
chai.add\_global\_const(chaiscript::const\_var(x), "x"); // global const переменная. Исключение, если x уже существует
chai.add\_global(chaiscript::var(x), "x"); // global переменная, Исключение. если x уже существует
chai.set\_global(chaiscript::var(x), "x"); // устанавливает значение global переменной, если та не const
```
#### Использование STL контейнеров
Если вы хотите передать STL-контейнеры, содержащие **примитивные** типы в ChaiScript, вы можете добавить инстанцирование шаблонного контейнера в ваш скрипт, чтобы не импортировать для каждого типа его методы.
```
using MyVector = std::vector>;
MyVector V;
V.emplace\_back(1, "John");
V.emplace\_back(3, "Bob");
// добавим наши типы - vector и pair
chai.add(chaiscript::bootstrap::standard\_library::vector\_type("MyVec"));
chai.add(chaiscript::bootstrap::standard\_library::pair\_type("MyVecData"));
chai.add(chaiscript::var(std::ref(V)), "vec");
chai.eval(R"(
for(var i = 0; i < vec.size; ++i)
{
print(to\_string(vec[i].first) + " " + vec[i].second)
}
)");
```
Под капотом идет вызов нескольких функций ChaiScript, которые сами добавляют необходимые методы. В целом, если ваш класс поддерживает схожие операции с STL-контейнерами, вы также можете добавить его таким способом. В случае c `std::vector` это, к сожалению, невозможно, так как ChaiScript требует наличие конструктора без параметров для элемента `vector_type`, коего у нашего Widget не было.
#### С++ классы внутри ChaiScript
Возможно в рамках вашей задачи необходимо не только изменять объекты в ChaiScript, но и создавать их в скрипте. Что же, это вполне возможно. Возьмем снова для примера класс Widget и унаследуем от него класс WindowWidget, а затем добавим в скрипт возможность создавать их оба, а также конвертировать унаследованный класс в базовый:
```
class Widget
{
int Id;
public:
Widget(int id) : Id(id) { }
int GetId() const { return this->Id; }
};
class WindowWidget : public Widget
{
std::pair Size;
public:
WindowWidget(int id, int width, int height)
: Widget(id), Size(width, height) { }
int GetWidth() const { return this->Size.first; }
int GetHeight() const { return this->Size.second; }
};
int main()
{
chaiscript::ChaiScript chai;
// добавим тип Widget и его конструктор
chai.add(chaiscript::user\_type(), "Widget");
chai.add(chaiscript::constructor(), "Widget");
// добавим тип WindowWidget и его конструктор
chai.add(chaiscript::user\_type(), "WindowWidget");
chai.add(chaiscript::constructor(), "WindowWidget");
// скажем, что Widget - базовый класс для WindowWidget
chai.add(chaiscript::base\_class());
// добавим методы Widget и WindowWidget
chai.add(chaiscript::fun(&Widget::GetId), "get\_id");
chai.add(chaiscript::fun(&WindowWidget::GetWidth), "width");
chai.add(chaiscript::fun(&WindowWidget::GetHeight), "height");
// создадим WindowWidget и вызовем его методы
chai.eval(R"(
var window = WindowWidget(1, 800, 600)
print("${window.width} \* ${window.height}")
print("widget.id is ${window.get\_id}")
)");
}
```
Полиморфизм работает в ChaiScript абсолютно также, как и в C++ для типов, информацию о которых вы предоставили. Если по каким-то причинам возникает неоднозначность при добавлении указателя на унаследованный метод (возможно, класс наследуется сразу от нескольких базовых), приведите его к нужному классу явно, как это сделано в примере выше с оператором индексации `std::vector`.
#### Привязка экземпляра к методу и конвертирование типа
Для синглтон объектов удобно использовать захват ссылки на них вместе с методом или полем. В таком случае в ChaiScript мы получим либо функцию, либо глобальную переменную, к которой можно обратиться без упоминания этого объекта:
```
Widget w(3);
w.Data = 4444;
// привязка Widget w
chai.add(chaiscript::fun(&Widget::GetId, &w), "widget_id");
chai.add(chaiscript::fun(&Widget::Data, &w), "widget_data");
chai.eval(R"(
print(widget_id)
print(widget_data)
)");
```
Также при экспорте более «библиотечных» классов из C++ в ChaiScript (к примеру, vec3, complex, matrix) часто требуется возможность неявного преобразования из одного типа в другой. В ChaiScript эта задача решается путем добавления `type_conversion` в объект скрипта. Для примера рассмотрим класс Complex и реализацию преобразования int и double в него при сложении:
```
class Complex
{
public:
float Re, Im;
Complex(float re, float im = 0.0f) : Re(re), Im(im) { }
};
int main()
{
chaiscript::ChaiScript chai;
// добавим Complex, определив поля re, im, конструктор и оператор `=`
chai.add(chaiscript::user_type(), "Complex");
chai.add(chaiscript::bootstrap::standard\_library::assignable\_type("Complex"));
chai.add(chaiscript::constructor(), "Complex");
chai.add(chaiscript::fun(&Complex::Re), "re");
chai.add(chaiscript::fun(&Complex::Im), "im");
// добавим неявное преобразование из double и int в Complex
chai.add(chaiscript::type\_conversion());
chai.add(chaiscript::type\_conversion());
// в скрипте определим оператор `+` для произвольного типа
chai.eval(R"(
def `+`(Complex c, x)
{
var res = Complex(0, 0)
res.re = c.re + x.re
res.im = c.im + x.im
return res
}
var c = Complex(1, 2)
c = c + 3
print("${c.re} + ${c.im}i")
)"); // результат: `4 + 2i`
}
```
Таким образом, не обязательно писать функцию преобразования в самом C++, а лишь затем экспортировать ее в ChaiScript. Можно добавить преобразования, и уже в самом коде скрипта описать новый функционал. Если же конвертация для двух типов нетривиальна, вы можете передать лямбду аргументом в функцию `type_conversion`. Она будет вызываться при приведении типов.
Схожий принцип используется для преобразования Vector или Map ChaiScript'а в ваш пользовательский тип. Для этого в библиотеке определены `vector_conversion` и `map_conversion`.
#### Распаковка возвращаемых значений ChaiScript
Методы `eval` и `eval_file` возвращают значение последнего выполненного выражения в виде объекта `Boxed_Value`. Чтобы распаковать его и использовать результат в коде C++, вы можете как явно указать тип возвращаемого значения, так и использовать функцию `boxed_cast`. Если преобразование между типами существует, оно будет выполнено, иначе возникнет исключение `bad_boxed_cast`:
```
// сразу привести результат к нужному типу
double d = chai.eval("5.3 + 2.1");
// сохранить результат в виде Boxed\_Value, затем привести к типу
auto v = chai.eval("5.3 + 2.1");
double d = chai.boxed\_cast(v);
```
Так как все объекты внутри ChaiScript хранятся с помощью shared\_ptr, вы можете получить объект в виде указателя для последующей работы с ним. Для этого явно укажите тип shared\_ptr при конвертации возвращаемого значения:
```
auto x = chai.eval>("var x = 3.2");
```
Главное, не стоит хранить ссылку на значение разыменнованного shared\_ptr, иначе вы рискуете получить access violation после того, как переменная будет удалена в ходе автоматической сборки мусора в скрипте.
Так же как и переменные, вы можете достать из ChaiScript функции в виде запакованных функторов, захватывающих состояние объекта ChaiScript. Для примера, воспользуемся уже реализованным функционалом класса Complex и попробуем с помощью него вызвать функцию на этапе выполнения программы:
```
auto printComplex = chai.eval>(R"(
fun(Complex c) { print("${c.re} + ${c.im}i"); }
)"); // создаем лямбду, печатающую объект класса, а затем возвращаем ее в C++
printComplex(Complex(2, 3)); // вызов chaiscript, печатает `2 + 3i`
```
#### Перехват исключений из ChaiScript
Авторы рекомендуют ловить три типа исключений помимо тех, которые вы генерируется самостоятельно. Это `eval_error` для ошибок времени выполнения, `bad_boxed_cast`, вызывающийся при неправильной распаковке возвращаемых значений и `std::exception` для всего остального. Если же вы планируете выкидывать свои собственные исключения, вы можете настроить автоматическое преобразование в типы С++:
```
class MyException : public std::exception
{
public:
int Data;
MyException(int data) : std::exception("MyException"), Data(data) { }
};
int main()
{
chaiscript::ChaiScript chai;
// добавим исключение как тип в chaiscript
chai.add(chaiscript::user_type(), "MyException");
chai.add(chaiscript::constructor(), "MyException");
try
{
// укажем к каким типам пытаться приводить исключения внутри скрипта
chai.eval("throw(MyException(11111))",
chaiscript::exception\_specification());
}
catch (MyException& e)
{
std::cerr << e.Data; // здесь выведется `11111`
}
catch (chaiscript::exception::eval\_error& e)
{
std::cerr << e.pretty\_print();
}
catch(std::exception& e)
{
std::cerr << e.what();
}
}
```
В примере выше показано, как можно ловить большинство исключений в C++. Помимо метода `pretty_print`, у `eval_error` имеется еще много полезных данных, таких как стек вызовов, имя файла, детали ошибки, но так сильно углубляться в этот класс в рамках этой статьи мы не будем.
#### Библиотеки ChaiScript
К сожалению, по умолчанию ChaiScript не предоставляет дополнительного функционала в плане библиотек. К примеру, в нем отсутствуют математические функции, хеш-таблицы, большинство алгоритмов. Часть из них вы можете скачать в виде библиотек-модулей из официального репозитория [ChaiScript Extras](https://github.com/ChaiScript/ChaiScript_Extras), а затем импортировать в ваш скрипт. Для примера возьмем библиотеку **math** и функцию acos(x):
```
#include
#include
int main()
{
chaiscript::ChaiScript chai;
// добавим библиотеку
auto mathlib = chaiscript::extras::math::bootstrap();
chai.add(mathlib);
std::cout << chai.eval("acos(0.5)"); // ~1.047
}
```
Вы также можете написать свою библиотеку для языка и потом импортировать. Делается это достаточно просто, поэтому советую ознакомиться с открытым кодом math или другой либы в репозиторие. В принципе, в рамках интеграции с C++ мы рассмотрели почти все, так что считаю, что раздел на этом можно закончить.
Личный опыт
-----------
В данный момент я пишу 3D-движок под OpenGL в качестве персонального проекта, и у меня возникла вполне закономерная идея реализовать консоль отладки, чтобы в реальном времени управлять состоянием приложения посредством команд. Можно было бы конечно заняться [велосипедированием](https://github.com/MomoDeve/MSL), но, как говорится, «игра бы не стоила свеч», поэтому я решил взять готовую библиотеку.
Как я упомянул в начале статьи, о ChaiScript к тому моменту я уже знал, поэтому передо мной стоял выбор между ним и Lua. До того момента ни с тем, ни с другим языком я знаком не был, поэтому больше всего влияли такие факторы как: понятность синтаксиса, легкость внедрения в уже существующий код и поддержка C++ вместо C, чтобы не городить забор из ООП-оберток над C-style функциями. Думаю, по ходу чтения данной статьи вы уже догадались, на что пал мой выбор.
На данный момент язык меня более чем устраивает, и писать обвязки над классами не составляет большого труда. В коде движка к запускаемому приложению прикреплен один экземпляр консоли на ImGui, в которой инициализируется объект chaiscript. Парой макросов задача о внедрении нового класса в скрипт сводится к простому описанию всех методов, которые необходимо экспортировать:
```
// фрагмент кода с инициализацией методов 3D-объекта:
// rotation
CHAI_IMPORT(&GLInstance::RotateX, rotate_x);
CHAI_IMPORT(&GLInstance::RotateY, rotate_y);
CHAI_IMPORT(&GLInstance::RotateZ, rotate_z);
// scale
CHAI_IMPORT((GLInstance&(GLInstance::*)(float))&GLInstance::Scale, scale);
CHAI_IMPORT((GLInstance&(GLInstance::*)(float, float, float))&GLInstance::Scale, scale);
// translation
CHAI_IMPORT(&GLInstance::Translate, translate);
CHAI_IMPORT(&GLInstance::TranslateX, translate_x);
CHAI_IMPORT(&GLInstance::TranslateY, translate_y);
CHAI_IMPORT(&GLInstance::TranslateZ, translate_z);
// hide / show
CHAI_IMPORT(&GLInstance::Hide, hide);
CHAI_IMPORT(&GLInstance::Show, show);
// getters
CHAI_IMPORT(&GLInstance::GetTranslation, translation);
CHAI_IMPORT(&GLInstance::GetRotation, rotation);
CHAI_IMPORT(&GLInstance::GetScale, scale);
```
Таким же образом экспортируются еще несколько классов, а затем все соединяется вместе лямбда-функциями, объявленными прямо в коде инициализации. Результат работы скрипта вы можете увидеть на скриншоте:
*консоль с chaiscript на ImGui: загрузка и установка объекта через команды*
Учитывая в целом гибкость библиотеки, поменять подход к экспорту классов в скрипт не составит практически никакого труда. Безусловно, Lua обладает более обширной документацией и сообществом, и этот язык будет предпочтительней в случае, если вам нужно получить большую производительность от кода скрипта (JIT все же делает свое дело), но списывать со счетов ChaiScript все же не стоит. Если у вас есть небольшой проект, который нуждается в скриптинге, можете смело эксперементировать с доступными альтернативами.
На этой ноте я бы хотел завершить данную статью. Если вы уже имели опыт работы со скриптовыми языками внутри C++ (будь то Lua или другой язык), в комментариях буду рад услышать ваше мнение о ChaiScript и скриптингу в целом. Также я приветствую любые вопросы или замечания касательно публикации. Всем спасибо за прочтение.
#### Полезные ссылки
* Официальный сайт ChaiScript: [chaiscript.com](http://chaiscript.com)
* Быстрый справочник по синтаксису и библиотеке: [ChaiScript cheatsheet](https://github.com/ChaiScript/ChaiScript/blob/develop/cheatsheet.md)
* Официальная документация: [codedocs.xyz/ChaiScript/ChaiScript](https://codedocs.xyz/ChaiScript/ChaiScript/)
* Мой проект с использованием ChaiScript: [github.com/MomoDeve/MomoEngine](https://github.com/MomoDeve/MomoEngine) | https://habr.com/ru/post/483540/ | null | ru | null |
# Как использовать консоль JavaScript: выход за пределы console.log ()
Привет, Хабр! Представляю вашему вниманию перевод статьи [«How to use the JavaScript console: going beyond console.log()»](https://www.freecodecamp.org/news/how-to-use-the-javascript-console-going-beyond-console-log-5128af9d573b/?utm_source=mybridge&utm_medium=blog&utm_campaign=read_more) автора Yash Agrawal.
Один из самых простых способов отладки чего-либо в JavaScript — вывод материала с помощью console.log. Но есть много других методов, предоставляемых консолью, которые могут помочь улучшить отладку.
Давайте начнем.
Самым базовым вариантом использования является вывод строки или группы объектов JavaScript. Довольно просто,
```
console.log('Is this working?');
```
Теперь представьте сценарий, когда у вас есть куча объектов, которые вам нужно вывести в консоль.
```
const foo = { id: 1, verified: true, color: 'green};
const bar = { id: 2, verified: false, color: 'red' };
```
Самый интуитивно понятный способ вывода просто console.log (variable) несколько раз. Проблема становится более очевидной, когда мы видим, как оно отображается в консоли.
Как видите, имена переменных не видны, что не очень удобно. Это можно решить объединив все переменные в единый console.log ({foo, bar}). Это также уменьшает количество строк console.log в нашем коде.
console.table ()
----------------
Мы можем сделать следующий шаг, поместив все это в таблицу, чтобы сделать ее более читаемой. Всякий раз, когда у вас есть объекты с общими свойствами или массив объектов, используйте console.table (). Здесь мы можем использовать console.table ({foo, bar}) и консоль показывает:
console.group ()
----------------
Может использоваться, когда вы хотите сгруппировать или вложить соответствующие элементы вместе, чтобы иметь возможность легко читать log.
Также можно использовать, когда у вас есть несколько операторов log внутри функции, и вы хотите иметь возможность четко видеть область действия, соответствующую каждому оператору.
Например, если вы регистрируете данные пользователя:
```
console.group('User Details');
console.log('name: John Doe');
console.log('job: Software Developer');
console.group('Address');
console.log('Street: 123 Townsend Street');
console.log('City: San Francisco');
console.log('State: CA');
console.groupEnd();
console.groupEnd();
```
Вы также можете использовать console.groupCollapsed () вместо console.group (), если вы хотите, чтобы группы были свернуты по умолчанию. Вам нужно будет нажать кнопку дескриптора слева, чтобы развернуть.
console.warn () & console.error ()
----------------------------------
В зависимости от ситуации, чтобы ваша консоль была более читабельной, вы можете добавлять logs, используя console.warn () или console.error (). Также есть console.info (), которая отображает значок «i» в некоторых браузерах.
Можно пойти еще дальше, добавив собственный стиль. Вы можете использовать директиву %c, чтобы добавить стилизацию к любому оператору log. Это можно использовать для различения вызовов API, пользовательских событий и т. д.
```
console.log('%c Auth ‘, 'color: white; background-color: #2274A5’, 'Login page rendered');
console.log('%c GraphQL ','color: white; background-color: #95B46A', 'Get user details');
console.log('%c Error ', 'color: white; background-color: #D33F49', 'Error getting user details’);
```
Вы также можете изменить размер шрифта, стиль шрифта и другие элементы CSS.
console.trace ()
----------------
console.trace () выводит трассировку стека в консоль и отображает, каким образом код завершился в определенный момент. Есть определенные методы, которые вы хотели бы вызвать только один раз, например, удаление из базы данных. console.trace () может использоваться, чтобы убедиться, что код ведет себя так, как мы этого хотим.
console.time ()
---------------
Еще одна важная вещь, когда речь заходит о frontend разработке, это то, что код должен быть быстрым. console.time () позволяет синхронизировать определенные операции в коде для тестирования.
```
let i = 0;
console.time("While loop");
while (i < 1000000) { i++;}console.timeEnd("While loop");
console.time("For loop");
for (i = 0; i < 1000000; i++) { // For Loop}console.timeEnd("For loop");
```
Надеюсь, что статья предоставила некоторую информацию о различных способах использования консоли. | https://habr.com/ru/post/492366/ | null | ru | null |
# phpThread: нити в PHP? Запросто
Если вы хотите научиться писать многопоточные приложения на PHP или здорово упростить себе жизнь — статья для вас.
Раньше для этих целей я пользовался либо запуском несколько копий скрипта, либо же использовал pcntl на более низком уровне, чем хотелось бы. Это, а от части и Java-идеология работы с потоками, побудили меня к написанию пакета phpThread.
Итак:
> `php<br/
> include 'thread.class.php';
>
> include 'threadCollection.class.php';
>
> class MyThread extends Thread
>
> {
>
> public function run()
>
> {
>
> for (;;)
>
> {
>
> echo date('r')."\n";
>
> if (!$this->sleep(2)) {return;}
>
> }
>
> }
>
> }
>
> echo "Starting...\n";
>
> $threads = new threadCollection;
>
> for ($i = 0; $i < 5; ++$i) {$threads->push(new MyThread);}
>
> $threads->start();
>
> echo "Doing pseudo-job (sleep for 5 seconds)...\n";
>
> sleep(5);
>
> echo "Pseudo-job in master done. Stopping and waiting...\n";
>
> $threads->stop();
>
> $threads->wait();
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Этот незамысловатый код создает 5 чаилдов, ждет 5 секунд, а потом их останавливает.
Забрать можно здесь — [code.google.com/p/phpthread](http://code.google.com/p/phpthread/)
Проект написан буквально на коленке, однако прекрасно работает.
На данный момент исходники весят 1 247 байт.
В ближайших планах — сделать удобную работу с конкурентными хранилищами.
Данную технику стоит применять:
1. Когда программа недостаточно быстро получает данные и растёт время простоя. Например, при генерации красивого графика можно одним потоком получать данные из СУБД (выполняется тяжелый запрос), а во втором потоке производить отрисовку.
2. Когда нужно выполнить несколько операционных задач, и более эффективно задействовать процессор.
Буду рад любым отзывам, идеям, и замечаниям.
Спасибо за внимание. | https://habr.com/ru/post/59982/ | null | ru | null |
# Возрождение ActionScript2.0 c помощью JavaScript
И вот уже март 2017 года, Adobe Flash Player уже не запускается по умолчанию без явных действий пользователя, по крайней мере в Google Chrome для автоматического запуска контента Adobe Flash Player необходимо выполнить [следующии инструкции](http://).Таким образом, акцент веб-разработки все больше и больше смещается в сторону использования JavaStript библиотек, предоставлющих доступ к HTML5 Canvas.
Одним из удобных способов разработки HTML5 Canvas, заместо Flash, является Adobe Animate CC 2017, который подерживает следущие типы проектов:
Из списка видно, что подержка ActionScript2.0 полностью исключена из текущей версии среды разработки, а также нет возможности перенести имеющийся AS2/3 код в html5 Canvas.
Единственное, что можно сделать в Adobe Animate CC 2017 — это преобразовать графическое содержимое Flash проекта и все входящие в него компоненты в HTML5 проект.
Для этого достаточно открыть Flash проект и выбрать из меню *Commands* пункт *Convert To Other Documents Format* после чего откроется диалоговое окно с предложением выбора типа проекта в который происходит преобразование. По умолчанию используется HTML5 Canvas, его и будем использовать в наших новых проектах.
После преобразования Flash проекта, весь AS код в проекте комментируется, что значит все должно быть переписано заново на JavaScript. В качестве API интерфейса для взаимодействия со средой разработки, используется библиотека [CreateJS](http://www.createjs.com/).
Данная библиотека по функционалу во многом, но к сожалению не во всем, совместима с привычным многим стандартным методам и классам AS. Например, любой объект типа [MovieClip](http://www.createjs.com/docs/easeljs/classes/MovieClip.html) включает в себя метод gotoAndStop() для переключания между кадрами, а также многое другое.
В связи с наличием большого количества кода ActionScript2.0, после ознакомления с библиотекой CreateJS, было принято решение разработать расширение к функционалу библиотеки с дополнительными методами совместимыми с AS2.0.
В итоге, был создан проект для более упрощенного переноса кода графических компонентов Flash [CreateJSToAS2](https://github.com/askeet/CreateJSToAS2). Эта библиотека включает в себя некоторые основные методы расширения для класса MovieClip. А также реализована(перегружена) функция eval, что бы была возможность обращения
к определенным элементам на ролике с помощью строки, аналогично тому как это сделано в ActionScript 2.0.
Хотя это еще малая часть возможностей ActionScript 2.0, но и это уже позволяет, много перенести без всякого изменения кода.
Библиотека CreateJSToAS2 подключается в заголовке html файла с помощью файла Lib\AS2\_Library.js.
```
```
А в теле функции init должна быть вызвана инициализирующая библиотеку функция InitAS2(), а после неё возможно написание вашего кода, конечно возможен другой вариант по вызову события, но этот самый простой.
```
var canvas, stage, exportRoot;
function init() {
canvas = document.getElementById("canvas");
exportRoot = new lib.AS2ToAS3_Canvas();
stage = new createjs.Stage(canvas);
stage.addChild(exportRoot);
stage.update();
createjs.Ticker.setFPS(lib.properties.fps);
createjs.Ticker.addEventListener("tick", stage);
InitAS2();
Init();
}
function Init(){
var _root = exportRoot;
// Write your code here
}
```
Например следующий пример создания MovieClip и рисования линий, будет совместим c html 5 Canvas
```
_root.createEmptyMovieClip("line_mc", 1);
_root.line_mc.lineStyle(10, 0xFF0000, 100);
_root.line_mc.moveTo(0, 0);
_root.line_mc.lineTo(150, 0);
_root.line_mc.lineTo(150, 50);
_root.line_mc.lineTo(0, 50);
_root.line_mc.lineTo(0, 0);
_root.line_mc._x=150;
_root.line_mc._y=150;
```
Создание нового текста MyText с текстом 'Hello Word'
```
eval('line_mc').createTextField("MyText", undefined, 10, 10);
eval('line_mc.MyText').text = 'Hello Word';
```
Даже подключение нового компонента из библиотеки Adobe Animate будет аналогично тому, как вы бы это сделали в AS2. Например, если есть компонент "LibMovie", то что бы подключить его, как Movie2 сделаем так.
```
_root.attachMovie("LibMovie","Movie2",undefined).x = 250;
_root.Movie2.y = 100;
eval('Movie2')._width = 40;
eval('Movie2')._height = 40;
```
Конечно еще много, что может быть еще расширенно и реализовано в этой библиотеке аналогично тому, как это уже сделано, но для этого конечно необходима заинтересованность community в openSource-проекте. Спасибо за внимание. | https://habr.com/ru/post/323388/ | null | ru | null |
# Представляем Sencha Ext JS 5
От имени компании Sencha и всей команды Ext JS я горд объявить, что сегодня мы выпускаем Ext JS 5. Ext JS 5 — это гигантский шаг вперёд и мы хотим воспользоваться случаем и поблагодарить наше сообщество за отзывы и постоянную поддержку. Это было самое крупное бета-тестирование в нашей истории с более чем 100K загрузок. Вместе мы создали самый продвинутый в мире multi-device JavaScript-фреймворк. Вы все сделали неоценимый вклад в создание самого лучшего фреймворка Ext JS.
#### Что нового
##### Поддержка touch
Ext JS 5 — это самый обширный апдейт фреймворка. Этот релиз представляет возможность запускать вашие desktop-приложения на touch-устройствах используя единую кодовую базу.
##### Улучшения архитектуры
Сейчас как никогда стало легко писать приложения, используя архитектуру MVVM и двунаправленный дата-биндинг. В клиентскую часть мы встроили управление сессиями данных для того, чтобы уменьшить число обращений к серверу. Ввод маршрутизации (*routing*) позволяет создавать глубокие ссылки в ваших приложениях. Со всеми этими улучшениями разработка приложений будет ещё более эффективной.
##### Отзывчивая разметка
Начиная с сегодняшнего дня благодаря новой системе отзывчивой разметки в ваших приложениях появилась возможность иметь оптимальный вид как среди десктопов, так и планшетов, независимо от изменений ориентации.
##### Обновления компонентов
Так же как растут ваши приложения, Sencha продолжает улучшать библиотеку компонентов. С Ext JS 5 вы можете добавлять виджеты в ячейку таблицы для визуалазации и аналитики больших данных. Также появился touch-оптимизированный набор компонент для построения графиков с финансовыми возможностями.
#### Посмотрим в действии!
* [Примеры с Ext JS 5](http://dev.sencha.com/extjs/5.0.0/examples/index.html)
* [Страница с продуктами Ext JS 5](http://www.sencha.com/products/extjs)
* [Обучающие материалы и документация](http://docs.sencha.com/extjs/5.0.0/)
#### Глубже в Ext JS 5
##### Унифицированные события среди десктопов и тачскринов
Ext JS 5 это первая версия, которая позволяет использовать один код на десктопах и устройствах с тачскрином. Используя систему жестов из Sencha Touch мы ввели поддержку таких жестов как pinch, zoom, swipe, tap, длинное нажатие и т.д., так что вы можете использовать ваши десктопные приложения на тачскринах с небольшими доработками или вовсе без них. Мы замапили щелчок мыши на события тач-устройств при помощи нашей [делегированной системы событий](http://www.sencha.com/blog/delegated-events-and-gestures-in-ext-js-5/), которая делает сопоставление автоматически.
##### MVVM и двунаправленное связвание
В Ext JS 4 мы представили архитектуру MVC. А в Ext JS 5 — MVVM (Model — View — ViewModel), которая предлагает двунаправленное связывание данных и улучшенное разделение ответственности между бизнес-логикой и представлениями. MVVM позволяет автоматически переносить изменения из представления в модель и наоборот. Эта живая и автоматическая синхронизация между представлениями и моделями позволяет сократить время разработки и ошибки. Также мы добавили вычисляемые значения и поля, так что привязка объекта к представлению перед синхронизацией может быть предварительно преобразована. Мы надеемся, что новая архитектура MVVM будет полезной.
В дополнение к MVVM в Ext JS 5 мы также улучшили поддержку MVC введением ViewController'ов. ViewController'ы нацелены именно на определённое представление, снимая лишние затраты по сравнению с традиционным MVC на управление объектами и восстановление состояния приложения. Теперь, избегая обычных контроллеров, которые слушают все события представлений, приложения могут уменьшить использование памяти и улучшить производительность.
##### Отзывчивая разметка
Ext JS 5 представляет новый плагин отзывчивой разметки, который направлен на улучшение вида приложений и навигации среди десктопов и тачскринов. Когда меняется ориентация (устройство повернулось), приложения, которым нужно изменить позицию или расположение элементов, могут делать это автоматически, используя новую систему конфигурации.
| | | |
| --- | --- | --- |
|
```
responsiveConfig: {
landscape: {
region: 'west'
},
portrait: {
region: 'north'
}
}
```
| или |
```
responsiveConfig: {
'width > 800': {
region: 'west'
},
'width <= 800': {
region: ‘north'
}
}
```
|
Для того, чтобы увидеть его в действии, попробуйте [этот пример](http://dev.sencha.com/extjs/5.0.0/examples/executive-dashboard/index.html#!kpi/clicks) изменяя размер экна браузера или поворачивая экран тачскрина.
##### Neptune Touch и Crisp Touch
У нас две новые multi-device темы, которые позволяют нашей богатой коллекции UI-компонентов выглядеть одинаково на десктопах и тачскринах. Тач-версии существующей темы Neptune и новой темы Crisp используют увеличенные элементы для поддержки большего пятна соприкосновения, которое требуется при работе на тачскринах.
Вы можете использовать тач-версии тем на десктопах и тачскринах, но мы рекомендуем использовать Neptune и Crisp для десктопа, и Neptune Touch и Crisp Touch — для тачскринов.
##### Улучшения таблиц
Grid — точно самый популярный компонент в Ext JS, а в версии 5 мы сделали его ещё более мощным. С введением грид-виджетов (*Grid Widgets*), которые могут быть совмещены с новой функцией — Buffered Updates, мы сделали возможной визуализацию rich data и обновления в реальном времени для поддержки аналитики больших данных.
##### Управление сессиями
Одна из самых восхитительных функций в ExtJS 5 — это управление сессиями (*Session Management*): мы добавили транзакционные сессии. Когда вы сохраняли записи на сервер с Ext JS 4, вам приходилось быть внимательными к тому, в каком порядке вы это делали. Вам приходилось удостовериваться в том, что вы вызвали метод сохранения для каждой из изменённых записей и хранилищ. Всё это «счётоводство» делало согласование данных склонным к ошибкам.
В Ext JS 5 появился новый класс для работы с этими действиями — [Ext.data.Session]. Сессия отслеживает записи, которым необходимо измениться, создаться или удалиться на сервере. Она даже может отсортировать эти операции для того, чтобы новые записи правильно ссылались на другие записи в этой транзакции. Используя сессии, стало проще редактировать записи и их ассоциации, собирать все изменения и отправлять на сервер. И т.к. сессия хранит все ваши изменения, вы можете получить их сразу, либо ни одной — в зависимости от того, завершилась ли транзакция успешно или нет.
##### Маршрутизация (Routing)
Ext JS 5 делает возможным создание в приложениях глубоких ссылок (*deep linking*), когда маршрут URL преобразуется в методы контроллера. Маршрутизация позволяет настроить приложения принимать такие URL, которые не обязательно ссылаются на физический файл на сервере. Часть URL, начинающаяся с # (используется как идентификатор фрагмента) открывает дорогу к стеку истории браузера без перезагрузки страницы. Когда изменяется hash, браузер создаёт событие 'hashchange', которое может быть использовано клиенским приложением самостоятельно.
##### Тач-оптимизированные графики
Ext JS 4 предоставлял систему графиков без плагинов, основанных на SVG и VML. Тем не менее, мы обнаружили, что эта система не была оптимальной на мобильных устройствах, более ограниченных в памяти, в которых был быстрый Canvas, но медленный SVG. С Ext JS 5 мы перестроили её на основе аналогичной системы из Sencha Touch, которые лучше оптимизированы для работы пальцами на устройствах с небольшим объемом памяти. Новая система графиков получила больше функций, таких как финансовые графики, многомерные и 3D-графики, включая поддержку зумирования. У них лучше производительность, они более расширяемы и имеют отличные возможности на тачскринах.
Мы даже сделали примеры приложений для работы с разными типами графиков наподобие Kitchen Sink. Обратите внимание, что существующие графики из Ext JS 4 до сих пор доступны отдельно, так что вы тоже можете их использовать. Но, если вы нацелены на планшеты, вам стоит сделать апгрейд на новую систему графиков. Детальная инструкция по миграции на Ext JS 5 представлена в нашей [документации](http://docs.sencha.com/extjs/5.0.0/).
##### Sencha Core Package
Одна из сверхзадач Ext JS 5 была свести ядра Ext JS и Sencha Touch как можно ближе. Мы последовательно сводили код системы классов, пакета работы с данными и обнаружения функций/среды, так что этот код можно использовать как в Ext JS, так и в Sencha Touch. Эта общая платформа позволит воздавать приложения с общими ресурсами независимо от фреймворка, на десктопах, планшетах и других тачскринах. Теперь мы работаем над релизом Sencha Touch, основанного на этом общем ядре. Следите за обновлениями.
##### Инструкции и документация
С Ext JS 5 мы не только добавили массу новых инструкций для появившихся функций и улучшений, но также обновили саму систему инструкций, чтобы ей было легче пользоваться. Эти инструкции охватывают всё об апгрейде на новый фреймворк: Sencha Cmd, графики, архитектура приложения и многое другое.
Мы упомянули только некоторые важные функции Ext JS 5, но есть ещё много о чём поговорить. Мы дадим вам изучить остальные новые функции и улучшения в инструкции [What's New in Ext JS 5](http://docs.sencha.com/extjs/5.0.0/whats_new/5.0/whats_new.html).
#### Поддерживаемые браузеры и платформы
Возможно, одна из глафных вещей, которая не изменилась в Ext JS 5 — это то, что мы продолжаем работать с IE8 как с VIP-клиентом (*as a first-class citizen, — прим. перев.*). Ext JS 5 поддерживает Safari 6+, Firefox, IE8+, Chrome и Opera 12+. На мобильной платформе поддерживаются Safari на iOS 6 и 7, Chrome на Android 4.1+, и на тачскринах под Windows 8 (таких как Surface и других тачскрин-лаптопах) — IE10+.
#### Обучение по Ext JS 5
Мы также обновили [программы тренингов](http://www.sencha.com/training/ext-js-5-update-training) по Sencha. Тренинги по Ext JS 5 начинаются в июне, и это включают следующие классы: Ext JS 5 Update, Upgrading to Ext JS 5, и Fast Track to Ext JS 5.
#### Цены на Ext JS 5
Начиная с этого релиза до 30 июня 2014 лицензии на Ext JS 5 будут доступны по ценам на текущий Ext JS 4.x. Это отличная возможность купить Ext JS 5 по нынешней стоимости. Начиная с 1 июля войдут в силу новые цены. Для подробной информации, пожалуйста, посетите [страницу с продуктами Ext JS 5](http://www.sencha.com/products/extjs) или [свяжитесь с нами](http://www.sencha.com/contact).
#### Большое спасибо
Мы бы хотели ещё раз выразить искреннюю благодарность нашему сообществу. Ваши запросы на новые функции, предложения, отзывы и багрепорты позволили достичь всех целей этого релиза. Мы очень активно работали над тем, чтобы свести к минимуму изменения кода при переходе с Ext JS 4 на Ext JS 5. Надеемся, вам понравится писать новые приложения с Ext JS 5 так же, как нам понравилось писать эту версию. | https://habr.com/ru/post/225169/ | null | ru | null |
# Тестирование инсталляторов в Windows, когда надо быстро и дешево
Счастливы веб-тестеры, бери селениум и не ошибешься. Счастливы java-tester'ы — для них есть тест-фреймворки, в особо тяжелых случаях- siculi. Принесли на тесты консольные приложения — тут приятны python, perl. А как же desktop? Тестирование приложений blackbox в windows, в частности — инсталляторов (например пакетов msi) привело меня в стан autoit, ввиду того, что автоматизация у меня каждый раз напарывается на одни и те же грабли, которые я выделил в следующее
Что надо от автотеста инсталлятора:
-----------------------------------
1. Кликать, вместо меня, там где надо — в русской и английской версиях интерфейса и чтобы без правки исходников. Для этого есть много разных способов, но мне больше понравился путь [Аutoit](http://www.autoitscript.com/site/autoit/downloads/) — достаточно знать имя экземпляра объекта и можно послать ему сообщение о нажатии, единственный минус — надо знать имя окна, где расположена наша кнопка, как на русском, так и английском.
2. Не парить кучей одинакового кода, например, если для нажатия кнопки 2 или кнопки 3 мне надо пройти путь через окна 1, 2 и 3, я бы хотел объединить нажатие кнопок в окнах 1, 2, 3 в некую абстракцию «путь к кнопкам 2 и 3» и вызывать ее по мере надобности.
3. Отчеты о завале, докуда успел докликать, вобщем, что делал. Может быть даже делать скрины перед нажатием кнопочек?**Скрытый текст**Как-нибудь потом реализую
4. Отчет о результате если все сделал, смоук тест о том, что все действия реально выполнились, а не что кнопки нажались. Для инсталлятора — появились ли файлы, активны ли службы, запускается ли интерфейс.
5. Не хочу перекомпилировать и раскидывать новые еxe. Хочу править завалившийся автотест прямо на машине где он завалился, среда написания автотеста не должна вносить изменений в окружение — JAVA, .net, etc. Сотни случаев — у меня тесты прошли на ура, у клиента нет — приложить какой-нибудь .net забыли. В основном по этой причине отвалились варианты использования siculi- очень уж накладно откатывать java, для проверки, что без нее все тоже не работало.
6. Тестер в обычном мире, полном боли и отчаяния, не том что показан в маркетинговом гладком ролике о tfs это если сильно повезет — ты и девочка, которая аккуратно идет по тест-плану (мне вот не везет и девочка отсутствует). Ей не нужен python, тысячи тысяч возможностей из cpan. Нужно — убрать рутину. Еще бонусом в тленной реальности тестерами будут на пол-ставочные студенты, круто, но как только студент освоит perl, python, он сбежит в кодеры и сильно повезет, если он успеет выполнить ту задачу по тестированию, которую ему ставили. Так я пришел к мысли о минимуме возможностей для программирования во время тестирования.
7. Путь выполнения не на всех операционных системах одинаков, где-то появляется окошко uac, где-то нет, я не хочу заморачиваться на это каждый раз. Должен быть способ какого-то ветвления при выполнении тестового пути.
Сведя все в список я пришел к следующей идее — мне нужен свой кликер окошек *с настройками в ini-файлах и отчетами*.
Ок, учтем опыт поколений, будем использовать unix-way: разобъем задачу на две части — кликер и формирователь отчета.
Кликер кликает по указанным в простейшем, желательно самодокументированном, текстовом файле объектам — кнопкам, имитирует нажатия с клавиатуры.
Формирователь отчета — отдельная прожка, пишется под каждый конкретный случай, может проверять службы, создание в нужном месте файликов, сравнивать вывод к примеру команды dir c эталоном и проч если, надо. В большинстве случаев его даже не надо, тк опыт показывает, что постоянно требуется проверять новый функционал и его придется смотреть самостоятельно.
Пример настроек для кликера: файл ways.ini, в котором содержатся уникальные пути выполнения теста:
**Скрытый текст**[PathToButtonSetup]
LogMessage=Take First Window, push button1
WindowsNameEnglish=System Setup
WindowsTextEnglish=Welcome to
Element=[CLASS:Button; INSTANCE:1]
WindowsNameRussian=Установка Системы
WindowsTextRussian=чтобы выйти из мастера
SendKeyText=
LogMessage=Take second Window, push button2
WindowsNameEnglish=System Setup
WindowsTextEnglish=Welcome to
Element=[CLASS:Button; INSTANCE:2]
WindowsNameRussian=Установка Системы
WindowsTextRussian=Вы устанавливаете
SendKeyText=
[Clicksetup]
LogMessage=Take Therth Window, push button1
WindowsNameEnglish=System Setup
WindowsTextEnglish=Complete
Element=[CLASS:Button; INSTANCE:1]
WindowsNameRussian=Установка Системы
WindowsTextRussian=Все готово
SendKeyText=
[ClickCancel]
LogMessage=Take Therth Window, push button2
WindowsNameEnglish=System Setup
WindowsTextEnglish=Complete
Element=[CLASS:Button; INSTANCE:2]
WindowsNameRussian=Установка Системы
WindowsTextRussian=Все готово
SendKeyText=
Собственно теперь, имея описание того, что можно делать с инсталлятором, соберем тестовый путь, описав его в другом ini-файле, testway1.ini.
**Скрытый текст**[initials]
countOps=7
ClickerIniPath=«ways.ini»
sLogPath=«logs.txt»
[testWay]
case1=PathToButtonSetup
case2=Clicksetup
Если нам понадобится проверить кнопку кансел — сделаем другой ini файлик, testway2.ini
**Скрытый текст**[initials]
countOps=7
ClickerIniPath=«ways.ini»
sLogPath=«logs2.txt»
[testWay]
case1=PathToButtonSetup
case2=ClickCancel
countOps — количество за раз считываемых настроек из ways.ini — сейчас их 7 штук: LogMessage, WindowsNameEnglish, WindowsTextEnglish, Element, WindowsNameRussian, WindowsTextRussian, SendKeyText. sLogPath — имя файла для сообщений, LogMessage. Остальное наверняка понятно из названий. Свойство Element придется определять через программку Au3Info.exe
Пример кода, что сможет работать с такими ini-файлами, clickAndType.au3:
**Скрытый текст**#include
$sLogMsg=""
$TestWayIniPath=«clickandtype.ini»
if $CmdLine[0]<>0 Then $TestWayIniPath=$CmdLine[1]
$countOps=IniRead($TestWayIniPath,'initials',«countOps»,«7»)
$ClickerIniPath=IniRead($TestWayIniPath,'initials','ClickerIniPath',«clicker.ini»)
$sLogPath=IniRead($TestWayIniPath,'initials','sLogPath',«logs.txt»)
$TestWay = IniReadSection($TestWayIniPath, 'testWay')
If `@error` Then
MsgBox(4096, "", «Error occured, probably no INI file.»)
Exit
EndIf
; Прочтем выбранный путь выполнения
For $TestWayElement=1 to $testWay[0][0]
$ControlsActivities = IniReadSection($ClickerIniPath,$TestWay[$TestWayElement][1])
If `@error` Then
MsgBox(4096, "", «Error occured, probably no INI file. „& $ClickerIniPath&' '&$TestWay[$TestWayElement][1])
EndIf
$stopCycle=abs($ControlsActivities[0][0]/$countOps)
For $Elements=0 to $StopCycle-1
$win=$ControlsActivities[$Elements\*$countOps+2][1]
$wintex=$ControlsActivities[$Elements\*$countOps+3][1]
$ControlToPress=$ControlsActivities[$Elements\*$countOps+4][1]
$winEng=$ControlsActivities[$Elements\*$countOps+5][1]
$wintexEng=$ControlsActivities[$Elements\*$countOps+6][1]
$SendString=$ControlsActivities[$Elements\*$countOps+7][1]
$sLogMsg=$ControlsActivities[$Elements\*$countOps+1][1]
\_FileWriteLog( $sLogPath, 'Окно:'&$win&' '&$wintex&' Действие:'&$sLogMsg)
While 1
if WinActive($win,$wintex) Then
$winEng=$win
$wintexEng=$wintex
ExitLoop
ElseIf WinActive($winEng,$wintexEng) then
$win=$winEng
$wintex=$wintexEng
ExitLoop
EndIf
sleep(3)
WinActivate($win,$wintex)
WinActivate($winEng,$wintexEng)
WEnd
if $controlToPress<>“» then
ControlClick($win,$wintex,$ControlToPress)
EndIf
if $SendString<>"" Then
Send($SendString)
EndIf
\_FileWriteLog( $sLogPath, 'Done')
Next
Next
Прожка для запуска требует параметр — имя файла для получения настроек (testway2.ini, например, в котором указано, что выполнить из файла ways.ini).
Как же всем этим хозяйством добиться ветвления из пункта 7? Все очень просто, при запуске тест виснет в трей и ждет появления указанного окошка, можно параллельно запустить несколько программок-автотестов, одна из которых, к примеру, будет реагировать на окошко с требованием ввода пароля, введет его и изначальный тест продолжит свое выполнение как будто ничего не случилось.
Про вторую прожку — формирователь отчета я пожалуй не буду писать, очень уж там все индивидуально.
Ок, оно за меня может кликать, что дальше, Брейн? Надо избавиться от порочной практики по запуску автотеста своими руками, хорошая идея — подготовить специальные виртуалки, сделать снепшот BeforeInstallXXX, который будет содержать в автозапуске батник вида, runme.bat:
**Скрытый текст**msiexec /i "\\fileshare\install\installer.msi"
start «testway1» /wait clickAndType.exe \\fileshare\install\testway1.ini
Осталось лишь размещать в файловой шаре тестируемый инсталлятор и перезагружать виртуальные машинки. Если быть достаточно везучим, можно на файловой шаре также разместить и сам автотест, тогда все изменения будут централизованы и вы сэкономите время на копировании файлов настроек testway.ini, ways.ini в каждую виртуалку.
По мере роста ваших запросов, скорее всего вы придете к мысли, что функционал runme.bat надо усложнять, насколько я могу судить, скоро предстоит реализовывать третью программку — раннер, который заменит runme.bat, и, видимо, будет уметь в зависимости от каких-то условий выбирать параметр запуска clickAndType.exe
9 из 10 ставлю на то, что все вышеописанное — это велосипед, который был изобретен уже 1000 раз 1000 разных людей и на самом деле все уперлось в то, что все они имели фатальный недостаток-написаны не мной, бонусом написаны программистами, которые в порывах максимальной универсальности нередко порождали монстров, я же, являясь основным заказчиком и пользователем был заинтересован в простоте инструмента таким его и реализовывал. Заодно скажу, что найти какую-либо информацию по тестированию инсталляторов в windows простым гуглением мне не посчастливилось. Теперь же она будет здесь. | https://habr.com/ru/post/197586/ | null | ru | null |
# Замедление хеширования паролей. Зачем?
 Доброго времени суток, хабрапараноик! Сегодня мы поговорим о немного необычном способе повышения безопасности, а именно **замедлении хеширования паролей**. Казалось бы, когда всё вокруг стараются оптимизировать, зачем что то замедлять?
Хотя бы затем, что даже в самой супер-пупер защищенной системе самым слабым звеном остается человек. А именно, его пароль.
Вы пытались когда нибудь взломать зашифрованный rar архив? И сколько паролей в секунду оно перебирало? 50-100-200? Даже на хорошем GPU, при использовании небезызвестного cRARk, скорость перебора [всего](http://www.password-crackers.com/en/category_99/program_13.html) около 2400 вариантов/сек. И это-то по сравнению с десятками (сотнями) миллионов паролей/сек для zip/md5/SHA1.
Под катом моя вольная интерпретация этого процесса.
Смысл всего действа сводится к следующему:
* Ключом шифрования важной является не пароль, а (медленный) хэш от него
* Юзеру ничего не стоит подождать секунду\пол секунды пока пароль прохешируется
* А вот homo brutforsus придется запастись терпением
Да, чуть не забыл про всеми любимые [rainbow tables](http://ru.wikipedia.org/wiki/Радужная_таблица), которые довольно успешно генерятся даже для систем, использующих ~~сахар~~ [соль](http://en.wikipedia.org/wiki/Salt_(cryptography)). Их генерация тоже станет если не бесполезной, то очень трудозатратной.
Я не говорю, что системы с солью плохие, просто их можно **еще** усилить.
И так, есть соль, есть пароль. Что дальше?
А дальше все довольно просто:
1. Конкатенируем соль и пароль
2. Хэшируем, запоминаем результат
3. while (много много раз) do{
4. сгенерировать раундовую соль
5. Сконкатенировать её и хэш
6. Прохэшировать, запомнить результат}
В Winrar (спасибо ему, кстати, за вдохновение), если мне не изменяет память, раундовой солью является номер итерации. Я же пошел *немножко* дальше.
Итак, код. Всё написано на java с использованием библиотеки [BouncyCastle](http://www.bouncycastle.org/), но вдумчивому хабрапараноику не составит сложности перенести это (и может быть добавить своё) на любой язык программирования, полный по тьюрингу. К тому же BouncyCastle есть и для C#.
1. Я использую 2 алгоритма хеширования (SHA-256 и SHA-512), поэтому для начала небольшой интерфейсик, который поможет нам всё это дело более-менее универсализировать.
> public interface IDigest
>
> {
>
> public byte[] process(byte[] data);
>
>
>
> public int getSize();
>
> }
>
>
>
>
2. Пример реализации этого интерфейса для алгоритма SHA-256 (используется класс **SHA256Digest** из библиотеки [BouncyCastle](http://www.bouncycastle.org/)):
> public class SHA256 implements IDigest
>
> {
>
>
>
> private SHA256Digest m\_SHA256 = new SHA256Digest();
>
>
>
> @Override
>
> public byte[] process(byte[] data)
>
> {
>
> m\_SHA256.reset();
>
> m\_SHA256.update(data, 0, data.length);
>
> byte[] result = new byte[m\_SHA256.getDigestSize()];
>
> m\_SHA256.doFinal(result, 0);
>
> return result;
>
> }
>
>
>
> @Override
>
> public int getSize()
>
> {
>
> return m\_SHA256.getDigestSize();
>
> }
>
> }
>
>
>
>
3. Самая вкуснятина. Её я объясню подробно.
> public class SlowHasher
>
> {
>
> private final static int BITS\_IN\_BYTE = 8;
>
>
>
> private static final int[] s\_primeIndices = new int[] { 7, 11, 17, 23, 31, 41, 47, 53, 61 };
>
>
>
> /\*\*
>
> \* this method hashes password 0x50000 times adding round salt each round
>
> \*
>
> \* [param](https://habrahabr.ru/users/param/) digest
>
> \* [param](https://habrahabr.ru/users/param/) password
>
> \* [return](https://habrahabr.ru/users/return/)
>
> \*/
>
> public byte[] calculateSlowHash(IDigest digest, String password, byte[] salt)
>
> {
>
> int roundSaltSize = digest.getSize() / BITS\_IN\_BYTE;
>
> byte[] bPasswd = password.getBytes();
>
> byte[] toHash = new byte[bPasswd.length + salt.length];
>
>
>
> /\*
>
> \* composing array of bytes that will be hashed
>
> \*/
>
> System.arraycopy(salt, 0, toHash, 0, salt.length);
>
> System.arraycopy(bPasswd, 0, toHash, salt.length, bPasswd.length);
>
>
>
> byte[] res = digest.process(toHash);
>
> byte[] temp = new byte[res.length + roundSaltSize];
>
>
>
> for (int i = 0; i < 0x50000; i++)
>
> {
>
> System.arraycopy(res, 0, temp, 0, res.length);
>
>
>
> /\*\*\*
>
> \* calculating salt
>
> \*/
>
> for (int j = 0; j < roundSaltSize; j++)
>
> {
>
> int btmp = res[s\_primeIndices[j]] & 0xFF;
>
> for (int k = 1; k < BITS\_IN\_BYTE; k++)
>
> {
>
> btmp = ror((btmp + (res[ror(btmp, k) % res.length] & 0xFF)) % 256, BITS\_IN\_BYTE-k);
>
> }
>
> temp[res.length + j] = (byte)btmp;
>
> }
>
> res = digest.process(temp);
>
> }
>
> return res;
>
> }
>
>
>
> /\*\*
>
> \* rotate bits right treating input as byte
>
> \* [param](https://habrahabr.ru/users/param/) value 0 <= value <=255
>
> \* [param](https://habrahabr.ru/users/param/) n number of bits to shift
>
> \* [return](https://habrahabr.ru/users/return/)
>
> \*/
>
> public static int ror(int value, int n)
>
> {
>
> return ((value >> (n % BITS\_IN\_BYTE)) | ((value << (8 — (n % BITS\_IN\_BYTE))) & 0xFF));
>
> }
>
> }
>
>
>
> Людям не знакомым с java скажу сразу, что не стоит пугаться многочисленных вставок `& 0xFF`. Это всего лишь конвертация signed byte в unsigned путем преобразования его в int и применения такой вот битовой маски. А всё потому, что **в java нет unsigned типов! Совсем!** Ну да ладно, это не смертельно.
>
>
>
> Вся красивость тут заключается в формировании раундовой соли, поэтому основное внимание будет уделяться ей.
>
>
>
> Немного о переменных:
>
> * **res** — массив из 32 байт для SHA-256 или 64 байт для SHA-512. В нем хранится результат хеширования
> * **roundSaltSize** — размер раундовой соли. 4 байта для SHA-256 и 8 байт для SHA-512
> * **temp** — массив из элементов размера массива res плюс размер раундовой соли roundSaltSize
> * **s\_primeIndices** — массив индексов элементов в массиве res, начиная с которых мы будем вычислять соответствующий байт раундовой соли. То есть, начинать вычисления первого байта раундовой соли для SHA-256 мы будем с res[7], второго с res[11] и т.д. Для SHA-512 будут задействованы все индексы
> * **btemp** — байт, который после серии хитрых преобразований станет на своё место в раундовой соли
>
>
>
> Еще одна ремарка прежде чем мы перейдем к разъяснениям формирования алгоритма раундовой соли. Весь алгоритм не является результатом каких либо научных исследований и тестов. Он создан для формирования значения, которое было бы зависимо от некоторых байтов результирующего хэша и помогло бы его замедлить и усложнить. Ну а теперь описание:
>
>
>
> 1. В начале в массив toHash собираются основная соль и пароль
> 2. Массив toHash хешируется и результат запоминается в массиве res. Всё, про основную соль и пароль забыли
> 3. Запускаем длинный цикл в 0x50000 итераций
> 4. Далее работаем с массивом temp, в который копируем массив res. В конце массива temp еще остается 4 или 8 байт для соли. Нам предстоит их заполнить
> 5. Для каждого из байтов раундовой соли:
> 6. Запоминаем в btmp элемент, который находится по одному из индексов (7, 11, 17… ) в зависимости от номера текущего байта (j)
> 7. Затем 7(k) раз делаем следующее:
> 8. Берем остаток от деления btmp, у которого биты сдвинуты вправо на k позиций, на длину массива res
> 9. предыдущее число используем как индекс для массива res, вытаскиваем число по этому индексу
> 10. btmp присваиваем это число, сложенное с btmp по модулю 256 и прокрученное вправо на 8-k бит
> 11. Помещаем btmp на своё место после хэша в массиве temp
> 12. Хэшируем temp
>
>
>
> Вызов этого метода выглядит следующим образом:
>
>
>
>
> > byte[] salt = new byte[16];
> >
> > new SecureRandom().nextBytes(salt); // generate random 16byte salt
> >
> > byte[] hashedPassword = new SlowHasher().calculateSlowHash(new SHA256(), password, salt);
> >
> >
> >
> >
>
>
>
>
>
> В результате получится хэш(хэш(хэш+ранудовая соль)+раундовая соль)… который можно использовать как 256 битный ключ шифрования важной информации для AES-256, например.
>
>
>
> На моей машине (C2D 2.6) на генерацию одного хэша приходится около 0.25 секунды, что я считаю приемлемым для использования. в своих проектах. Можно увеличить число раундов и тогда время соответственно вырастет.
>
>
>
> Если уважаемой публике будет интересно, то я могу рассказать и о других прикладных аспектах работы с библиотекой BouncyCastle как то симметричное\ассиметричное шифрование, генерация сертификатов и т.д.
>
>
>
> **UPD:**
>
> В комментах [указали](http://people.redhat.com/drepper/SHA-crypt.txt) ссылку на доку, в которой такого рода схема принимает еще больший размах | https://habr.com/ru/post/100138/ | null | ru | null |
# Особенности программного ProxyChanging'а в Android. Часть 1: от Jelly Bean до Lollipop
Как-то раз, для собственного удобства, мне захотелось написать приложение, которое меняет настройки прокси в конфигурации сетей Wifi для Android. Задача, как мне тогда показалось, была на раз плюнуть, однако, на деле, как всегда, возникли непредвиденные сложности.
Если вы считаете полезным в будущем знать решение, хотите почерпнуть что-то для себя или в вас просто проснулось любопытство — добро пожаловать под кат. Там вас ждет внутреннее устройство классов отвечающих за конфигурацию Wifi в различных версиях Android, небольшая чашечка кода на Java и щепотка Reflection.
Немного общения с Google на тему «change wifi proxy settings in android programmatically» привели, разумеется, на StackOverflow, где присутствовало решение через Reflection. Недолго думая я скопировал код и запустил на своем девайсе.
**Результат**
Разочарование быстро сменилось интересом и азартом, примерно на этом моменте автор решил, что уже потратил слишком много времени, для того, чтобы просто забить на вышеуказанный вопрос, а так же понял, что данная задача требует более глобального подхода. Итак, поехали.
#### Шаг 1. Изучаем внутреннее устройство библиотеки android.net и отличия в Jelly Bean — Kitkat и Lollipop
**Список вещей, которые желательно знать для лучшего понимания происходящего ниже*** Your English level must be, at least, pre-intermediate.
* У вас не должно возникать вопросов «Что такое *Context*?» и аналогичных по сложности, если же он возник на этом моменте — можете почитать [developer.android.com](https://developer.android.com/training/basics/firstapp/index.html) или [Александра Климова](http://developer.alexanderklimov.ru/android/)
* Так же не должны вызывать смущения аннотации *@Before*, *@Test*, *@After* и прочие вещи относящиеся к тестированию. Опять же, ссылка: [developer.android.com](https://developer.android.com/training/testing/start/index.html)
Я бы с удовольствием разобрал все это, но сами понимаете — тогда моя статья вырастет в книгу.
Также я хотел бы дать еще несколько общих уточнений:
* Вы почти не встретите комментариев в моем коде. Я долго размышлял над этим вопросом и очень долго сомневался, но, в конце концов, решил просто дать его девушке, которая вообще не знает java, и, после коротких пояснений, что такое *class*, *void*, *throws*, *exception* она смогла, прочтя несколько классов, весьма точно сказать, что происходит в них и их методах, потому я почти отказался от них.
* Если у вас есть комментарии, дополнения, вопросы, замечания (например, по предыдущему пункту) — автор их очень ждет.
* Статья на данный момент очень обобщена, опять же, если вы хотите увидеть некоторые моменты подробнее, то в зависимости от объема работ я напишу комментарий или, возможно, отдельную статью на заинтересовавшую вас тему.
* В коде нет импортов, ибо имя пакета содержит в себе ник вашего покорного слуги, а им, судя по правилам, нельзя светить в статье для песочницы.
Еще немного вопросов в Google привели меня на [android.googlesource](https://android.googlesource.com/platform/frameworks/base/+refs)
Настройки прокси (а так же некоторые другие) заключены в экземпляре *WifiConfiguration* (Ссылка на [класс для Kitkat mr2.2](https://android.googlesource.com/platform/frameworks/base/+/kitkat-mr2.2-release/wifi/java/android/net/wifi/WifiConfiguration.java)) для данной сети. При изучении данного класса был получен ответ на то, почему не работало на моем устройстве решение со StackOverflow. Оказалось, что начиная с пятой версии Android устройство класса *WifiConfiguration*, а так же пакета *android.net* претерпели значительные изменения и объекта [*LinkPropeties*](https://android.googlesource.com/platform/frameworks/base/+/kitkat-mr2.2-release/core/java/android/net/LinkProperties.java), с которым работал вышеуказанный код просто не существует в рамках данного класса. Зато присутствует объект [*IpConfiguraion*](https://android.googlesource.com/platform/frameworks/base/+/lollipop-release/core/java/android/net/IpConfiguration.java) с объектом [*ProxyInfo*](https://android.googlesource.com/platform/frameworks/base/+/lollipop-release/core/java/android/net/ProxyInfo.java).
Учитывая что данные версии Android покрывали 80% различных устройств, то задача сводилась к тому, чтобы просто написать нечто такое:
```
public void changeProxySettings(String host, int port){
if(Build.VERSION.SDK_INT > 14 && Build.VERSION.SDK_INT < 20){
changeProxyWithLikProperties(String host, int port);
}else if(Build.VERSION.SDK_INT > 20 && Build.VERSION.SDK_INT < 23){
changeProxyWithProxyInfo(String host, int port);
}else{
throw new Exception("Sorry, android version not supported")
}
}
```
где *changeProxyXXX* — монструозные методы, на пару страниц. Не самое изящное решение.
#### Шаг 2. Разрабатываем библиотеку для настройки Wifi proxy в Android
Итак, автор решил не останавливаться на громоздком классе с кучей методов. Свободное время имеется (безвременный отпуск по случаю сокращения финансирования проекта в котором я участвовал), так почему бы не поработать над задачей глобальнее.
##### Архитектура модуля
Мы имеем различные реализации под разные версии Android, у которых должен быть единый интерфейс для изменения настроек прокси, и работающие с объектом *WifiConfiguration*. Стараясь максимально удовлетворить данным требованиям, на начальном этапе мое воспаленное сознание придумало нечто такое:
**Поясняющий комментарий к картинке выше*** Класс *BaseWifiConfiguration*, по сути, хранит объект *WifiConfiguration* и содержит реализацию взятия конфигурации той сети, которая является текущей, при создании через *Context*.
* Интерфейс *ProxyChanger*, соответственно, гарантирует наличие методов для работы с конфигурацией прокси сети.
* Нам предстоит работа с Reflection, и желательно вынести основные методы для этого в отдельный класс, так как использоваться они будут часто. Поэтому создаем класс *ReflectionHelper*.
Классы для разных версий Android наследуются от *BaseWifiConfiguration* дабы иметь легкий доступ к экземпляру *WifiConfiguration* интересующей нас сети и облегчить работу с ним, и должны иметь реализации методов объявленных в *ProxyChanger*.
**PS**Я не спорю, что это, быть может, не лучшее архитектурное решение и, если у Вас есть предложения по улучшению или какие-то замечания, — с радостью жду их в комментариях.
Например, меня очень интересует ReflectionHelper, как видите, он объявлен абстрактным, сделано это из соображений того, что он не должен иметь конкретных реализаций и используется только для структуризации и легкого доступа к интересующим нас методам. Я не знаю насколько правилен этот подход, так что если у вас есть комментарий по данному вопросу (или каким-то другим) — я буду премного благодарен его услышать.
Разумеется, это только общий каркас и, спустя несколько итераций рефакторинга, он обрастет новыми подробностями.
##### Тесты
Итак, мы подумали над архитектурой, настало время написать пару строчек кода. Разумеется, не рабочего, а тестирующего наш проект.
Создаем небольшой класс, который будет отвечать за выбор ProxyChanger'а под конкретный api, класс для работы с вышеозначенным объектом в плане изменения конфигурации прокси и еще один, для взятия информации о настройках текущей сети, достаем пару телефонов и начинаем.
**WifiProxyChangerTest.java**
```
@RunWith(AndroidJUnit4.class)
public class WifiProxyChangerTest {
@Rule
public ExpectedException expectedException = ExpectedException.none();
@Rule
public ActivityTestRule mActivityRule = new ActivityTestRule<>(
MainActivity.class);
Context context;
@Before
public void prepare() throws Exception {
context = mActivityRule.getActivity();
ExceptionsPreparer.prepareExceptions(expectedException, context);
}
@Test
public void testChangeWifiStaticProxySettings() throws Exception {
String testIp = RandomValuesGenerator.randomIp();
int testPort = RandomValuesGenerator.randomPort();
WifiProxyChanger.changeWifiStaticProxySettings(testIp, testPort, context);
assertEquals(testIp, WifiProxyInfo.getHost(context));
assertEquals(testPort, WifiProxyInfo.getPort(context));
}
@Test
public void testProxySettingsClear() throws Exception {
String testIp = RandomValuesGenerator.randomIp();
int testPort = RandomValuesGenerator.randomPort();
WifiProxyChanger.changeWifiStaticProxySettings(testIp, testPort, context);
WifiProxyChanger.clearProxySettings(context);
assertEquals(ProxySettings.NONE, CurrentProxyChangerGetter
.chooseProxyChangerForCurrentApi(context)
.getProxySettings());
}
@After
public void сlearSettings() throws Exception {
if (NetworkHelper.isWifiConnected(context) && ApiChecker.isSupportedApi())
WifiProxyChanger.clearProxySettings(context);
}
}
```
**WifiProxyInfoTest.java**
```
@RunWith(AndroidJUnit4.class)
public class WifiProxyInfoTest {
@Rule
public ExpectedException expectedException = ExpectedException.none();
@Rule
public ActivityTestRule mActivityRule = new ActivityTestRule<>(
MainActivity.class);
Context context;
@Before
public void prepareAndPresetProxy() throws Exception {
context = mActivityRule.getActivity();
ExceptionsPreparer.prepareExceptions(expectedException, context);
if (ApiChecker.isSupportedApi()) {
WifiProxyChanger.clearProxySettings(context);
WifiProxyChanger.changeWifiStaticProxySettings("localhost", 3030, context);
}
}
@Test
public void testGetHost() throws Exception {
assertEquals("localhost", WifiProxyInfo.getHost(context));
}
@Test
public void testGetPort() throws Exception {
assertEquals(3030, WifiProxyInfo.getPort(context));
}
@Test
public void testGetProxySettings() throws Exception {
assertEquals(ProxySettings.STATIC, WifiProxyInfo.getProxySettings(context));
}
@After
public void сlearSettings() throws Exception {
if (NetworkHelper.isWifiConnected(context) && ApiChecker.isSupportedApi())
WifiProxyChanger.clearProxySettings(context);
}
}
```
**CurrentProxyChangerGetterTest .java**
```
@RunWith(AndroidJUnit4.class)
public class CurrentProxyChangerGetterTest {
@Rule
public ExpectedException expectedException = ExpectedException.none();
@Rule
public ActivityTestRule mActivityRule = new ActivityTestRule<>(
MainActivity.class);
Context context;
@Before
public void prepare() throws Exception {
context = mActivityRule.getActivity();
ExceptionsPreparer.prepareExceptions(expectedException, context);
}
@Test
public void testChooseProxyChangerForCurrentApi() throws Exception {
ProxyChanger proxyChanger = CurrentProxyChangerGetter.chooseProxyChangerForCurrentApi(context);
WifiManager manager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
assertEquals(manager.getConnectionInfo().getNetworkId(), proxyChanger.getWifiConfiguration().networkId);
if (ApiChecker.isJellyBeanOrKitkat()) {
assertTrue(proxyChanger instanceof WifiConfigurationForApiFrom15To19);
} else if (ApiChecker.isLolipop()) {
assertTrue(proxyChanger instanceof WifiConfigurationForApiFrom21To22);
}
}
}
```
**ExceptionsPreparer.java**
```
public abstract class ExceptionsPreparer {
public static void prepareExceptions(ExpectedException expectedException, Context context) throws Exception {
if (!ApiChecker.isSupportedApi()) {
expectedException.expect(ApiNotSupportedException.class);
} else if (!NetworkHelper.isWifiConnected(context)) {
expectedException.expect(NullWifiConfigurationException.class);
} else if (!CurrentProxyChangerGetter.chooseProxyChangerForCurrentApi(context).isProxySetted()) {
expectedException.expect(WifiProxyNotSettedException.class);
}
}
}
```
**Комментарий к коду, объясняющий, откуда там куча непонятных вещей про которые я не упомянул.**Я думаю, после прочтения возникли резонные вопросы: Что это за *«ProxySettings.STATIC»*, и за что он отвечает, откуда взялись Exceptions, которые тоже ранее не упоминались, и так далее.
Дело в том, что изначальной версии, к сожалению, у меня не осталось, и в bitbucket наличествуют только уже прошедшие несколько итераций рефакторинга тестовые классы.
Запуск тестов оканчивается провалом, теперь нужно это как-то исправить.
#### Шаг 3. Реализация
Наконец, продумав что писать и сделав все необходимые приготовления мы можем приступить к реализации нашего проекта.
##### Часть первая: Подготовительные работы и вспомогательные классы
###### Для начала — приступим к нашей обещанной щепотке Reflection
**Чуть-чуть о Reflection api**
> Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine.
>
> Oracle Java Turtorial
Класс, но что конкретно можно с этим сделать?
**Небольшой пример**Пусть у нас есть маленькая библиотека, в ней пара классов для взятия веб страницы и ее сохранения. Я хочу подключить ее «на лету» и использовать. Напишем для этого небольшой класс:
```
public class LibLoader {
//Я искренне прошу прощения за этот код, писал за 2 минуты для примера.
URLClassLoader urlClassLoader;
String page;
LibLoader(File myJar) throws MalformedURLException {
urlClassLoader = new URLClassLoader(new URL[]{myJar.toURL()}, this.getClass().getClassLoader());
}
public void loadPage(URL url) throws Exception {
Class classToLoad = Class.forName("com.company.HtmlPageGetter", true, urlClassLoader);
Method method = classToLoad.getDeclaredMethod("getPageFromURL", URL.class);
Object instance = classToLoad.newInstance();
Object result = method.invoke(instance, url);
page = (String) result;
}
public String getCurrentPage() {
return page;
}
public void saveCurrentPage(String name) throws Exception {
List content = new ArrayList<>();
content.add(page);
Class classToLoad = Class.forName("com.company.HtmlPageSaver", true, urlClassLoader);
Method method = classToLoad.getDeclaredMethod("savePageToFile", String.class, List.class);
Object instance = classToLoad.newInstance();
method.invoke(instance, name, content);
}
}
```
Теперь используем его:
```
public static void main(String[] args) throws Exception {
File lib = new File("htmlgetandsave.jar");
LibLoader libLoader = new LibLoader(lib);
libLoader.loadPage(new URL("https://habrahabr.ru/post/69552/"));
System.out.println(libLoader.getCurrentPage());
libLoader.saveCurrentPage("Статья с хабра - Делаем reflection быстрой как прямые вызовы ");
}
```
Запускаем и наслаждаемся результатом:
Более того, мы могли вообще знать только расположение файла библиотеки и не знать ничего о ее структуре, Reflection api позволило бы изучить этот вопрос прямо в рантайме, и использовать ее после этого.
Однако для нас сейчас важно то, что помимо прочего, благодаря Reflection мы можем получить доступ к приватным полям и методам, а так же помеченным аннотацией *hide*.
Итак, пишем уже упомянутый выше *ReflectionHelper*.
**ReflectionHelper.java**
```
public abstract class ReflectionHelper {
/**
* Used for getting public fields with @hide annotation
*/
public static Object getField(Object object, String name)
throws SecurityException, NoSuchFieldException, IllegalArgumentException,
IllegalAccessException {
Field field = object.getClass().getField(name);
return field.get(object);
}
/**
* Used for getting private fields
*/
public static Object getDeclaredField(Object object, String name)
throws SecurityException, NoSuchFieldException, IllegalArgumentException,
IllegalAccessException {
Field declaredField = object.getClass().getDeclaredField(name);
declaredField.setAccessible(true);
return declaredField.get(object);
}
/**
* Used for setting private fields
*/
public static void setDeclaredField(Object object, String name, Object value)
throws NoSuchFieldException, IllegalAccessException {
Field declaredField = object.getClass().getDeclaredField(name);
declaredField.setAccessible(true);
declaredField.set(object, value);
}
/**
* Used for setting Enum fields
*/
public static void setEnumField(Object object, String value, String name)
throws SecurityException, NoSuchFieldException, IllegalArgumentException,
IllegalAccessException {
Field field = object.getClass().getField(name);
field.set(object, Enum.valueOf((Class) field.getType(), value));
}
/\*\*
\* Used for simplifying process of invoking private method
\* Automatically detects args types and founds method to get and invoke
\*/
public static Object getMethodAndInvokeIt(Object object, String methodName, Object... args)
throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
Method method = object.getClass().getDeclaredMethod(methodName, parameterTypes(args));
method.setAccessible(true);
return method.invoke(object, args);
}
private static Class[] parameterTypes(Object... args) {
ArrayList classes = new ArrayList<>();
for (Object arg : args) {
classes.add(arg.getClass());
}
return classes.toArray(new Class[args.length]);
}
}
```
Здесь я все же поставил себе памятки, ибо, например, разницу между *getField* и *getDeclaredField* и в каких случаях какой использовать — можно легко забыть.
Большая часть работы с Reflection перенесена в отдельный класс, займемся реализацией остальных частей.
###### Создаем Exceptions на 3 случая:
* Неподходящая версия Api. Соответствующий класс:
```
public class ApiNotSupportedException extends Exception {
public ApiNotSupportedException() {
super("Api version not supported");
}
}
```
* Попытка создания объекта с не заданной конфигурацией Wifi (Например, пользователь пытается с отключенным wifi изменить параметры прокси текущей сети):
```
public class NullWifiConfigurationException extends Exception {
public NullWifiConfigurationException(){
super("WiFi configuration was null. \n" +
"If you are trying to change current network settings - check your connection.");
}
}
```
* Не определен объект для настроек прокси в текущем классе WifiConfiguration:
```
public class WifiProxyNotSettedException extends IllegalStateException{
public WifiProxyNotSettedException(){
super("Wifi proxy not setted for current WifiConfiguration");
}
}
```
###### Реализуем класс служащий базовым для подклассов работающих с *WifiConfiguration* под различными api:
**BaseWifiConfiguration.java**
```
public class BaseWifiConfiguration {
protected WifiConfiguration wifiConfiguration;
protected BaseWifiConfiguration(WifiConfiguration wifiConfiguration)
throws NullWifiConfigurationException {
if (wifiConfiguration == null)
throw new NullWifiConfigurationException();
this.wifiConfiguration = wifiConfiguration;
}
protected BaseWifiConfiguration(Context context)
throws NullWifiConfigurationException {
this(getCurrentWifiConfigurationFromContext(context));
}
public WifiConfiguration getWifiConfiguration() {
return wifiConfiguration;
}
private static WifiConfiguration getCurrentWifiConfigurationFromContext(Context context) {
final WifiManager manager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
List wifiConfigurationList = manager.getConfiguredNetworks();
if (!manager.isWifiEnabled() || wifiConfigurationList == null || wifiConfigurationList.isEmpty())
return null;
return findWifiConfigurationByNetworkId(wifiConfigurationList, manager.getConnectionInfo().getNetworkId());
}
private static WifiConfiguration findWifiConfigurationByNetworkId(List wifiConfigurationList, int networkId) {
for (WifiConfiguration wifiConf : wifiConfigurationList) {
if (wifiConf.networkId == networkId)
return wifiConf;
}
return null;
}
}
```
###### Объявляем интерфейс *ProxyChanger*
**ProxyChanger.java**
```
public interface ProxyChanger {
void setProxySettings(ProxySettings proxySettings)
throws NoSuchFieldException, IllegalAccessException;
ProxySettings getProxySettings()
throws NoSuchFieldException, IllegalAccessException;
void setProxyHostAndPort(String host, int port)
throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException,
InstantiationException, IllegalAccessException, NoSuchFieldException;
String getProxyHost()
throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
ApiNotSupportedException, NoSuchFieldException;
int getProxyPort()
throws ApiNotSupportedException, NoSuchMethodException, IllegalAccessException,
InvocationTargetException, NoSuchFieldException;
boolean isProxySetted()
throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
ApiNotSupportedException, NoSuchFieldException;
WifiConfiguration getWifiConfiguration();
}
```
Да, списки Exception'ов при использовании Reflection — это нечто.
Вроде все? А, нет, есть еще один маленький подпункт:
###### ProxySettings.java — что это вообще такое и зачем оно нужно?
Это аналог перечисления, находящегося в классе *WifiConfiguration* библиотеки Android. Мы создаем его за тем, чтобы облегчить работу с ним и не прописывать каждый раз *STATIC*, *NONE* и прочие вручную.
**ProxySettings.java**
```
public enum ProxySettings {
/* No proxy is to be used. Any existing proxy settings
* should be cleared. */
NONE("NONE"),
/* Use statically configured proxy. Configuration can be accessed
* with httpProxy. */
STATIC("STATIC"),
/* no proxy details are assigned, this is used to indicate
* that any existing proxy settings should be retained */
UNASSIGNED("UNASSIGNED"),
/* Use a Pac based proxy.
*/
PAC("PAC");
String value = "";
ProxySettings(String value) {
this.value = value;
}
public String getValue() {
return value;
}
}
```
##### Часть вторая: Пишем классы реализующие *ProxyChanger* под конкретные Api
Итак, настало время написать наконец тот самый код, который будет менять наши настройки прокси. Сразу оговорюсь, что есть разнообразные способы, чтобы добраться до них через Reflection: можно вызывать методы класса *WifiConfiguration*, можно добираться до, собственно, полей, где они находятся и через *setDeclaredField* менять их напрямую.
Я написал только часть для работы с текущей сетью (ибо это то, в чем нуждался автор), т.е. с созданием экземпляров классов через *Context*, однако, наша архитектура позволяет добавлением буквально нескольких строк адаптировать данные классы для работы с произвольным объектом *WifiConfiguration*.
###### Kitkat и Jelly Bean
Как уже говорилось в шаге 1, в данных версиях Android за хранение настроек Proxy отвечает объект *ProxyProperties*, хранящийся в *LinkProperties*, который в свою очередь находится в *WifiConfiguration*. Да, да, игла в яйце, яйцо в утке, утка в зайце и так далее.
Для того, чтобы изменить настройки прокси создадим новый экземпляр *ProxyProperties* с нужными нам параметрами, затем заменить данным объектом уже имеющийся и после этого настроить *ProxySettings*.
За создание экземпляров *ProxyProperties* будет отвечать отдельный класс:
**ProxyPropertiesConstructor.java**
```
public abstract class ProxyPropertiesConstructor {
public static Object proxyProperties(String host, int port)
throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException,
InstantiationException, IllegalAccessException {
return proxyProperties(host, port, null);
}
public static Object proxyProperties(String host, int port, String exclList)
throws NoSuchMethodException, ClassNotFoundException, IllegalAccessException,
InvocationTargetException, InstantiationException {
return proxyPropertiesConstructor().newInstance(host, port, exclList);
}
private static Constructor proxyPropertiesConstructor()
throws ClassNotFoundException, NoSuchMethodException {
return Class.forName("android.net.ProxyProperties").getConstructor(String.class, int.class, String.class);
}
}
```
Для удобной работы с данным объектом также создадим класс-контейнер, содержащий объект *ProxyProperties* и предоставляющий доступ к основным полям (и позволяющий удобно создавать его сразу через host и порт):
**ProxyPropertiesContainer.java**
```
public class ProxyPropertiesContainer {
Object proxyProperties;
ProxyPropertiesContainer(Object proxyProperties) {
this.proxyProperties = proxyProperties;
}
ProxyPropertiesContainer(String host, int port)
throws ClassNotFoundException, NoSuchMethodException, InstantiationException,
IllegalAccessException, InvocationTargetException {
this(host, port, null);
}
ProxyPropertiesContainer(String host, int port, String exclList)
throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException,
InstantiationException, IllegalAccessException {
this(ProxyPropertiesConstructor.proxyProperties(host, port, exclList));
}
public String getHost()
throws NoSuchFieldException, IllegalAccessException {
return (String) ReflectionHelper.getDeclaredField(proxyProperties, "mHost");
}
public int getPort()
throws NoSuchFieldException, IllegalAccessException {
return (int) ReflectionHelper.getDeclaredField(proxyProperties, "mPort");
}
public String getExclusionList()
throws NoSuchFieldException, IllegalAccessException {
return (String) ReflectionHelper.getDeclaredField(proxyProperties, "mExclusionList");
}
public Object getProxyProperties() {
return proxyProperties;
}
}
```
Теперь пишем реализацию собственно класса:
**WifiConfigurationForApiFrom15To19.java**
```
public class WifiConfigurationForApiFrom15To19 extends BaseWifiConfiguration implements ProxyChanger {
private ProxyPropertiesContainer proxyPropertiesContainer;
public WifiConfigurationForApiFrom15To19(Context context)
throws NoSuchFieldException, IllegalAccessException, NullWifiConfigurationException {
super(context);
this.proxyPropertiesContainer = new ProxyPropertiesContainer(getCurrentProxyProperties());
}
public static WifiConfigurationForApiFrom15To19 createFromCurrentContext(Context context)
throws NoSuchFieldException, IllegalAccessException, NullWifiConfigurationException {
return new WifiConfigurationForApiFrom15To19(context);
}
@Override
public void setProxySettings(ProxySettings proxySettings)
throws NoSuchFieldException, IllegalAccessException {
ReflectionHelper.setEnumField(wifiConfiguration, proxySettings.getValue(), "proxySettings");
}
@Override
public ProxySettings getProxySettings()
throws NoSuchFieldException, IllegalAccessException {
return ProxySettings.valueOf(String.valueOf(ReflectionHelper.getDeclaredField(wifiConfiguration, "proxySettings")));
}
@Override
public void setProxyHostAndPort(String host, int port)
throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException,
InstantiationException, IllegalAccessException, NoSuchFieldException {
proxyPropertiesContainer = new ProxyPropertiesContainer(host, port);
ReflectionHelper.getMethodAndInvokeIt(
getLinkProperties(),
"setHttpProxy",
proxyPropertiesContainer.getProxyProperties());
}
@Override
public String getProxyHost()
throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
ApiNotSupportedException, NoSuchFieldException {
if (proxyPropertiesContainer == null)
throw new WifiProxyNotSettedException();
return proxyPropertiesContainer.getHost();
}
@Override
public int getProxyPort()
throws ApiNotSupportedException, NoSuchMethodException, IllegalAccessException,
InvocationTargetException, NoSuchFieldException {
if (proxyPropertiesContainer == null)
throw new WifiProxyNotSettedException();
return proxyPropertiesContainer.getPort();
}
@Override
public boolean isProxySetted()
throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
ApiNotSupportedException, NoSuchFieldException {
return !(proxyPropertiesContainer == null);
}
private LinkProperties getLinkProperties()
throws NoSuchFieldException, IllegalAccessException {
return (LinkProperties) ReflectionHelper.getField(wifiConfiguration, "linkProperties");
}
private Object getCurrentProxyProperties()
throws NoSuchFieldException, IllegalAccessException {
return ReflectionHelper.getDeclaredField(getLinkProperties(), "mHttpProxy");
}
}
```
C этой версией закончили, остался:
###### Lollipop
Опять же, апеллируя к шагу 1, можно сделать вывод, что настройки прокси в данной версии Api находятся в классе *ProxyInfo*, содержащемся в *IpConfiguration*, который в свою очередь имеет своим местом дислокации наш *WifiConfiguration*. *ProxySettings* — тоже переехал, теперь он в вышеупомянутом *IpConfiguration*.
Напишем класс, делающий новые экземпляры ProxyInfo по заданным параметрам.
**ProxyInfoConstructor.java**
```
public abstract class ProxyInfoConstructor {
public static ProxyInfo proxyInfo(String host, int port)
throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException,
InvocationTargetException, InstantiationException {
return proxyInfo(host, port, null);
}
public static ProxyInfo proxyInfo(String host, int port, String exclude)
throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException,
InvocationTargetException, InstantiationException {
Object newProxyInfo = proxyInfoConstructor().newInstance(host, port, exclude);
return (ProxyInfo) newProxyInfo;
}
private static Constructor proxyInfoConstructor()
throws ClassNotFoundException, NoSuchMethodException {
return Class.forName("android.net.ProxyInfo").getConstructor(String.class, int.class, String.class);
}
}
```
Как видите, здесь мы уже возвращаем не Object'ы, а именно экземпляры *ProxyInfo*, более того, далее будет видно, что у этого класса есть еще и методы *getHost* и *getPort*. В предыдущем случае мы этого сделать не могли, класс *ProxyProperties* был спрятан, именно поэтому мы писали для него «оболочку».
И, собственно, код для еще одной реализации:
**WifiConfigurationForApiFrom21To22.java**
```
public class WifiConfigurationForApiFrom21To22 extends BaseWifiConfiguration implements ProxyChanger {
public WifiConfigurationForApiFrom21To22(Context context)
throws NullWifiConfigurationException {
super(context);
}
public static WifiConfigurationForApiFrom21To22 createFromCurrentContext(Context context)
throws NullWifiConfigurationException {
return new WifiConfigurationForApiFrom21To22(context);
}
@Override
public ProxySettings getProxySettings()
throws NoSuchFieldException, IllegalAccessException {
return ProxySettings.valueOf(String.valueOf(ReflectionHelper.getDeclaredField(getIpConfigurationObject(), "proxySettings")));
}
@Override
public void setProxySettings(ProxySettings proxySettings)
throws NoSuchFieldException, IllegalAccessException {
ReflectionHelper.setEnumField(getIpConfigurationObject(), proxySettings.getValue(), "proxySettings");
}
@Override
public void setProxyHostAndPort(String host, int port)
throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException,
InstantiationException, IllegalAccessException, NoSuchFieldException {
setProxyInfo(ProxyInfoConstructor.proxyInfo(host, port));
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
@Override
public String getProxyHost()
throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
ApiNotSupportedException {
ProxyInfo info = getProxyInfo();
if (info == null)
throw new WifiProxyNotSettedException();
return info.getHost();
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
@Override
public int getProxyPort()
throws ApiNotSupportedException, NoSuchMethodException, IllegalAccessException,
InvocationTargetException {
ProxyInfo info = getProxyInfo();
if (info == null)
throw new WifiProxyNotSettedException();
return info.getPort();
}
@Override
public boolean isProxySetted()
throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
ApiNotSupportedException, NoSuchFieldException {
return !(getProxyInfo() == null);
}
private Object getIpConfigurationObject()
throws NoSuchFieldException, IllegalAccessException {
return ReflectionHelper.getDeclaredField(wifiConfiguration, "mIpConfiguration");
}
private ProxyInfo getProxyInfo()
throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
return (ProxyInfo) ReflectionHelper.getMethodAndInvokeIt(wifiConfiguration, "getHttpProxy");
}
private void setProxyInfo(ProxyInfo proxyInfo)
throws NoSuchMethodException, InvocationTargetException, IllegalAccessException,
NoSuchFieldException {
ReflectionHelper.getMethodAndInvokeIt(wifiConfiguration, "setHttpProxy", proxyInfo);
}
}
```
С основной реализацией на этом все. До финиша осталось совсем чуть-чуть.
#### Шаг 4. Предстартовая подготовка
Реализуем классы, упоминавшиеся ранее в тестах (замечание: мы реализуем настройку прокси по IP и порту, соответственно тип *ProxySettings* — *STATIC*.)
**CurrentProxyChangerGetter.java**
```
public abstract class CurrentProxyChangerGetter {
public static ProxyChanger chooseProxyChangerForCurrentApi(Context context)
throws ApiNotSupportedException, NoSuchFieldException, IllegalAccessException,
NullWifiConfigurationException {
if (ApiChecker.isJellyBeanOrKitkat()) {
return WifiConfigurationForApiFrom15To19.createFromCurrentContext(context);
} else if (ApiChecker.isLolipop()) {
return WifiConfigurationForApiFrom21To22.createFromCurrentContext(context);
} else {
throw new ApiNotSupportedException();
}
}
}
```
**WifiProxyChanger.java**
```
public abstract class WifiProxyChanger {
public static void changeWifiStaticProxySettings(String host, int port, Context context)
throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException,
InstantiationException, IllegalAccessException, NoSuchFieldException,
ApiNotSupportedException, NullWifiConfigurationException {
updateWifiWithNewConfiguration(
getCurrentWifiConfiguretionWithUpdatedSettings(host, port, ProxySettings.STATIC, context),
context);
}
public static void clearProxySettings(Context context)
throws IllegalAccessException, ApiNotSupportedException, NoSuchFieldException,
NullWifiConfigurationException, ClassNotFoundException, NoSuchMethodException,
InstantiationException, InvocationTargetException {
updateWifiWithNewConfiguration(
getCurrentWifiConfiguretionWithUpdatedSettings("", 0, ProxySettings.NONE, context),
context);
}
private static WifiConfiguration getCurrentWifiConfiguretionWithUpdatedSettings(String host, int port, ProxySettings proxySettings, Context context)
throws ApiNotSupportedException, IllegalAccessException, NullWifiConfigurationException,
NoSuchFieldException, ClassNotFoundException, NoSuchMethodException,
InstantiationException, InvocationTargetException {
ProxyChanger proxyChanger = CurrentProxyChangerGetter.chooseProxyChangerForCurrentApi(context);
proxyChanger.setProxyHostAndPort(host, port);
proxyChanger.setProxySettings(proxySettings);
return proxyChanger.getWifiConfiguration();
}
private static void updateWifiWithNewConfiguration(WifiConfiguration wifiConfiguration, Context context) {
WifiManager currentWifiManager = NetworkHelper.getWifiManager(context);
currentWifiManager.updateNetwork(wifiConfiguration);
currentWifiManager.saveConfiguration();
currentWifiManager.reconnect();
}
}
```
**WifiProxyInfo.java**
```
public abstract class WifiProxyInfo {
public static String getHost(Context context)
throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
ApiNotSupportedException, NoSuchFieldException, NullWifiConfigurationException {
return CurrentProxyChangerGetter.chooseProxyChangerForCurrentApi(context).getProxyHost();
}
public static int getPort(Context context)
throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
ApiNotSupportedException, NoSuchFieldException, NullWifiConfigurationException {
return CurrentProxyChangerGetter.chooseProxyChangerForCurrentApi(context).getProxyPort();
}
public static ProxySettings getProxySettings(Context context)
throws ApiNotSupportedException, IllegalAccessException, NoSuchFieldException,
NullWifiConfigurationException {
return CurrentProxyChangerGetter.chooseProxyChangerForCurrentApi(context).getProxySettings();
}
}
```
Реализуем вспомогательный класс для проверки версии API:
**ApiChecker.java**
```
public abstract class ApiChecker {
public static boolean isJellyBeanOrKitkat() {
return Build.VERSION.SDK_INT > 14 && Build.VERSION.SDK_INT < 20;
}
public static boolean isLolipop() {
return Build.VERSION.SDK_INT > 20 && Build.VERSION.SDK_INT < 23;
}
public static boolean isSupportedApi() {
return isJellyBeanOrKitkat() || isLolipop();
}
}
```
#### ЗАПУСКАЕМ ТЕСТЫ
(прошу прощения, но это такой момент, что я решился выделить его заголовком)
…
Шампанское! Вино! Народные гулянья! Аплодисменты! Queen — We are the champions в качестве музыкального сопровождения!
**Небольшой комментарий**Разумеется, автор запускал тесты до этого момента несколько десятков раз и созерцал ошибки в огромных количествах. А иногда ему приходилось править и криво написанные тестовые сценарии, в которых была допущена какая-нибудь пустяковая ошибка, типа пропущенного *"!"*. Но, так как к моменту написания статьи код уже был по 10 раз отрефакторен, переотрефакторен и выотрефакторен, то почему бы не позволить себе немного приукрасить действительность.
#### Шаг 5. Наслаждаемся плодами нашей деятельности
Подключаем библиотеку к приложению созданному по умолчанию и проверяем результат:
**MainActivity.java**
```
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
changeProxySettings("myhost.com", 12345);
}
void changeProxySettings(String host, int port) {
try {
WifiProxyChanger.changeWifiStaticProxySettings(host, port, this);
} catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | InvocationTargetException | NoSuchFieldException | IllegalAccessException | NullWifiConfigurationException | ApiNotSupportedException e) {
e.printStackTrace();
}
}
}
```
Запускаем. На экране приложения мы ничего интересного не увидим, потому сразу идем в настройки wifi сети к которой мы подключены.
**Результат. Картинка великовата.**
Результат достигнут.
#### Подведение итогов
На данный момент мы получили рабочую, легко расширяемую библиотеку, которую уже можно использовать для изменения настроек прокси wifi сетей в указанных выше версиях Android.
Дальнейшие планы? Да у автора их целый список!
* Разумеется, нужно добавить поддержку Marshmallow, как раз появился новый телефон под управлением данной версии Android (и чувствую, что работа с новой системой разрешений будет той еще задачей).
* Хочется так же изучить вопрос, касающийся настроек для мобильной сети.
* Возможно, стоит доработать библиотеку для полноценного изменения конфигурации Wifi сетей. *WifiConfiguration* — класс большой и интересный, и, быть может, скоро в библиотеке появится интерфейс *IpSettingsChanger*, а с ним — и новая статья.
* И, разумеется, нужно нормально оформить readme и прочие вещи на Bitbucket.
И, разумеется это далеко не все.
**Post scriptum и еще немного комментариев автора**» Если вы заинтересовались ссылкой на библиотеку, дабы посмотреть, что она являет собой в текущем состоянии, то по запросу в комментариях я прикреплю ссылку на Bitbucket (либо оставлю в комментах).
» Если вас интересует какие либо подробности — автору можно свободно писать, он всегда рад общению с умными людьми.
» Если вы внезапно осознали, что вашему проекту будет полезен функционал реализованный или близкий к данному, и вам захочется использовать сии наработки — пожалуйста.
Спасибо за интерес к статье, искренне ваш, «Nickname, который нельзя оставить в песочнице» | https://habr.com/ru/post/311388/ | null | ru | null |
# Многопоточность в C++ и SObjectizer с CSP-шными каналами, но совсем без акторов…
Раньше мы рассказывали про [SObjectizer](https://habrahabr.ru/post/304386/) как про акторный фреймворк для C++, хотя в действительности это не совсем так. Например, уже давно в SObjectizer есть такая классная штука, как [mchain-ы](https://www.slideshare.net/YauheniAkhotnikau/dive-into-sobjectizer-55-ninth-part-message-chains) (они же каналы из модели [CSP](https://en.wikipedia.org/wiki/Communicating_sequential_processes)). Mchain-ы позволяют легко и непринужденно организовать обмен данными между рабочими потоками. Не создавая агентов, которые нужны далеко не всегда. Как раз на днях довелось в очередной раз этой фичей воспользоваться и упростить себе жизнь за счет передачи данных между потоками посредством каналов (т.е. SObjectizer-овских mchain-ов). Так что не только в Go можно получать удовольствие от использования CSP. В C++ это так же возможно. Кому интересно, что и как, прошу под кат.
Задача была следующей: есть некая сторонняя система, к которой нужно делать синхронные запросы. Нужно было посмотреть, как ведет себя эта система, если запросы к ней идут не в один поток, а в несколько. Для этого следовало сделать из имевшегося однопоточного многопоточного клиента, рабочие нити которого выдавали бы свой поток запросов к сторонней системе.
Полный список запросов, которые подлежали выполнению, находился в отдельном файле. Так что нужно было последовательно читать этот файл, доставать очередной запрос и отдавать его одной из свободных рабочих нитей. Каждая нить подсчитывала количество выполненных запросов. Нужно было определить, сколько времени потребуется на вычитку и обработку всех запросов, а так же подсчитать, сколько всего запросов было выполнено.
Очевидным образом напрашивалось простое решение. Есть главная рабочая нить, которая читает файл с запросами. Каждый запрос ставиться в общую очередь запросов. Откуда запросы разбираются рабочими нитями. Т.е. рабочая нить берет из очереди первый запрос, выполняет его, затем берет новый первый запрос из очереди и т.д. Если очередь пуста, то рабочая нить должна приостанавливаться до тех пор, пока что-то в очереди появится. Если очень заполнена, то должна приостанавливаться главная нить пока в очереди не появится свободное место.
[Mchain-ы из SObjectizer-а](https://sourceforge.net/p/sobjectizer/wiki/so-5.5%20In-depth%20-%20Message%20chains/) как раз позволяют обойтись без написания своих thread-safe очередей.
Для решения этой задачи потребовалось два mchain-а. Первый mchain используется для передачи прочитанных запросов рабочим нитям. Главная нить пишет в него запросы,
рабочие нити читают запросы оттуда. Когда файл с запросами вычитан полностью, главная нить просто закрывает этот mchain. Соответственно, как только рабочие потоки увидят, что в mchain-е ничего нет и он закрыт, они завершат свою работу.
Второй mchain потребовался для того, чтобы рабочие нити смогли передать в главную нить информацию о том, что они заверили свою работу и сколько запросов они при этом обработали. В этот mchain рабочие нити пишут всего по одному сообщению. А главная нить только читает из этого mchain-а.
Ну и теперь можно посмотреть, как все это выглядит в коде. Код без комментариев, т.к. это была одноразовая программулина «на выброс». Посему необходимые пояснения будут приводится после соответствующего куска кода.
Начнем с функции run\_app, которая вызывается из main() сразу после того, как программа разберет параметры командной строки:
```
void
run_app( const app_args_t & args )
{
so_5::wrapped_env_t sobj(
[]( so_5::environment_t & ) {},
[]( so_5::environment_params_t & params ) {
params.infrastructure_factory(
so_5::env_infrastructures::simple_mtsafe::factory() );
} );
auto tasks_ch = create_mchain( sobj,
std::chrono::seconds(5),
50,
so_5::mchain_props::memory_usage_t::preallocated,
so_5::mchain_props::overflow_reaction_t::abort_app );
auto finish_ack_ch = create_mchain( sobj );
std::vector< std::thread > workers;
const auto cleanup = cpp_util_3::at_scope_exit( [&] {
so_5::close_drop_content( finish_ack_ch );
so_5::close_drop_content( tasks_ch );
for( auto & t : workers )
t.join();
} );
cpp_util_3::n_times( args.m_threads_count, [&] {
workers.emplace_back( [&] {
worker_thread( args, tasks_ch, finish_ack_ch );
} );
} );
do_main_work( args, tasks_ch, finish_ack_ch );
}
```
Здесь сперва создается экземпляр SObjectizer Environment, которому будут принадлежать mchain-ы. Не имея SOEnvironment нельзя создать mchain, так что SOEnvironment приходится создавать.
Но нам не нужен полноценный SOEnvironment, который предназначен для создания тучи агентов в приложении, для эффективного управления которыми SOEnvironment вынужден создавать несколько собственных вспомогательных нитей. Поэтому в параметрах SOEnvironment мы задаем использовать [специальный, однопоточный вариант SObjectizer-а](https://sourceforge.net/p/sobjectizer/wiki/so-5.5.19%20Environment%20Infrastructure/). В этом случае wrapped\_env\_t создаст одну вспомогательную нить, на которой произойдет вызов so\_5::launch() и все. Больше SObjectizer ничего делать не будет. Да и эта вспомогательная нить будет спать в so\_5::launch() до тех пор, пока не произойдет возврат из run\_app.
Далее нам нужен mchain для раздачи запросов рабочим нитям. Это tasks\_ch. Но это не простой mchain. Во-первых, это mchain ограниченной емкости. Попытка добавить в заполненный mchain еще одно сообщение будет блокировать текущую нить. Но блокировать не навсегда, а всего на 5 секунд. Если же даже спустя 5 секунд в mchain-е свободного места не окажется, то все приложение будет прервано вызовом std::abort(). В данном случае это оправдано, т.к. в нормальных условиях ни одна из рабочих нитей не должна засыпать больше чем на несколько миллисекунд, не говоря уже про 5 секунд. Так что если за 5 секунд в tasks\_ch не появилось свободного места, то что-то точно идет не так, поэтому нужно звать std::abort(). Кроме того, поскольку tasks\_ch у нас имеет заранее известный размер, то мы предписываем сразу выделить необходимую память под всю очередь сообщений в mchain-е.
Со вторым mchain-ом, в который рабочие нити будут отсылать сообщения finish\_ack, все гораздо проще. Поэтому finish\_ack\_ch создается простым вызовом create\_mchain, с параметрами по умолчанию (безразмерный mchain без блокировки на операциях send).
Далее нам нужно запустить N рабочих нитей и сохранить их в векторе workers. Но здесь не так все просто. Мы можем получить исключение при создании очередной рабочей нити. При этом нам было бы полезно нормально завершить те нити, которые уже были созданы.
Чтобы упростить себе жизнь с откатом ранее выполненных операций, используется аналог D-шного scope\_exit (ну или аналог BOOST\_SCOPE\_EXIT или Go-шного defer, тут уж кому что ближе). Переменная cleanup, по сути, представляет из себя объект с лямбдой внутри. Эта лямбда вызывается при вызове деструктора переменной cleanup. Создается cleanup средствами небольшой вспомогательной библиотеки [cpp\_util](https://bitbucket.org/sobjectizerteam/cpp_util-3.0). Еще одно пояснение по поводу cleanup-а: первое, что нам нужно сделать при очистке — это закрыть mchain-ы. Если какая-то из рабочих нитей уже успела стартовать и уснуть на вызове receive из tasks\_ch, то закрытие tasks\_ch в cleanup сразу же разбудит эту нить и позволит ей завершить свою работу.
Ну а далее мы создаем рабочие нити и вызываем do\_main\_work. Внутри do\_main\_work выполняется основная работа главной нити приложения: чтение файла с запросами, передача запросов рабочим нитям, сбор результатов. Вот как выглядит упрощенный вариант do\_main\_work, из которого убрали второстепенные детали:
```
void
do_main_work(
const app_args_t & args,
so_5::mchain_t tasks_ch,
so_5::mchain_t finish_ack_ch )
{
data_file_handler_t file{
args.m_data_file,
args.m_force_keep_alive
};
const auto started_at = hires_clock::now();
while( !file.is_eof() )
{
auto request = file.get_next_request();
if( !request )
break;
so_5::send< std::string >( tasks_ch, *request );
}
so_5::close_retain_content( tasks_ch );
unsigned long long total_requests{};
so_5::receive( from(finish_ack_ch).handle_n( args.m_threads_count ),
[&]( const finish_ack_t & what ) {
total_requests += what.m_requests;
} );
const auto total_time = hires_clock::now() - started_at;
if( total_requests )
{
... // Print the results...
}
}
```
Все самое интересное здесь собрано в двух местах.
Во-первых, внутри while. Там последовательно читаются запросы из файла и передаются рабочим нитям посредством вызова send. Если send вызывается когда tasks\_ch полностью заполнен, то главная нить будет приостановлена (но не более, чем на 5 секунд).
Во-вторых, когда весь файл с запросами прочитан, нам нужно дождаться ответов от всех рабочих нитей. Для этого мы сперва закрываем tasks\_ch, чтобы рабочие нити поняли, что пора завершать свою работу. Но закрывать нужно так, чтобы не потерялись те запросы, которые уже стоят в очереди, но еще не были обработаны. Поэтому вызывается close\_retain\_content (а вот для cleanup-действия в run\_app была задействована close\_drop\_content, т.к. там нам не нужно ничего сохранять в закрываемом канале).
После того, как tasks\_ch закрыт, нужно дождаться ответа от N рабочих нитей. Вот это ожидание ровно N ответов записывается одной магической строкой:
```
so_5::receive( from(finish_ack_ch).handle_n( args.m_threads_count ),
```
Она говорит буквально следующее: читать из канала finish\_ack\_ch до тех пор пока не будет прочитано и обработано ровно threads\_count сообщений.
Ну и для завершения картины нужно показать как выглядит код рабочей нити. Он совсем простой:
```
void
worker_thread(
const app_args_t & args,
so_5::mchain_t tasks_ch,
so_5::mchain_t finish_ack_ch )
{
io_performer_t io_performer{ args.m_srv, args.m_port };
unsigned long long total_requests{};
so_5::receive( from(tasks_ch),
[&]( const std::string & request ) {
io_performer.request_response( request );
++total_requests;
} );
so_5::send< finish_ack_t >( finish_ack_ch, total_requests );
}
```
Нить просто висит внутри receive из канала tasks\_ch. Возврат из receive произойдет при закрытии tasks\_ch. Если же tasks\_ch пуст, то receive будет спать до тех пор,
пока в канал что-то поступит (либо пока канал не закроют). А когда возврат из receive происходит, то рабочая нить просто отсылает finish\_ack-сообщение в finish\_ack\_ch и завершается.
Вот, собственно, и все.
Надо сказать, что с самой многопоточностью и обменом информацией между потоками проблем не было. Буквально с первого раза завелось и заработало. Проблемы возникли внутри реализации io\_performer\_t::request\_response, когда из-за ошибок в реализации взаимодействия между клиентом и сервером подвисала текущая нить. Вот тогда и помогло ограничение в 5 секунд на время ожидания записи в полный tasks\_ch: когда нити начинали зависать, срабатывал тайм-аут и многопоточный клиент аварийно завершался. Сразу становилось понятно, что есть баг, причем баг в request\_response, т.к. только зависание там и могло остановить нормальное чтение из tasks\_ch.
В завершение хочется сказать, что и Модель Акторов, и Модель Взаимодействующих Последовательных Процессов (aka CSP) — отличные штуки. Где-то хорошо работает одна, где-то вторая. [SObjectizer](https://sourceforge.net/projects/sobjectizer/) позволяет использовать и то, и другое. А то и все сразу, иногда и такое бывает необходимо. | https://habr.com/ru/post/336854/ | null | ru | null |
# Основы и заблуждения насчет JavaScript
#### Объекты, классы, конструкторы
> ECMAScript, будучи высоко-абстрактным объектно-ориентированным языком программирования, оперирует объектами. Существуют также и примитивы, но и они, когда требуется, также преобразуются в объекты. Объект — это коллекция свойств, имеющая также связанный с ней объект-прототип. Прототипом является либо также объект, или же значение null.
В JavaScript нет привычных классов, но есть функции-конструкторы, порождающие объекты по определенным алгоритмам (см. Оператор new).
#### Прототипное делегирующее наследование
Классическое наследование очень похоже на то, как люди наследуют гены своих предков. Есть какие-то базовые особенности: люди могут ходить, говорить… И есть характерные черты для для каждого человека. Люди не в состоянии изменить себя — свой класс (но могут поменять собственные свойства) и бабушки, дедушки, мамы и папы не могут динамически повлиять на гены детей и внуков. Все очень по земному.
Теперь представим другую планету, на которой не такое как на Земле генное наследование. Там обитают мутанты с «телепатическим наследованием», которые способны изменять гены своих потомков.
Разберем пример. Отец наследует гены от Дедушки, а Сын наследует гены от Отца, который наследует от Дедушки. Каждый мутант может свободно мутировать, и может менять гены своих потомков. Например у Дедушки был зеленый цвет кожи, Отец цвет унаследовал, Сын тоже унаследовал цвет. И вдруг Дед решил: «надоело мне ходить зеленым — хочу стать сними», смутировал (изменил прототип своего класса) и «телепатически» распространил эту мутацию Отцу и Сыну, вобщем посинели все. Тут Отец подумал: «Дед на старости лет совсем двинулся» и поменял свой цвет в генах обратно на зеленый(изменил прототип своего класса), и распространил «телепатически» свой цвет сыну. Отец и Сын зеленые, Дед синий. Теперь как бы дед ни старался Отец и сын цвет не поменяют, т.к сейчас Отец в своем прототипе прописал цвет, а Сын в первую очередь унаследует от Прототипа Отца. Теперь Сын решает: «Поменяю ка я свой цвет на черный, а моё потомство пусть наследует цвет от Отца» и прописал собственное свойство, которое не влияет на потомство. И так далее.
Опишем все в коде:
```
var Grandfather = function () {}; // Конструктор Grandfather
Grandfather.prototype.color = 'green';
var Father = function () {}; // Конструктор Father
Father.prototype = new Grandfather(); // Это простой, но не самый лучший вариант протитипного наследования
var Son = function () {}; // Конструктор Son
Son.prototype = new Father(); // Аналогично
var u = new Grandfather(); // Экземпляр "класса" Grandfather
var f = new Father(); // Экземпляр "класса" Father
var s = new Son(); // Экземпляр "класса" Son
// Изначально все зеленые
console.log([u.color, f.color, s.color]); // ["green", "green", "green"]
// Дед решил поменять свой цвет и цвет потомства
Grandfather.prototype.color = 'blue';
console.log([u.color, f.color, s.color]); // ["blue", "blue", "blue"]
// Отец решил все вернуть для себя и своего потомства
Father.prototype.color = 'green';
// Хотя мог исделать и так:
// Grandfather.prototype.color = 'green';
console.log([u.color, f.color, s.color]); // ["blue", "green", "green"]
// Смысла нет
Grandfather.prototype.color = 'blue';
console.log([u.color, f.color, s.color]); // ["blue", "green", "green"]
// Сын решил не брать пример с Деда и поменял только собственное свойство
s.color = 'black'; // Меняем собственное свойство, которое не затрагивает цепочку прототипов
console.log([u.color, f.color, s.color]); // ["blue", "green", "black"]
var SonsSon = function () {}; // Конструктор SonsSon
SonsSon.prototype = new Son(); // Аналогично
var ss = new SonsSon(); // Экземпляр "класса" SonsSon
// Сын сына унаследовал от Отца
console.log([u.color, f.color, s.color, ss.color]); // ["blue", "green", "black", "green"]
```
Почитать:
[ООП в Javascript: наследование](http://javascript.ru/tutorial/object/inheritance)
[Разбираемся с prototype, \_\_proto\_\_, constructor и их цепочками в картинках](http://habrahabr.ru/blogs/javascript/108915/)
#### Цепочка прототипов, получение свойства с заданными именем
> Цепь прототипов (prototype chain) — это конечная цепь объектов, которая используется для организации наследования и разделяемых (shared) свойств.
В JavaScript каждый объект имеет собственные свойства (Own Properties) и ссылку на объект-прототип, в свою очередь прототип тоже имеет собственные свойства и ссылку на прототип, прототип прототипа тоже имеет собственные свойства и ссылку на прототип ну и так далее, пока ссылка на прототип не будет null — эта структура называется цепочка прототипов.
При попытке обратиться к свойству объекта (через точку или скобки) выполняется поиск указателя по имени: сперва проверяется есть ли указатель с таком-то именем с списке собственных свойств (если есть, то возвращается), если его нет, то идет поиск в собственном прототипе (если есть, то возвращается), если его нет, то идет поиск в прототипе прототипа и так далее, пока прототип прототипа не станет null в этом случае возвращается undefined.
Некоторые реализации JavaScript используют свойство \_\_proto\_\_ для представления следующего объекта в цепочке прототипов.
Поиск свойства на чтение можно описать следующей функцией:
```
function getProperty(obj, prop) {
if (obj.hasOwnProperty(prop))
return obj[prop]
else if (obj.__proto__ !== null)
return getProperty(obj.__proto__, prop)
else
return undefined
}
```
Для примера рассмотри простой класс Point 2D, содержащий 2 свойства (x, y) и метод print. Используя, определения выше — построим объект.
```
var Point = {
x: 0,
y: 0,
print: function () {
console.log(this.x, this.y);
}
};
var p = {x: 10, __proto__: Point};
// Свойство 'x' нашлось в свобственных свойствах:
/* p.x */ getProperty(p, 'x'); // 10
// Свойство 'y' нашлось по ссылке __proto__ в объекте-прототипе Point
/* p.y */ getProperty(p, 'y'); // 0
// Метод print нашелся по ссылке __proto__ в объекте-прототипе Point
/* p.print() */ getProperty(p, 'print').call(p); // 10 0
```
*Почему я использовал `call`, а не вызвал полученную функции напрямую, описано ниже.*
На самом деле `Point` имеет ещё одно свйоство, да это наша ссылка на прототип родителя `__proto__`, которая в случае `Point` указывает на `Object.prototype`.
Например, вот так будет выглядеть вся цепочка пртотипов в самом первом примере:
```
/* SonsSon <- Son <---- Father <- Grandfather <-- Object <-- null */
console.log(ss.__proto__.__proto__.__proto__.__proto__.__proto__.__proto__ === null);
```
#### \_\_proto\_\_, prototype, оператор new
Выше был «низкоуровневый код», теперь посмотрим как все работает в жизни:
```
function Point(x, y) { // Конструктор Point
this.x = x;
this.y = y;
}
Point.prototype = { // Прототип конструктора
print: function () { console.log(this.x, this.y); }
};
var p = new Point(10, 20); // Создаем новый объект
p.print(); // 10 20
```
Если в предыдущем коде мы хотя бы знали, что куда ссылается, в этом все как-то запутанно.
Вся «магия» кроется в операторе new. Brendan Eich (создатель JavaScript) захотел, чтобы JavaScript был похож на традиционные ОО языки, такие как C++, Java, поэтому был добавлен оператор new. Посмотрим как же он работает.
Оператор new получает в свое распоряжение функцию и аргументы функции (`new F(arguments...)`) и выполняет следующие действия:
1. Создает пустой объект с единственным свойством `__proto__`, которое ссылается на `F.prototype`
2. Выполняет конструктор `F` в котором `this` — созданный ранее объект
3. Возвращает объект
Создадим функцию `New`, эмулирующую поведение оператора `new`:
```
function New (F, args) {
/*1*/ var n = {'__proto__': F.prototype};
/*2*/ F.apply(n, args);
/*3*/ return n;
}
```
Изменим предыдущий пример с Point:
```
function Point(x, y) { // Конструктор Point
this.x = x;
this.y = y;
}
Point.prototype = { // Прототип конструктора
print: function () { console.log(this.x, this.y); }
};
var p1 = new Point(10, 20);
p1.print(); // 10 20
console.log(p1 instanceof Point); // true
// Это аналогично:
var p2 = New(Point, [10, 20]);
p2.print(); // 10 20
console.log(p2 instanceof Point); // true
```
#### Построение цепочки прототипов
В самом первом примере я строил цепочку прототипов, используя вот такую конструкцию `Father.prototype = new Grandfather()`:
```
var Grandfather = function () {}; // Конструктор Grandfather
Grandfather.prototype.color = 'green';
var Father = function () {}; // Конструктор Father
Father.prototype = new Grandfather(); // Это простой, но не самый лучший вариант протитипного наследования
var Son = function () {}; // Конструктор Son
Son.prototype = new Father(); // Аналогично
```
Теперь мы знаем поведение оператора new и можем понять, что тут делается — развернем `new Grandfather()`:
```
Father.prototype = {
__proto__: { // Прототип Grandfather
color: 'green',
__proto__: Object.prototype
}
};
```
Теперь при вызове `new Father()` мы получим вот такой объект (сразу развернем объект):
```
Son.prototype = {
__proto__: { // Прототип Father
__proto__: { // Прототип Grandfather
color: 'green',
__proto__: Object.prototype
}
}
}
```
Давайте посмотрим, что мы имеем в конце кода в объекте s (экземпляр Son)
```
{
color: 'black', // Сын поменял только собственное свойство
__proto__: { // Прототип Son
__proto__: { // Прототип Father
color: 'green', // Отец решил вернуть цвет
__proto__: { // Прототип Grandfather
color: 'blue', // Дед решил поменять на синий
__proto__: Object.prototype
}
}
}
}
```
Почему же `Father.prototype = new Grandfather()` не самый лучший вариант построения цепочки прототипов?
Потому, что нам приходится вызывать конструктор `Grandfather`, который может подмешать лишние свойства и вызвать лишние методы, например `alert`. Для обхода этой проблемы используют подставной конструктор:
```
function inherit (object, parent) {
function F(){}; // Подставной конструктор
F.prototype = parent.prototype; // Подсовываем прототип реального конструктора
object.prototype = new F(); // Теперь реальный конструктор не будет выполнен
return object; // Можно и не возвращать
};
```
Пример использования:
```
var Grandfather = function () {}; // Конструктор Grandfather
Grandfather.prototype.color = 'green';
var Father = function () {}; // Конструктор Father
inherit(Father, Grandfather); // Это лучше
```
Конструктор `Grandfather` не будет выполнен. Если нам все-такие необходимо выполнить конструктор Grandfather, то вызываем его с помошью call или appy
```
var Father = function () { // Конструктор Father
Grandfather.call(this);
};
```
#### Оператор instanceof
```
if (p instanceof Point) {
// ...
}
```
Оператор `instanceof` очень тесно связан с цепочной прототипов. Он использует именно цепочку прототипов для вынесения вердикта, а не проверяет порожден ли данный объект «p» конструктором «Point». В этом моменте часто бывает путаница.
Оператор `instanceof` оперирует двумя объектами — obj и constructor: (`obj instanceof constructor`). Он начиная с constructor.prototype, пробегает по цепочке прототипов и проверяет следующее равенство `obj.__proto__ === constructor.prototype`, если оно истинное, то возвращает true.
Опишем в коде:
```
function isInstanceOf(obj, constructor) {
if (obj.__proto__ === constructor.prototype)
return true;
else if (obj.__proto__ !== null)
return isInstanceOf(obj.__proto__, constructor)
else
return false
}
```
Рассмотрим пример выше:
```
function Point(x, y) { // Конструктор Point
this.x = x;
this.y = y;
}
Point.prototype = { // Прототип конструктора
print: function () { console.log(this.x, this.y); }
};
var p = new Point(10, 20); // Создаем новый объект
/* {} instanceof Object */ console.log(isInstanceOf({}, Object)); // true
/* p instanceof Point */ console.log(isInstanceOf(p, Point)); // true
/* p instanceof Object */ console.log(isInstanceOf(p, Object)); // true потому, что Object есть в цепи прототипов (Point.__proto__ === Object.prototype)
/* p instanceof Array */ console.log(isInstanceOf(p, Array)); // false потому, что Array нет в цепочке прототипов
```
#### Свойство this
this это одно большое заблуждение.
> Многие привыкли, что ключевое слово this в языках программирования тесно связано с объектно-ориентированным программированием, а именно, указывает на текущий порождаемый конструктором объект. В ECMAScript this не ограничивается лишь определением порождаемого объекта.
В JavaScript значение this определяется вызывающей стороной по форме вызова. Правило по которому определяется то, что будет в this такое (объясню по-простому):
1. Если метод вызывается напрямую (без `new, call, apply, bind, with, try catch`), то значением this будет тот объект, который стоит перед точкой, слева от имени метода.
2. Если точки нет (функция вызывается напрямую), то this будет приравнен к undefined, null или window(global), в зависимости от среды и «use strict».
3. Если выражение представляет из себя не ссылку, а значение, то применяется пункт 2
Пример:
```
var foo = {
bar: function () {
console.log(this);
}
};
var bar = foo.bar;
bar(); // this === global (2)
foo.bar(); // this === foo (1)
(foo.bar)(); // this === foo скобки ничего не меняют (1)
// Все выражения слева от скобок вызова - значения
(foo.bar = foo.bar)(); // this === global (3)
(false || foo.bar)(); // this === global (3)
(foo.bar, foo.bar)(); // this === global (3)
function foo() {
function bar() {
console.log(this);
}
bar(); // this === global (2)
}
```
Вспомним пример с `getProperty(p, 'print').call(p)` именно из-за этого правила я вручную указал значение this. Иначе функция print получила бы в качестве this — window.
Вот эти операторы и методы способны управлять значением `this: new, call, apply, bind, with, try catch` (с ними более-менее все понятно, не буду затрагивать).
Подробнее о this:
[Тонкости ECMA-262-3. Часть 3: This](http://dmitrysoshnikov.com/ecmascript/ru-chapter-3-this/)
#### undefined, null, void
null — примитивное значение, представляющее нулевую, пустую, не существующую ссылку
undefined — примитивное значение, которое получает каждая перемененная по умолчанию (когда переменная не имеет значение)
void — это оператор (т.е. при вызове его скобки не нужны), выполняющий выражение и всегда возвращающий undefined
#### Заключение
1. В JavaScript нет классов — есть конструкторы
2. Цепь прототипов — база на которую опирается все наследование в JavaScript
3. Свойство объекта получается с использованием цепи прототипов
4. \_\_proto\_\_ — это ссылка на прототип конструктора(prototype)
5. Оператор new создает пустой объект с единственным свойством \_\_proto\_\_, которое ссылается на F.prototype, выполняет конструктор F в котором this — созданный ранее объект и возвращает объект
6. Оператор instanceof не проверяет порожден ли данный объект «Object» конструктором «ObjectsConstoructor», для своего вердикта он использует цепь прототипов
7. В JavaScript значение this определяется вызывающей стороной по форме вызова
8. void — это оператор, а не функция. undefined, null — примитивные значения
**Важно** В некоторых реализациях JavaScript нельзя напрямую менять [\_\_proto\_\_](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Object/proto), к тому же это свойство не стандартное и уже устаревшее. Для получения ссылки на прототип следует использовать [Object.getPrototypeOf](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Object/getPrototypeOf). В статье я применял его (\_\_proto\_\_) для демонстрации «внутренностей» ECMAScript.
#### В статье были использованы материалы
Статьи из [блога](http://dmitrysoshnikov.com/) Дмитрия Сошинкова [dsCode](https://habrahabr.ru/users/dscode/)
[How Prototypal Inheritance really works](http://blog.vjeux.com/2011/javascript/how-prototypal-inheritance-really-works.html) (Christopher Chedeau) | https://habr.com/ru/post/120193/ | null | ru | null |
# Обнаружение объектов с помощью YOLOv3 на Tensorflow 2.0
Кадр из аниме "Жрица и медведь"До появления YOLO большинство способов обнаружения объектов пытались адаптировать классификаторы для детекции. В YOLO же, обнаружение объектов было сформулировано как задача регрессии на пространственно разделенных ограничивающих рамок (*bounding boxes*) и связанных с ними вероятностей классов.
В данной статье мы узнаем о системе [YOLO Object Detection](http://datahacker.rs/object-detection-yolo-algorithm/) и как реализовать подобную систему в Tensorflow 2.0
> *О YOLO:*
>
> *Наша унифицированная архитектура чрезвычайно быстра. Базовая модель YOLO обрабатывает изображения в режиме реального времени со скоростью 45 кадров в секунду. Уменьшенная версия сети, Fast YOLO, обрабатывает аж 155 кадра в секунду…*
>
> *— You Only Look Once: Unified, Real-Time Object Detection, 2015*
>
>
### Что такое YOLO?
YOLO – это новейшая (на момент написания оригинальной статьи) система (сеть) обнаружения объектов. Она была разработана Джозефом Редмоном (Joseph Redmon). Наибольшим преимуществом YOLO над другими архитектурами является скорость. Модели семейства YOLO исключительно быстры и намного превосходят R-CNN (*Region-Based Convolutional Neural Network*) и другие модели. Это позволяет добиться обнаружения объектов в режиме реального времени.
На момент первой публикации (в 2016 году) по сравнению с другими системами, такими как R-CNN и DPM (*Deformable Part Model*), YOLO добилась передового значения mAP (*mean Average Precision*). С другой стороны, YOLO испытывает трудности с точной локализацией объектов. Однако в новой версии были внесены улучшения в скорости и точности системы.
**Альтернативы** (на момент публикации статьи): Другие архитектуры в основном использовали метод скользящего окна по всему изображению, и классификатор использовался для определенной области изображения (*DPM*). Также, R-CNN использовал метод предложения регионов (*region proposal method*). Описываемый метод сначала создает потенциальные [bounding box’ы](http://datahacker.rs/deep-learning-bounding-boxes/). Затем, на области, ограниченные bounding box’ами, запускается классификатор и следующее удаление повторяющихся распознаваний, и уточнение границ рамок.
YOLO переосмыслила задачу обнаружения объектов в задачу регрессии. Она идет от пикселей изображения к координатам bounding box’ов и вероятностей классов. Тем самым, единая сверточная сеть предсказывает несколько bounding box’ов и вероятности классов для содержания этих областей.
### Теория
Так как YOLO необходимо только один взгляд на изображение, то метод скользящего окна не подходит в данной ситуации. Вместо этого, изображение будет поделено на сетку с ячейками размером`S x S`. Каждая ячейка может содержать несколько разных объектов для распознавания.
Во-первых, каждая ячейка отвечает за прогнозирование количества bounding box’ов. Также, каждая ячейка прогнозирует доверительное значение (*confidence value*) для каждой области, ограниченной bounding box’ом. Иными словами, это значение определяет вероятность нахождения того или иного объекта в данной области. То есть в случае, если какая-то ячейка сетки не имеет определенного объекта, важно, чтобы доверительное значение для этой области было низким.
Когда мы визуализируем все предсказания, мы получаем карту объектов и упорядоченных по доверительному значению, рамки.
Во-вторых, каждая ячейка отвечает за предсказание вероятностей классов. Это не говорит о том, что какая-то ячейка содержит какой-то объект, только вероятность нахождения объекта. Допустим, если ячейка предсказывает автомобиль, это не гарантирует, что автомобиль в действительности присутствует в ней. Это говорит лишь о том, что если присутствует объект, то этот объект скорее всего автомобиль.
Давайте подробней опишем вывод модели.
В YOLO используются [anchor boxes](https://towardsdatascience.com/anchor-boxes-the-key-to-quality-object-detection-ddf9d612d4f9) (*якорные рамки / фиксированные рамки*) для прогнозирования bounding box’ов. Идея anchor box’ов сводится к предварительному определению двух различных форм. И таким образом, мы можем объединить два предсказания с двумя anchor box’ами (в целом, мы могли бы использовать даже большее количество anchor box’ов). Эти якоря были рассчитаны с помощью датасета [COCO](https://cocodataset.org/#home) (*Common Objects in Context*) и кластеризации [k-средних](https://ru.wikipedia.org/wiki/Метод_k-средних) (*K-means clustering*).
У нас есть сетка, где каждая ячейка предсказывает:
* Для каждого bounding box'а:
+ 4 координаты (tx , ty , tw , th)
+ 1 objectness error (*ошибка объектности*), которая является показателем уверенности в присутствии того или иного объекта
* Некоторое количество вероятностей классов
Если же присутствует некоторое смещение от верхнего левого угла на cx , cy то прогнозы будут соответствовать:
где pw (*ширина*) и ph (*высота*) соответствуют ширине и высоте bounding box'а. Вместо того, чтобы предугадывать смещение как в прошлой версии YOLOv2, авторы прогнозируют координаты местоположения относительно местоположения ячейки.
Этот вывод является выводом нашей нейронной сети. В общей сложности здесь`S x S x [B * (4+1+C)]` выводов, где `B` – это количество bounding box'ов, которое может предсказать ячейка на карте объектов, `C` – это количество классов, `4` – для bounding box'ов, `1` – для objectness prediction (*прогнозирование объектности*). За один проход мы можем пройти от входного изображения к выходному тензору, который соответствует обнаруженным объектам на картинке. Также стоит отметить, что YOLOv3 прогнозирует bounding box'ы в трех разных масштабах.
Теперь, если мы возьмем вероятность и умножим их на доверительные значения, мы получим все bounding box'ы, взвешенные по вероятности содержания этого объекта.
Простое нахождение порогового значения избавит нас от прогнозов с низким доверительным значением. Для следующего шага важно определить метрику [IoU](http://datahacker.rs/deep-learning-intersection-over-union/) (*Intersection over Union / Пересечение над объединением*). Эта метрика равняется соотношению площади пересекающихся областей к площади областей объединенных.
После этого все равно могут остаться дубликаты, и чтобы от них избавиться нужно использовать [“подавление не-максимумов”](http://datahacker.rs/deep-learning-intersection-over-union/) (*non-maximum suppression*). Подавление не-максимумов заключается в следующем: алгоритм берёт bounding box с наибольшей вероятностью принадлежности к объекту, затем, среди остальных граничащих bounding box'ов с данной области, возьмёт один с наивысшим IoU и подавляет его.
Ввиду того, что все делается за один прогон, эта модель будет работать почти также быстро, как и классификация. К тому же все обнаружения предсказываются одновременно, что означает, что модель неявно учитывает глобальный контекст. Проще говоря, модель может узнать какие объекты обычно встречаться вместе, их относительный размер и расположение объектов и так далее.
Yolov3Мы также рекомендуем прочитать следующие статьи о YOLO:
* [You Only Look Once: Unified, Real-Time Object Detection](https://arxiv.org/pdf/1506.02640.pdf)
* [YOLO9000: Better, Faster, Stronger](https://arxiv.org/pdf/1612.08242.pdf)
* [YOLOv3: An Incremental Improvement](https://pjreddie.com/media/files/papers/YOLOv3.pdf)
### Реализация в Tensorflow
Первым шагом в реализации YOLO это подготовка ноутбука и импортирование необходимых библиотек. Целиком ноутбук с кодом вы можете на [Github](https://github.com/gingermuffin/YOLOv3-Tensorflow) или [Kaggle](https://www.kaggle.com/anastasiakim/yolov3-tensorflow):
Следуя этой статье, мы сделаем полную сверточную сеть (*fully convolutional network / FCN*) без обучения. Для того, чтобы применить эту сеть для определения объектов, нам необходимо скачать готовые веса от предварительно обученной модели. Эти веса были получены от обучения YOLOv3 на датасете [COCO](https://cocodataset.org/#home) (*Common Objects in Context*). Файл с весами можно скачать по ссылке [официального сайта](https://pjreddie.com/media/files/yolov3.weights).
```
# Создаем папку для checkpoint'ов с весами.
# !mkdir checkpoints
# Скачиваем файл с весами для YOLOv3 с официального сайта.
# !wget https://pjreddie.com/media/files/yolov3.weights
# Импортируем необходимые библиотеки.
import cv2
import numpy as np
import tensorflow as tf
from absl import logging
from itertools import repeat
from PIL import Image
from tensorflow.keras import Model
from tensorflow.keras.layers import Add, Concatenate, Lambda
from tensorflow.keras.layers import Conv2D, Input, LeakyReLU
from tensorflow.keras.layers import MaxPool2D, UpSampling2D, ZeroPadding2D
from tensorflow.keras.regularizers import l2
from tensorflow.keras.losses import binary_crossentropy
from tensorflow.keras.losses import sparse_categorical_crossentropy
yolo_iou_threshold = 0.6 # Intersection Over Union (iou) threshold.
yolo_score_threshold = 0.6 # Score threshold.
weightyolov3 = 'yolov3.weights' # Путь до файла с весами.
size = 416 # Размер изображения.
checkpoints = 'checkpoints/yolov3.tf' # Путь до файла с checkpoint'ом.
num_classes = 80 # Количество классов в модели.
# Список слоев в YOLOv3 Fully Convolutional Network (FCN).
YOLO_V3_LAYERS = [
'yolo_darknet',
'yolo_conv_0',
'yolo_output_0',
'yolo_conv_1',
'yolo_output_1',
'yolo_conv_2',
'yolo_output_2'
]
```
По причине того, что порядок слоев в [Darknet](https://pjreddie.com/darknet/yolo/) (*open source NN framework*) и tf.keras разные, то загрузить веса с помощью чистого функционального API будет проблематично. В этом случае, наилучшим решением будет создание подмоделей в keras. TF Checkpoints рекомендованы для сохранения вложенных подмоделей и они официально поддерживаются Tensorflow.
```
# Функция для загрузки весов обученной модели.
def load_darknet_weights(model, weights_file):
wf = open(weights_file, 'rb')
major, minor, revision, seen, _ = np.fromfile(wf, dtype=np.int32, count=5)
layers = YOLO_V3_LAYERS
for layer_name in layers:
sub_model = model.get_layer(layer_name)
for i, layer in enumerate(sub_model.layers):
if not layer.name.startswith('conv2d'):
continue
batch_norm = None
if i + 1 < len(sub_model.layers) and \
sub_model.layers[i + 1].name.startswith('batch_norm'):
batch_norm = sub_model.layers[i + 1]
logging.info("{}/{} {}".format(
sub_model.name, layer.name, 'bn' if batch_norm else 'bias'))
filters = layer.filters
size = layer.kernel_size[0]
in_dim = layer.input_shape[-1]
if batch_norm is None:
conv_bias = np.fromfile(wf, dtype=np.float32, count=filters)
else:
bn_weights = np.fromfile(wf, dtype=np.float32, count=4*filters)
bn_weights = bn_weights.reshape((4, filters))[[1, 0, 2, 3]]
conv_shape = (filters, in_dim, size, size)
conv_weights = np.fromfile(wf, dtype=np.float32, count=np.product(conv_shape))
conv_weights = conv_weights.reshape(conv_shape).transpose([2, 3, 1, 0])
if batch_norm is None:
layer.set_weights([conv_weights, conv_bias])
else:
layer.set_weights([conv_weights])
batch_norm.set_weights(bn_weights)
assert len(wf.read()) == 0, 'failed to read weights'
wf.close()
```
На этом же этапе, мы должны определить функцию для расчета IoU. Мы используем [batch normalization](https://habr.com/ru/post/309302/) (*пакетная нормализация*) для нормализации результатов, чтобы ускорить обучение. Так как tf.keras.layers.BatchNormalization работает не очень хорошо для [трансферного обучения](https://habr.com/ru/company/binarydistrict/blog/428255/) (*transfer learning*), то мы используем другой подход.
```
# Функция для расчета IoU.
def interval_overlap(interval_1, interval_2):
x1, x2 = interval_1
x3, x4 = interval_2
if x3 < x1:
return 0 if x4 < x1 else (min(x2,x4) - x1)
else:
return 0 if x2 < x3 else (min(x2,x4) - x3)
def intersectionOverUnion(box1, box2):
intersect_w = interval_overlap([box1.xmin, box1.xmax], [box2.xmin, box2.xmax])
intersect_h = interval_overlap([box1.ymin, box1.ymax], [box2.ymin, box2.ymax])
intersect_area = intersect_w * intersect_h
w1, h1 = box1.xmax-box1.xmin, box1.ymax-box1.ymin
w2, h2 = box2.xmax-box2.xmin, box2.ymax-box2.ymin
union_area = w1*h1 + w2*h2 - intersect_area
return float(intersect_area) / union_area
class BatchNormalization(tf.keras.layers.BatchNormalization):
def call(self, x, training=False):
if training is None: training = tf.constant(False)
training = tf.logical_and(training, self.trainable)
return super().call(x, training)
# Определяем 3 anchor box'а для каждой ячейки.
yolo_anchors = np.array([(10, 13), (16, 30), (33, 23), (30, 61), (62, 45),
(59, 119), (116, 90), (156, 198), (373, 326)], np.float32) / 416
yolo_anchor_masks = np.array([[6, 7, 8], [3, 4, 5], [0, 1, 2]])
```
В каждом масштабе мы определяем 3 anchor box'а для каждой ячейки. В нашем случае если маска будет:
* 0, 1, 2 – означает, что будут использованы первые три якорные рамки
* 3, 4 ,5 – означает, что будут использованы четвертая, пятая и шестая
* 6, 7, 8 – означает, что будут использованы седьмая, восьмая, девятая
```
# Функция для отрисовки bounding box'ов.
def draw_outputs(img, outputs, class_names, white_list=None):
boxes, score, classes, nums = outputs
boxes, score, classes, nums = boxes[0], score[0], classes[0], nums[0]
wh = np.flip(img.shape[0:2])
for i in range(nums):
if class_names[int(classes[i])] not in white_list:
continue
x1y1 = tuple((np.array(boxes[i][0:2]) * wh).astype(np.int32))
x2y2 = tuple((np.array(boxes[i][2:4]) * wh).astype(np.int32))
img = cv2.rectangle(img, x1y1, x2y2, (255, 0, 0), 2)
img = cv2.putText(img, '{} {:.4f}'.format(
class_names[int(classes[i])], score[i]),
x1y1, cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 255), 2)
return img
```
Теперь пришло время для реализации YOLOv3. Идея заключается в том, чтобы использовать только сверточные слои. Так как их здесь 53, то самым простым способом является создание функции, в которую мы будем передавать важные параметры, меняющиеся от слоя к слою.
[Остаточные блоки](http://datahacker.rs/deep-learning-residual-networks/) (*Residual Blocks*) в диаграмме архитектуры YOLOv3 применяются для изучения признаков. Остаточный блок содержит в себе несколько сверточных слоев и дополнительные связи для обхода этих слоев.
Создавая нашу модель, мы строим нашу модель с помощью функционального API, который будет легко использовать. С его помощью мы можем без труда определить ветви в нашей архитектуре (*ResNet Block*) и делить слои внутри архитектуры.
```
def DarknetConv(x, filters, size, strides=1, batch_norm=True):
if strides == 1:
padding = 'same'
else:
x = ZeroPadding2D(((1, 0), (1, 0)))(x)
padding = 'valid'
x = Conv2D(filters=filters, kernel_size=size,
strides=strides, padding=padding,
use_bias=not batch_norm, kernel_regularizer=l2(0.0005))(x)
if batch_norm:
x = BatchNormalization()(x)
x = LeakyReLU(alpha=0.1)(x)
return x
def DarknetResidual(x, filters):
previous = x
x = DarknetConv(x, filters // 2, 1)
x = DarknetConv(x, filters, 3)
x = Add()([previous , x])
return x
def DarknetBlock(x, filters, blocks):
x = DarknetConv(x, filters, 3, strides=2)
for _ in repeat(None, blocks):
x = DarknetResidual(x, filters)
return x
def Darknet(name=None):
x = inputs = Input([None, None, 3])
x = DarknetConv(x, 32, 3)
x = DarknetBlock(x, 64, 1)
x = DarknetBlock(x, 128, 2)
x = x_36 = DarknetBlock(x, 256, 8)
x = x_61 = DarknetBlock(x, 512, 8)
x = DarknetBlock(x, 1024, 4)
return tf.keras.Model(inputs, (x_36, x_61, x), name=name)
def YoloConv(filters, name=None):
def yolo_conv(x_in):
if isinstance(x_in, tuple):
inputs = Input(x_in[0].shape[1:]), Input(x_in[1].shape[1:])
x, x_skip = inputs
x = DarknetConv(x, filters, 1)
x = UpSampling2D(2)(x)
x = Concatenate()([x, x_skip])
else:
x = inputs = Input(x_in.shape[1:])
x = DarknetConv(x, filters, 1)
x = DarknetConv(x, filters * 2, 3)
x = DarknetConv(x, filters, 1)
x = DarknetConv(x, filters * 2, 3)
x = DarknetConv(x, filters, 1)
return Model(inputs, x, name=name)(x_in)
return yolo_conv
def YoloOutput(filters, anchors, classes, name=None):
def yolo_output(x_in):
x = inputs = Input(x_in.shape[1:])
x = DarknetConv(x, filters * 2, 3)
x = DarknetConv(x, anchors * (classes + 5), 1, batch_norm=False)
x = Lambda(lambda x: tf.reshape(x, (-1, tf.shape(x)[1], tf.shape(x)[2],
anchors, classes + 5)))(x)
return tf.keras.Model(inputs, x, name=name)(x_in)
return yolo_output
def yolo_boxes(pred, anchors, classes):
grid_size = tf.shape(pred)[1]
box_xy, box_wh, score, class_probs = tf.split(pred, (2, 2, 1, classes), axis=-1)
box_xy = tf.sigmoid(box_xy)
score = tf.sigmoid(score)
class_probs = tf.sigmoid(class_probs)
pred_box = tf.concat((box_xy, box_wh), axis=-1)
grid = tf.meshgrid(tf.range(grid_size), tf.range(grid_size))
grid = tf.expand_dims(tf.stack(grid, axis=-1), axis=2)
box_xy = (box_xy + tf.cast(grid, tf.float32)) / tf.cast(grid_size, tf.float32)
box_wh = tf.exp(box_wh) * anchors
box_x1y1 = box_xy - box_wh / 2
box_x2y2 = box_xy + box_wh / 2
bbox = tf.concat([box_x1y1, box_x2y2], axis=-1)
return bbox, score, class_probs, pred_box
```
Теперь определим функцию подавления не-максимумов.
```
def nonMaximumSuppression(outputs, anchors, masks, classes):
boxes, conf, out_type = [], [], []
for output in outputs:
boxes.append(tf.reshape(output[0], (tf.shape(output[0])[0], -1, tf.shape(output[0])[-1])))
conf.append(tf.reshape(output[1], (tf.shape(output[1])[0], -1, tf.shape(output[1])[-1])))
out_type.append(tf.reshape(output[2], (tf.shape(output[2])[0], -1, tf.shape(output[2])[-1])))
bbox = tf.concat(boxes, axis=1)
confidence = tf.concat(conf, axis=1)
class_probs = tf.concat(out_type, axis=1)
scores = confidence * class_probs
boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression(
boxes=tf.reshape(bbox, (tf.shape(bbox)[0], -1, 1, 4)),
scores=tf.reshape(
scores, (tf.shape(scores)[0], -1, tf.shape(scores)[-1])),
max_output_size_per_class=100,
max_total_size=100,
iou_threshold=yolo_iou_threshold,
score_threshold=yolo_score_threshold)
return boxes, scores, classes, valid_detections
```
Основная функция:
```
def YoloV3(size=None, channels=3, anchors=yolo_anchors,
masks=yolo_anchor_masks, classes=80, training=False):
x = inputs = Input([size, size, channels])
x_36, x_61, x = Darknet(name='yolo_darknet')(x)
x = YoloConv(512, name='yolo_conv_0')(x)
output_0 = YoloOutput(512, len(masks[0]), classes, name='yolo_output_0')(x)
x = YoloConv(256, name='yolo_conv_1')((x, x_61))
output_1 = YoloOutput(256, len(masks[1]), classes, name='yolo_output_1')(x)
x = YoloConv(128, name='yolo_conv_2')((x, x_36))
output_2 = YoloOutput(128, len(masks[2]), classes, name='yolo_output_2')(x)
if training:
return Model(inputs, (output_0, output_1, output_2), name='yolov3')
boxes_0 = Lambda(lambda x: yolo_boxes(x, anchors[masks[0]], classes),
name='yolo_boxes_0')(output_0)
boxes_1 = Lambda(lambda x: yolo_boxes(x, anchors[masks[1]], classes),
name='yolo_boxes_1')(output_1)
boxes_2 = Lambda(lambda x: yolo_boxes(x, anchors[masks[2]], classes),
name='yolo_boxes_2')(output_2)
outputs = Lambda(lambda x: nonMaximumSuppression(x, anchors, masks, classes),
name='nonMaximumSuppression')((boxes_0[:3], boxes_1[:3], boxes_2[:3]))
return Model(inputs, outputs, name='yolov3')
```
Функция потерь:
```
def YoloLoss(anchors, classes=80, ignore_thresh=0.5):
def yolo_loss(y_true, y_pred):
pred_box, pred_obj, pred_class, pred_xywh = yolo_boxes(
y_pred, anchors, classes)
pred_xy = pred_xywh[..., 0:2]
pred_wh = pred_xywh[..., 2:4]
true_box, true_obj, true_class_idx = tf.split(
y_true, (4, 1, 1), axis=-1)
true_xy = (true_box[..., 0:2] + true_box[..., 2:4]) / 2
true_wh = true_box[..., 2:4] - true_box[..., 0:2]
box_loss_scale = 2 - true_wh[..., 0] * true_wh[..., 1]
grid_size = tf.shape(y_true)[1]
grid = tf.meshgrid(tf.range(grid_size), tf.range(grid_size))
grid = tf.expand_dims(tf.stack(grid, axis=-1), axis=2)
true_xy = true_xy * tf.cast(grid_size, tf.float32) - \
tf.cast(grid, tf.float32)
true_wh = tf.math.log(true_wh / anchors)
true_wh = tf.where(tf.math.is_inf(true_wh),
tf.zeros_like(true_wh), true_wh)
obj_mask = tf.squeeze(true_obj, -1)
true_box_flat = tf.boolean_mask(true_box, tf.cast(obj_mask, tf.bool))
best_iou = tf.reduce_max(intersectionOverUnion(
pred_box, true_box_flat), axis=-1)
ignore_mask = tf.cast(best_iou < ignore_thresh, tf.float32)
xy_loss = obj_mask * box_loss_scale * \
tf.reduce_sum(tf.square(true_xy - pred_xy), axis=-1)
wh_loss = obj_mask * box_loss_scale * \
tf.reduce_sum(tf.square(true_wh - pred_wh), axis=-1)
obj_loss = binary_crossentropy(true_obj, pred_obj)
obj_loss = obj_mask * obj_loss + \
(1 - obj_mask) * ignore_mask * obj_loss
class_loss = obj_mask * sparse_categorical_crossentropy(
true_class_idx, pred_class)
xy_loss = tf.reduce_sum(xy_loss, axis=(1, 2, 3))
wh_loss = tf.reduce_sum(wh_loss, axis=(1, 2, 3))
obj_loss = tf.reduce_sum(obj_loss, axis=(1, 2, 3))
class_loss = tf.reduce_sum(class_loss, axis=(1, 2, 3))
return xy_loss + wh_loss + obj_loss + class_loss
return yolo_loss
```
Функция "преобразовать цели" возвращает кортеж из форм:
```
(
[N, 13, 13, 3, 6],
[N, 26, 26, 3, 6],
[N, 52, 52, 3, 6]
)
```
Где `N` – число меток в пакете, а число `6`означает `[x, y, w, h, obj, class]` bounding box'а.
```
@tf.function
def transform_targets_for_output(y_true, grid_size, anchor_idxs, classes):
N = tf.shape(y_true)[0]
y_true_out = tf.zeros(
(N, grid_size, grid_size, tf.shape(anchor_idxs)[0], 6))
anchor_idxs = tf.cast(anchor_idxs, tf.int32)
indexes = tf.TensorArray(tf.int32, 1, dynamic_size=True)
updates = tf.TensorArray(tf.float32, 1, dynamic_size=True)
idx = 0
for i in tf.range(N):
for j in tf.range(tf.shape(y_true)[1]):
if tf.equal(y_true[i][j][2], 0):
continue
anchor_eq = tf.equal(
anchor_idxs, tf.cast(y_true[i][j][5], tf.int32))
if tf.reduce_any(anchor_eq):
box = y_true[i][j][0:4]
box_xy = (y_true[i][j][0:2] + y_true[i][j][2:4]) / 2
anchor_idx = tf.cast(tf.where(anchor_eq), tf.int32)
grid_xy = tf.cast(box_xy // (1/grid_size), tf.int32)
indexes = indexes.write(
idx, [i, grid_xy[1], grid_xy[0], anchor_idx[0][0]])
updates = updates.write(
idx, [box[0], box[1], box[2], box[3], 1, y_true[i][j][4]])
idx += 1
return tf.tensor_scatter_nd_update(
y_true_out, indexes.stack(), updates.stack())
def transform_targets(y_train, anchors, anchor_masks, classes):
outputs = []
grid_size = 13
anchors = tf.cast(anchors, tf.float32)
anchor_area = anchors[..., 0] * anchors[..., 1]
box_wh = y_train[..., 2:4] - y_train[..., 0:2]
box_wh = tf.tile(tf.expand_dims(box_wh, -2),
(1, 1, tf.shape(anchors)[0], 1))
box_area = box_wh[..., 0] * box_wh[..., 1]
intersection = tf.minimum(box_wh[..., 0], anchors[..., 0]) * \
tf.minimum(box_wh[..., 1], anchors[..., 1])
iou = intersection / (box_area + anchor_area - intersection)
anchor_idx = tf.cast(tf.argmax(iou, axis=-1), tf.float32)
anchor_idx = tf.expand_dims(anchor_idx, axis=-1)
y_train = tf.concat([y_train, anchor_idx], axis=-1)
for anchor_idxs in anchor_masks:
outputs.append(transform_targets_for_output(
y_train, grid_size, anchor_idxs, classes))
grid_size *= 2
return tuple(outputs) # [x, y, w, h, obj, class]
def preprocess_image(x_train, size):
return (tf.image.resize(x_train, (size, size))) / 255
```
Теперь мы можем создать нашу модель, загрузить веса и названия классов. В COCO датасете их80.
```
yolo = YoloV3(classes=num_classes)
load_darknet_weights(yolo, weightyolov3)
yolo.save_weights(checkpoints)
class_names = ["person", "bicycle", "car", "motorbike", "aeroplane", "bus", "train", "truck",
"boat", "traffic light", "fire hydrant", "stop sign", "parking meter", "bench",
"bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear", "zebra", "giraffe",
"backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard",
"sports ball", "kite", "baseball bat", "baseball glove", "skateboard", "surfboard",
"tennis racket", "bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl",
"banana","apple", "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut",
"cake","chair", "sofa", "pottedplant", "bed", "diningtable", "toilet", "tvmonitor", "laptop",
"mouse","remote", "keyboard", "cell phone", "microwave", "oven", "toaster", "sink",
"refrigerator","book", "clock", "vase", "scissors", "teddy bear", "hair drier", "toothbrush"]
def detect_objects(img_path, white_list=None):
image = img_path # Путь к изображению.
img = tf.image.decode_image(open(image, 'rb').read(), channels=3)
img = tf.expand_dims(img, 0)
img = preprocess_image(img, size)
boxes, scores, classes, nums = yolo(img)
img = cv2.imread(image)
img = draw_outputs(img, (boxes, scores, classes, nums), class_names, white_list)
cv2.imwrite('detected_{:}'.format(img_path), img)
detected = Image.open('detected_{:}'.format(img_path))
detected.show()
detect_objects('test.jpg', ['bear'])
```
### Итог
В этой статье мы поговорили об отличительных особенностях YOLOv3 и её преимуществах перед другими моделями. Мы рассмотрели способ реализации с использованием TensorFlow 2.0 (TF должен быть не менее версией 2.0).
### Ссылки
* [Полная реализация YOLOv3 на Tensorflow 2.0](https://github.com/zzh8829/yolov3-tf2)
* [Реализация YOLOv3 из текущей статьи](https://github.com/gingermuffin/YOLOv3-Tensorflow)
* [YOLOv3 - Joseph Redmon](https://pjreddie.com/media/files/papers/YOLOv3.pdf) | https://habr.com/ru/post/556404/ | null | ru | null |
# Автоматическое принятие приглашений к обмену документами в ЭДО Диадок по API
Предпосылки
-----------
ФНС в 2020 году утвердила концепцию перехода документооборота с контрагентами в электронный вид. В июле 2021 года обмен первичными документами и счетами-фактурами по закупке и продаже некоторых товаров уже стал безальтернативно электронным.
В компаниях с большим количеством операций, исполнителей, клиентов, поставщиков, филиалов, возникнет потребность в администрировании и настройке ЭДО: разделение доступа и управление им, справочниками сотрудников, контрагентами. В дальнейшем придется контролировать форматы документов (они меняются) и сам поток документов, их подписание. А также, использовать преимущества ЭДО: возможность разобрать документ и сверить с оплатами, заявками, договорами; заполнить реквизиты бухгалтерских проводок; автоматизировать отклонение документов при несоответствии, автоматически подписать при полном соответствии и так далее.
Операторы ЭДО предоставляют модули для интеграции с 1С, SAP и прочими популярными ERP. Коробочные инструменты не позволят добиться максимума автоматизации без затрат на их доработку. Операторы предлагают хорошую альтернативу - возможность интеграции по API, за сравнительно небольшие деньги.
Пример использования API
------------------------
Для возможности отправить и принять документы контрагенты должны обменяться приглашениями. Приглашение можно отправить любому юр.лицу по ключу ИНН-КПП, поэтому они могут поступать ежедневно от любых юридических лиц. Приглашение, которое не содержит доп.соглашения или договора об ЭДО между лицами, не порождает никаких правовых обязательств у сторон, поэтому его можно смело принимать. Но желательно ограничить список теми, с кем есть нерасторгнутый договор и активно ведутся сделки, и поставщик не в списке ненадежных.
Описание ниже не претендует на оценку качества кода, соблюдения правил. Код просто работает. Назначение - демонстрация возможностей лицам, принимающим решения (бизнесу, руководству), тестирование. То есть для стадии "минимально жизнеспособный продукт" (MVP).
Инструменты: Python, PyCharm Community Edition, SQL Server Express Edition, SSMS, ключ разработчика API (купить/получить у оператора ЭДО), описание методов и структур данных API оператора ЭДО. Все бесплатное, кроме ключа API.
Общий алгоритм:
1. Python: заходит в кабинет вашей организации (или нескольких в цикле), забирает все приглашения, помещает в таблицу на сервере
2. SQL server: связывает таблицу приглашений с таблицей оборотов (можно добавить доп.фильтры - договоры, список ненадежных) по ключу ИНН, строит список ИНН с ненулевыми оборотами за последний период
3. Python: забирает таблицу ИНН, заходит в кабинет ЭДО, принимает приглашения, заносит в таблицу на сервере записи о принятых приглашениях. Опционально (не описано в этой статье) - отправляет списки принятых приглашений ответственным сотрудникам.
4. Планировщик задач Windows: запускает программу, выполняющую три пункта выше, регулярно
Создаем базу данных на сервере с таблицами:
```
CREATE TABLE [dbo].[tbl_organizations](
[OrgGUID] [char](36) NULL,
[OrgID] [char](36) NULL,
[Inn] [char](12) NULL,
[Kpp] [char](9) NULL,
[Full_name] [nvarchar](max) NULL,
[Short_name] [nvarchar](max) NULL,
[BoxID] [varchar](100) NULL,
[BoxGUID] [char](36) NULL,
[Box_title] [nvarchar](max) NULL,
[Invoice_format_ver] [char](20) NULL,
[Ogrn] [char](15) NULL,
[FNS_participant] [char](50) NULL
) ON [PRIMARY]
GO
CREATE TABLE [dbo].[tbl_departments](
[DepartmentID] [char](36) NULL,
[Parent_dept_ID] [char](36) NULL,
[Dept_name] [nvarchar](max) NULL,
[Dept_abbr] [nvarchar](50) NULL,
[OrgID] [char](36) NULL
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
GO
CREATE TABLE [dbo].[tbl_invitations](
[Short_name] [nvarchar](255) NULL,
[OrgID_our] [char](36) NULL,
[Inn] [char](12) NULL,
[OrgID] [char](36) NULL
) ON [PRIMARY]
GO
CREATE TABLE [dbo].[tbl_invitations_accepted](
[OrgId] [char](36) NULL,
[Record_date] [date] NULL,
[Inn] [char](12) NULL,
[OrgId_our] [char](36) NULL
) ON [PRIMARY]
GO
```
Таблица tbl\_departments в этой задаче не используется, но будет использоваться для работы с документами в следующих статьях, если это кому-то будет интересно.
Предполагается, что на сервере уже есть таблица или представление (view) с оборотами поставщиков по ключу ИНН или ИНН-КПП, или активными договорами. Если нет, её можно периодически заливать на сервер полуавтоматом из любой системы - вывод в эксель из 1С или SAP и загрузка утилитой bcp, импортом в SSMS или программой.
Код программы представлен в виде линейной последовательности операций, без выделения повторяющихся инструкций в функции. Методы запросов описаны в документации на сайте оператора ЭДО.
```
import pprint
import requests
import json
import pyodbc
import datetime
import sys
#заводим файл лога для перенаправления вывода в файл
f_name = r'C:\Temp\log_' + datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S') + '.txt'
stdoutOrigin = sys.stdout
sys.stdout = open(f_name, "w")
try:
conn = pyodbc.connect(r'Driver={SQL Server};
SERVER=……;Database=diadoc_test;
Trusted_Connection=yes')
cursor = conn.cursor()
except:
ctypes.windll.user32.MessageBoxW(0,
"Нет прав на работу с БД"
, "Ошибка доступа", 1)
print(datetime.datetime.now()
.strftime('%Y-%m-%d_%H-%M-%S') + ' - не получилось соединиться с БД')
sys.stdout.close()
sys.stdout = stdoutOrigin
exit()
log_pass = {'login': '……', 'password': '…'}
pass_json = json.dumps(log_pass)
# ниже вместо точек указываем полученный от оператора ключ
auth_header_key = "DiadocAuth ddauth_api_client_id=..."
# авторизуемся для получения токена доступа
r = requests.request(method='POST'
, url='https://diadoc-api.kontur.ru/V3/Authenticate',
headers={"Authorization": auth_header,
"Content-Length": "1252",
"Connection": "Keep-Alive",
"Content-Type": "application/json"},
params={"type": "password"},
data=pass_json)
# добавляем полученный токен к заголовку авторизации
auth_header = auth_header_key + ",ddauth_token=" + r.text
print(datetime.datetime.now().__str__() + ' - авторизовался'
# обновляем реестр организаций и подразделений в базе данных
r1 = requests.request(method='GET'
, url='https://diadoc-api.kontur.ru/GetMyOrganizations'
,headers={"Authorization": auth_header,
"Content-Length": "1252",
"Connection": "Keep-Alive",
"Content-Type": "application/json",
"Accept": "application/json"},
params={"type": "password"},
data=pass_json)
r1 = r1.json()
print(datetime.datetime.now().__str__() + ' - получил список организаций')
conn.cursor().execute('truncate table diadoc_test.dbo.tbl_organizations')
.commit()
print(datetime.datetime.now().__str__() + ' - очистил таблицу организаций')
conn.cursor().execute('truncate table diadoc_test.dbo.tbl_departments').commit()
print(datetime.datetime.now().__str__() + ' - очистил таблицу подразделений')
for i in range(len(r1['Organizations'])):
if not r1['Organizations'][i]['IsTest']:
q_str = 'INSERT INTO diadoc_test.dbo.tbl_organizations VALUES(' + \
"'" + r1['Organizations'][i]['OrgIdGuid'] + \
"', '" + r1['Organizations'][i]['OrgId'] + "', '" + \
r1['Organizations'][i]['Inn'] + "', '" + \
r1['Organizations'][i]['Kpp'] + "', '" + \
r1['Organizations'][i]['FullName'] + "', '" + \
r1['Organizations'][i]['ShortName'] + "', '" + \
r1['Organizations'][i]['Boxes'][0]['BoxId'] + "', '" + \
r1['Organizations'][i]['Boxes'][0]['BoxIdGuid'] + "', '" + \
r1['Organizations'][i]['Boxes'][0]['Title'] + "', '" + \
r1['Organizations'][i]['Boxes'][0]['InvoiceFormatVersion'] + \
"', '" + r1['Organizations'][i]['Ogrn'] + "', '" + \
r1['Organizations'][i]['FnsParticipantId'] + "')"
conn.cursor().execute(q_str).commit()
print(datetime.datetime.now().__str__() + ' - ' + q_str)
for j in range(len(r1['Organizations'][i]['Departments'])):
if not r1['Organizations'][i]['Departments'][j]['IsDisabled']:
buff = r1['Organizations'][i]['Departments'][j]
q_str = 'INSERT INTO diadoc_test.dbo.tbl_departments VALUES(' + \
"'" + buff['DepartmentId'] + "', '" + \
buff['ParentDepartmentId'] + "', '" + \
buff['Name'] + "', '" + buff['Abbreviation'] + "', '" + \
r1['Organizations'][i]['OrgId'] + "')"
conn.cursor().execute(q_str).commit()
print(datetime.datetime.now().__str__() + ' - ' + q_str)
# обновляем реестр приглашений
conn.cursor().execute('truncate table diadoc_test.dbo.tbl_invitations').commit()
print(datetime.datetime.now().__str__() + ' - очистил таблицу приглашений')
orgs = conn.cursor().execute('select distinct OrgId from dbo.tbl_organizations').fetchall()
orgs_list = list(orgs[x][0] for x in range(len(orgs)))
print(datetime.datetime.now().__str__()
+ ' - построил список ЮЛ, записей - ' + str(len(orgs_list)))
for org in orgs_list:
after_index = -1
counter = 0
eol = False
while not eol:
print(org)
r1 = requests.request(method='GET'
, url='https://diadoc-api.kontur.ru/V2/GetCounteragents',
headers={"Authorization": auth_header,
"Content-Length": "1252",
"Connection": "Keep-Alive",
"Content-Type": "application/json",
"Accept": "application/json"},
params={"myOrgId": org,
"afterIndexKey": after_index,
"counteragentStatus": "InvitesMe"},
data=pass_json)
if r1.text[:8] != 'Доступ з':
r1 = r1.json()
for i in range(len(r1['Counteragents'])):
buff = r1['Counteragents'][i]['Organization']
q_str = 'INSERT INTO diadoc_test.dbo.tbl_invitations ' + \
'VALUES(' + "'" + buff['ShortName'] + "', '" + \
org + "', '" + buff['Inn'] + "', '" + \
buff['OrgId'] + "')"
conn.cursor().execute(q_str).commit()
print(datetime.datetime.now().__str__() + ' - ' + q_str)
if len(r1['Counteragents']) < 99:
eol = True
else:
# максимум 100 записей, запоминаем индекс, передаем в сл. запрос
after_index =
r1['Counteragents'][len(r1['Counteragents'])-1]['IndexKey']
else:
print(datetime.datetime.now().__str__() + ' - ' +
org + ' - ' + r1.text)
eol = True
# забираем с сервера список ИНН, OrgID, очищенный от неизвестных лиц,
# и принимаем приглашения
a = conn.cursor().execute(
'select distinct OrId_our, OrgID, ИНН from dbo.view_Приглашения_от_моих_КА'
).fetchall()
ka_list = list([a[x][0], a[x][1], a[x][2]] for x in range(len(a)))
print(datetime.datetime.now().__str__() +
' - построил список поставщиков по ЮЛ, записей - ' + str(len(ka_list)))
for i in range(len(ka_list)):
r1 = requests.request(method='POST'
, url='https://diadoc-api.kontur.ru/V2/AcquireCounteragent'
, headers={"Authorization": auth_header,
"Content-Length": "1252",
"Connection": "Keep-Alive",
"Content-Type": "application/json",
"Accept": "application/json"},
params={"myOrgId": ka_list[i][0]},
data=json.dumps({"OrgId": ka_list[i][1]}))
#если приглашение требует подписи - оно не примется, просто заносим в лог
if r1.text[0:6] == 'Cannot':
print(r1.text)
else:
#если приглашение "простое" - оно принято, вносим в таблицу на сервере
conn.cursor().execute('INSERT INTO dbo.tbl_invitations_accepted' +
'VALUES (' + "'" + ka_list[i][1] + "', '" +
datetime.datetime.now().strftime('%Y-%m-%d') +
"', '" + ka_list[i][2] + "', '" +
ka_list[i][1] + "')").commit()
print(datetime.datetime.now().__str__() +
' - принято приглашение от ' + ka_list[i][2])
print(datetime.datetime.now().__str__() + ' - задача завершена')
#закрываем файл лога
sys.stdout.close()
sys.stdout = stdoutOrigin
```
С помощью команды pyinstaller код собирается в исполняемый файл .exe, создаем задачу в планировщике задач Windows, в "Действиях" выбираем .exe-файл, на вкладке "Триггеры" добавляем периоды срабатывания по расписанию.
Результат:
Опционально можно добавить отправку писем ответственным за сделки с контрагентами, которая отправит сообщение о приеме приглашений и о наличии приглашений, требующих подписания. | https://habr.com/ru/post/588957/ | null | ru | null |
# Сортировка товаров и показ выбранного пользователем количества товаров в 1С-Битрикс
Исторически так сложилось, что комплексный компонент 1С-Битрикс не позволяет пользователю в публичной части отсортировать товары, хотя бы по цене, дате, наименованию, а также выбрать сколько товаров на странице ему выбрать. Но ни один из интернет-магазинов не обходится без такого функционала, который кстати включен в почти все шаблоны готовых интернет-магазинов в Маркетплэйс. Но для реализовать блоки «Сортировать по: ...» и «Показать по: ...» достаточно просто. Нужно всего-лишь использовать массив `$_REQUEST` и метод API 1С-Битрикс `GetCurPageParam()` для передачи данных в этот массив.
Приступим!
Для начала определимся, что от нас хотят:
* Вывести справа над списком товаров блок «Показать по: 18 36 54 72». (По умолчанию выводится 9).
* Слева над списком товаров вывести блок «Сортировать по: цене, наименованию, дате».
* Повторное нажатие на уже выбранный вариант сортировки переключает направление сортировки.
* Дата — дата изменения, цена — отображаемая цена товара.
Пойдем по порядку и начнем с показа выбранного пользователем из предложенных количества товаров на странице.
За отображение количества товаров на странице отвечает параметр `PAGE_ELEMENT_COUNT`. В него мы и будем передавать выбранное пользователем количество с помощью `$_REQUEST` и `GetCurPageParam()`.
Для начала заведем соответствующую переменную и по-умолчанию присвоим ей значение заданное в параметрах компонента. А затем при клике пользователя на нужное ему количество элементов будем его модифицировать.
Следующий код предлагается размещать перед подключением компонента `catalog.section`. Если используется комплексный компонент `catalog`, то в файле в котором происходит вызов компонента `catalog.section` выводящего товары на нужной странице.
```
php
$pageElementCount = $arParams["PAGE_ELEMENT_COUNT"];
if (array_key_exists("showBy", $_REQUEST)) {
if ( intVal($_REQUEST["showBy"]) && in_array(intVal($_REQUEST["showBy"]), array(18, 36, 54, 72)) ) {
$pageElementCount = intVal($_REQUEST["showBy"]);
$_SESSION["showBy"] = $pageElementCount;
} elseif ($_SESSION["showBy"]) {
$pageElementCount = intVal($_SESSION["showBy"]);
}
}
?
Показать по
for( $i = 18; $i <= 72; $i+=18 ) : ?
class="current" endif; ?
href="= $APPLICATION-GetCurPageParam('showBy='.$i, array('showBy', 'mode')) ?>"
>
= $i ?
endfor; ?
```
И теперь передадим полученное значение в компонент:
```
php
$APPLICATION-IncludeComponent(
"bitrix:catalog.section",
...
"PAGE_ELEMENT_COUNT" => $pageElementCount,
...
?>
```
Теперь разберемся с сортировкой. Она не намного сложнее, за исключением того, что нам нужно проверять текущее направление и менять его. Для этого в методе `GetCurPageParam()` мы будем передавать два параметра `sortBy` и `orderBy`. А затем в соответствующих переменных передавать их в параметры компонента `"ELEMENT_SORT_FIELD"` и `"ELEMENT_SORT_ORDER"` соответственно. По умолчанию сортировка должна осуществляться с помощью внутреннего поля сортировки 1С-Битрикс — `sort`.
Проверяем направление сортировки и меняем в случае необходимости:
```
php
if (isset($_REQUEST['orderBy'])) {
if ($_REQUEST['orderBy'] == 'asc') {
$orderBy = 'desc';
} else {
$orderBy = 'asc';
}
} else {
$orderBy = 'asc';
}
?
```
Выводим ссылки на сортировку:
```
Сортировать по:
class="current-sort" endif; ?
href="= $APPLICATION-GetCurPageParam('sortBy=price&orderBy='.$orderBy, array('sortBy', 'orderBy')) ?>"
>
цене
class="current-sort" endif; ?
href="= $APPLICATION-GetCurPageParam('sortBy=name&orderBy='.$orderBy, array('sortBy', 'orderBy')) ?>"
>
наименованию
class="current-sort" endif; ?
href="= $APPLICATION-GetCurPageParam('sortBy=date&orderBy='.$orderBy, array('sortBy', 'orderBy')) ?>"
>
дате
```
Параметр name принимается полем `"ELEMENT_SORT_FIELD"` для сортировки по наименованию товара без дополнительного вмешательства а вот для даты и цены мы должны уточнить, какой из параметров элемента инфоблока мы имеем ввиду.
Для даты нам нужно значение поля `'timestamp_x'`, отвечающего за дату изменения. Для цены мы должны узнать наименование типа цены, которая выводится из поля элемента инфоблока. Для этого нужно распечатать массив `$arItem` в шаблоне компонента (в моем случае `catalog.section`) либо с помощью `var_dump($arItem);`, либо ````
echo ''; print_r($arItem); echo '
```
';`. Находим поле массива отвечающего за вывод цены и копируем его название, в моем случае это оказалось `CATALOG_PRICE_1`. Стоит обратить внимание, что в случае с ценой использовать нужно название того поля, которые содержит значение цены без валюты.
И передадим полученные данные в переменную `$sortBy`:
```
php
if (isset($_REQUEST['sortBy'])) {
$sortBy = $_REQUEST['sortBy'];
} else {
$sortBy = 'sort';
}
if ($sortBy=='price') {
$sortBy = 'CATALOG_PRICE_1';
}
if ($sortBy=='date') {
$sortBy = 'timestamp_x';
}
?
```
И передадим значения в параметры компонента:
```
php
$APPLICATION-IncludeComponent(
"bitrix:catalog.section",
...
"ELEMENT_SORT_FIELD" => $sortBy,
"ELEMENT_SORT_ORDER" => $orderBy,
...
?>
```
Вот собственно и все. В результате получится примерно такая строка:
Теперь пользователь может сортировать товары и выбирать сколько товаров он хочет видеть на странице, и разумеется переходить по страницам и фильтровать товары ничего не теряя. | https://habr.com/ru/post/271307/ | null | ru | null |
# PHP модуль — это всё ещё просто. Часть вторая
Пока [nerezus](https://habrahabr.ru/users/nerezus/) сочиняет статью о встраивании PHP, я постараюсь продолжить его рассказ о написании расширений. Рассказано будет далеко не всё, поскольку я считаю, что сложность наращивать надо постепенно, иначе материал будет трудноусвояемым и совсем не питательным. В связи с этим я всё-таки не расскажу в этот раз, как подменить операторы в классе, кто захочет, может почитать исходники [модуля Operator](http://cvs.php.net/viewvc.cgi/pecl/operator/) от Сары Големон — основного автора какой бы то ни было информации о разработке расширений PHP.
Поскольку разработку я веду исключительно в линуксе, то писать мы будем без всяких хитрых аддонов к Visual Studio, ручками, с нуля :) А что, лучше сразу разобраться, а потом уже упрощать свой труд.
Первым делом нам надо будет написать два файла: **config.m4** и **Makefile**. Первый нужен для сборки нашего расширения, а второй… чтобы эта самая сборка не загадила наш каталог с исходниками :)
#### 1. config.m4
Итак, приступим. Файлы для сборки писать не слишком интересно, поэтому я их просто приведу и расскажу, что к чему. [Вот общий вид](http://paste.ubuntu.com/320348/) нашего конфига.
Строки, начинающиеся с «dnl» — это комментарии.
Первые две строки добавляют нам опцию --enable-mystring для сборки. Так мы можем положить наш модуль в папку /ext/ исходников пхп и выбирать — собрать пхп с ним или без него.
Если закомментировать строки 1-2 и раскомментировать 3-4, то мы получим опцию --with-mystring, которой можно дополнительно указать путь. Зачем? Для всех оставшихся в файле строк :) Если мы заходим использовать какую-то специфическую библиотеку (я в примере указал библиотеки mylib1 и mylib2), то мы сможем при конфигурировании передать путь к ней. Собственно в строках 12-29 мы и пытаемся данные библиотеки найти и подключить.
Дальше обращаем внимание на строку 9. Она добавляет в наш конфиг переменную <ИМЯ\_МОДУЛЯ>\_SHARED\_LIBADD, куда добавляются библиотеки для линковки. Вообще привыкайте, что m4 требует строгих, а не произвольных имён переменных. Это Спарта.
В строках 33-35 мы добавляем к линковке самые обычные библиотеки — их искать не требуется.
Ну и в строке 36 — указываем, из каких файлов надо собрать наш экстеншен.
Строка 32 дополнительно указывает, что мы пишем наш модуль не на C, а на С++ (в деле написания модуля — разница небольшая, а вот если вы будете подключать плюсовые библиотеки или плюсовый код — оно вам потребуется).
Поскольку в этот раз мы ничего не подключаем — мы наш конфиг значительно [укоротим](http://paste.ubuntu.com/320359/). Всего 10 строк — ничего лишнего.
#### 2. Makefile
Мейкфайлы, я думаю, каждый уважающий себя программист хоть раз в жизни да писал, поэтому пояснений требоваться не должно. Так что [берем и пользуемся](http://paste.ubuntu.com/320362/). Обращаю внимание, что команда `php-config --extension-dir` выдаёт нам каталог, где хранятся расширения PHP, а каталог **\_\_build** — это тот, в котором мы и будем всё собирать.
#### 3. Создаём mystring.h-файл
Что нам теперь надо? Как и в любой приличной программе на C/C++ — заголовочный файл и файл с кодом. Начнём с заголовочного. Файл у нас опять-таки будет [простой](http://paste.ubuntu.com/320825/), меньше 40 строк. Пройдёмся по нему.
Строками 4-5 мы объявим название и версию нашего расширения. Нужно это с единственной целью — вывести данную ценную информацию позже в инфо о модуле.
Строка 7 задаёт нам имя класса. Конечно, писать «mystring» короче, чем PHP\_MYSTRING\_CLASS\_NAME, но зато в любой момент сменить имя класса можно будет в одном единственном месте. Например, переименовать класс в «Mystring» — с большой буквы, как подобает приличным людям.
Строки 9-11 инклюдят файл config.h, который сгенерируется в процессе сборке — сами мы его писать не будем.
Дальше инклюдим стандартные заголовки и объявляем функции. Остановимся здесь подробнее. Функции **PHP\_MINIT\_FUNCTION** и **PHP\_MSHUTDOWN\_FUNCTION** — это функции, выполняющиеся при загрузке и выгрузке модуля. Помимо них бывают **\*\_GINIT\_\*** и **\*\_GSHUTDOWN\_\*** — функции для глобального запуска/выгрузки PHP, и **\*\_RINIT\_\*** и **\*\_RSHUTDOWN\_\*** — при активации/деактивации модуля. Функция **PHP\_MINFO\_FUNCTION** — это функция, выполняющаяся при вызове **phpinfo()**, она сгенерирует нам информацию о модуле.
Дальше мы объявим несколько методов — помните, в первой части вы объявляли их при помощи макроса **PHP\_FUNCTION** и они были глобальными? Здесь мы делаем по сути то же самое, только макрос принимает два параметра — класс и имя его метода.
Ну и под конец 35-ой строкой объявим наш модуль.
Больше нам собственно в заголовочном файле ничего не нужно — переходим к коду.
#### 4. Пишем код модуля — mystring.cc
Здесь, код посложнее. К сожалению, не удалось его поместить прямо в статью — хабр протестовал — поэтому я выложил сразу весь код [сюда](http://paste.ubuntu.com/321607/), здесь же мы рассмотрим только его содержимое.
##### Строки 1-27
Пока всё просто — объявляем наш будущий класс, и декларируем наш модуль. Обратите внимание — мы указали его название, версию, а также функции **MINIT**, **MSHUTDOWN** и **MINFO**. Глобальных функций мы в этот раз не объявляем, **RINIT** и **RSHUTDOWN** нам тоже не нужны, всё остальное можно считать дефолтным.
##### Строки 29-49
Теперь мы подставили макрос, говорящий PHP, что наш модуль можно скомпилировать как расширение, а не только как часть PHP. Затем объявили набор функций класса. Для каждой функции указывается 4 параметра: имя класса, имя функции, указатель на структуру **arg\_info** и параметры доступа. Внятного описания структуры **arg\_info** я ни разу не встречал, поэтому мы будем по старинке передавать **NULL**, а проверять параметры уже в самой функции.
Основные параметры доступа — это, разумеется, **ZEND\_ACC\_PUBLIC**, **ZEND\_ACC\_PROTECTED** и **ZEND\_ACC\_PRIVATE**. Дополнительно к ним можно указать **ZEND\_ACC\_STATIC** или **ZEND\_ACC\_ALLOW\_STATIC** (такой метод можно использовать и как статический, и как обычный). Для конструкторов, деструкторов, а также оператора **clone** (в PHP объявляется как функция **\_\_clone**) надо указывать соответственно флаги **ZEND\_ACC\_CTOR**, **ZEND\_ACC\_DTOR** и **ZEND\_ACC\_CLONE**.
Впрочем, полный список вы можете посмотреть в заголовочных файлах, на моей машине это файл */usr/include/php5/Zend/zend\_compile.h*
Обратите внимание, что после каждого метода, описанного с помощью **PHP\_ME()** запятую ставить не нужно. А в конце всегда должен быть массив из трёх **NULL**'ов.
А тем временем мы едем дальше.
##### Строки 51-76
Определили три объявленных ранее метода — загрузка, выгрузка и информация о модуле. Из всех трёх интерес нам представляет только один: загрузка модуля. Для начала мы должны зарегистрировать наш объявленный класс.
Затем мы в зарегистрированном классе создаём свойство, для чего передаём указатель на зарегистрированный класс, название свойства, длину этого названия (об этом строчкой позже), значение по умолчанию и опять-таки параметры доступа. В конце мы должны обязательно написать волшебное слово **TSRMLS\_CC**. Это слово надо упомянуть особо. Чтобы внутри функции работать с текущим состоянием PHP — знать, где мы сейчас находимся, иметь информацию о классах и т.д. и т.п., надо данную информацию передавать. Для этого при объявлении функции надо в конце написать макрос **TSRMLS\_DC**, а при вызове — **TSRMLS\_CC**. Запятую перед макросом в обоих случаях ставить не нужно.
Теперь вернемся к длине названия свойства. Информация об объявлении свойств в разных источниках весьма скудна и противоречива. Так, в руководстве той же Сары Големон упоминается, что если свойство объявлено как приватное, оно должно иметь название вида "**\0**имя\_класса**\0**имя\_свойства", для чего в PHP существует метод **zend\_mangle\_property\_name()**, конструирующий подобное название для protected и private свойств. На практике же оказалось, что если использовать **zend\_mangle\_property\_name**, PHP при обращении к свойству грязно ругается, в то время как в вышеупомянутом вызове — всё замечательно. Имейте в виду, если будете читать литературу по теме.
##### Строки 78-106
Давайте теперь определим стандартные методы класса. Поехали по пунктам.
Функция **getThis()** возвращает нам указатель на объект класса, из которого мы вызвали метод. Для конструктора и деструктора мы проверяем этот указатель — нам не хочется, чтобы кто-то вызывал данные методы статически. Затем в конструкторе мы — просто чтобы показать вам данную функцию — меняем уже задекларированное свойство «str». Для этого мы передаем тип объекта (класс), указатель на сам объект, имя и длину имени свойства, а также новое значение. Обратите внимание, что мы используем **\*\_stringl()**, а не **\*\_string()** функцию — она требует передать еще и длину нового значения. В принципе она используется в случаях, когда в строке может присутствовать символ **'\0'**, или когда мы наоборот хотим записать только первые N символов от строки, но из-за того что она работает чуть быстрее, чем **\*\_string()** вариант, мы используем её и в такой тривиальной ситуации- нам же не жалко лишний параметр указать.
Аналогично мы используем макрос **RETURN\_STRINGL** в функции приведения класса к строке. Обратите внимание на последний параметр «1» — он означает, что мы хотим передать не сам объект, а его копию. Мало ли что потом с нашей строкой захотят делать.
##### Строки 108-133
Давайте опишем метод добавления строки.
Первым делом мы проверяем, передали ли нам строку в качестве параметра — это уже рассматривалось в первой части.
Затем мы считываем из нашего объекта уже храняющуюся там строку. Обратите внимание, что хотя мы создавали свойство как **string**, указатель нам вернулся на **zval**. Всё дело в том, что абсолютно все типы данных в php представляются типом **zval**. Если вам интересно, как он устроен, смотрите файл */usr/include/php5/Zend/zend.h* на предмет определения **struct \_zval\_struct** и **union \_zvalue\_value**.
Наконец, мы выделяем память под новую строку и копируем туда исходную строку и «добавку». Затем пользуемся уже знакомым методом **zend\_update\_property\_stringl()** и записываем новое значение. Вместо **malloc**, **calloc** и **free** в PHP принято пользоваться зендовскими аналогами **emalloc**, **ecalloc** и **efree**.
Готово, новое значение лежит там, где надо, можно вернуть **NULL**. Домашнее задание: догадаться, как вернуть сам объект, чтобы можно было составлять цепочки вида **$a->append(«a»)->append(«b»)**…
##### Строки 135-148
Ну и наконец реализуем метод compare. В нём мы не будем реализовывать настоящее сравнивание (чёрт знает, почему я решил обозвать метод так), а выведем нашу строку — должна же она хоть где-то выводиться — и покажем чуть-чуть магии.
Для начала мы считали и вывели нашу строку str. Синтаксис функции **zend\_printf()**, как вы могли заметить, абсолютно идентичен стандартному **printf()**. А вот дальше… что это? Да, это мы легко и непринужденно взяли и выполнили кусок PHP-кода. В качестве параметров передаём строку кода, указатель на переменную, куда положить результат выполнения, а также название нашего скрипта. Чтобы ничего не выдумывать, я просто написал myvardump.
#### Итоги
Набираем `**make all install**`. Теперь вводим: **php -r '$s = new mystring(); echo $s."\n"; $s->append(" Попячсо!"); $s->compare();'**, смотрим на вывод:
> `mystring
>
> upchk Попячсо!
>
> object(mystring)#1 (1) {
>
> ["str:private"]=>
>
> string(21) "upchk Попячсо!"
>
> }`
Первая строка — это мы вывели наш класс, приведенный к строке (см. **\_\_toString()**). Вторая — вывели уже измененную строку str. А оставшиеся три строки — это результат нашего **zend\_eval\_string** — дамп класса. Наблюдаем наше созданное приватное свойство — всё честно.
#### Что дальше?
Во-первых, в рамках самопиара рекомендую зачекаутить только недавно написанный мною экстеншен:
**svn checkout <http://dingo-php.googlecode.com/svn/trunk/> dingo-php**
Большинству пользователей сам экстеншен будет абсолютно неинтересен с точки зрения практического применения, но зато в нём можно посмотреть:
— как сделать в одном экстеншене несколько классов, которые можно включать и выключать при компиляции
— как оборачивать и использовать сторонние библиотеки
— ну и немножко реального кода
Кроме того, рекомендую книгу Сары Големон:
>> *Sara Golemon «Extending and Embedding PHP»*
В России она стоит какого-то бешеного количества тенге, но при известном старании в интернете можно найти электронную версию.
Книга немного устаревшая, но зато именно там можно узнать, зачем нужны RINIT/RSHUTDOWN, как навесить свои хэндлеры на события, происходящие с классами, как создавать потоки (streams), работать с ini-конфигом, и творить с объектами очень многое другое.
P.s. Для тех, кому для экспериментов лень будет копипастить, я выложил архив с готовым к компиляции модулем: [narod.ru/disk/15177450000/mystring.tar.gz.html](http://narod.ru/disk/15177450000/mystring.tar.gz.html) | https://habr.com/ru/post/75445/ | null | ru | null |
# Переходим с Disqus на комментарии Github
Какое-то время я хотел убрать комментарии из своего блога; в основном, потому что здесь вообще мало комментариев, да и не хочется возиться с лишними «тормозами» от [Disqus](https://disqus.com/). Посмотрев на время загрузки Disqus, я был потрясён тем, что приходится терпеть посетителям сайта по моей вине (кроме тех, кто использует блокировщики вроде [Privacy Badger](https://www.eff.org/privacybadger) и [uBlock Origin](https://github.com/gorhill/uBlock).
Эта статья заточена под Hugo, но код легко адаптируется для любого сайта.
Что не так с Disqus?
--------------------
Вот как выглядит типичный журнал запросов с *включенным* Disqus.
[](https://habrastorage.org/files/a1a/3e3/02f/a1a3e302f4974b4093251befda71d3d4.png)
А вот лог после *отключения* Disqus.
[](https://habrastorage.org/files/86f/c0d/dad/86fc0ddad76c4bfba4cae2f78ce6f2cf.png)
**ЧЕГО!?**
Важные моменты здесь следующие:
* Время загрузки снижается с 6 до 2 секунд.
* Количество сетевых запросов снижается со 105 до 16.
* По сети идёт масса нерелевантных запросов для слежки за пользователем.
Среди сетевых запросов вы можете обнаружить такие:
* **disqus.com** — Очевидно!
* **google-analytics.com** — Многочисленные запросы; без понятия, кто следит за вами.
* **connect.facebook.net** — Если вы авторизованы на Facebook, то они знают о вашем посещении этого сайта.
* **accounts.google.com** — Google также отслеживает ваше посещение этого сайта через любой из ваших аккаунтов Google.
* **pippio.com** — Идентификация LiveRamp для сбора информации о вас с коммерческими целями.
* **bluekai.com** — Трекинг отдельного пользователя для маркетинговых кампаний.
* **crwdcntrl.net** — Довольно подозрительный сайт, который упоминается в связи с распространением вирусов и шпионского ПО.
* **exelator.com** — Ещё один сайт для слежки за пользователями, в честь него даже назван вирус!
* **doubleclick.net** — Этого мы все знаем: реклама и слежка за действиями пользователя, принадлежит Google.
* **tag.apxlv.net** — Очень подозрительно и выглядит хитростью, что владелец обфусцировал свой домен (я даже не знал, что такой приём работает!). Добавляет на ваш сайт пиксель для слежки.
* **adnxs.com** — Ещё больше следящего мусора, хотя немного более обильного.
* **adsymptotic.com** — Реклама и слежка, которая предположительно использует машинное обучение.
* **rlcdn.com** — Обфусцированная реклама/трекинг от Rapleaf.
* **adbrn.com** — «Обеспечиваем пернализированное путешествие пользователя по устройствам, каналам и платформам с помощью технологии соответствия через пользовательский идентификатор Adbrain».
* **nexac.com** — Datalogix от Oracle, их собственная дрянь для слежки и поведенческого анализа.
* **tapad.com** — Всё, мне надоело искать про них информацию.
* **liadm.com** — Ещё? Ох, ладно, тогда…
* **sohern.com** — Мда. Слежка.
* **demdex.net** — Слежка. От Adobe.
* **bidswitch.net** — Дам ещё одну подсказку…
* **agkn.com** — …
* **mathtag.com** — Забавное название, может быть, это… нет. Оно следит за вами.
Я не могу посетить многие из этих сайтов, потому что они заблокированы в uBlock Origin, так что информацию пришлось собирать из результатов поиска Google и со сторонних сайтов. Нечего и говорить — довольно противно видеть, как некоторые бесплатные продукты превращают вас самого в продукт. Ещё больше опасений вызывают сервисы, которые пытаются скрыть своё предназначение и цель, зачем они следят за вашими действиями.
В любом случае, удаляйте это. Прошу прощения перед всеми за то, что отравил свой сайт этими сетями. Перейдём к лучшим вещам.
Используем Github для комментариев
----------------------------------
Я обсуждал удаление Disqus, и [@HarryDenholm](https://twitter.com/HarryDenholm) упомянул, что его друг умудрился реализовать комментарии на своём статичном блоге Github, используя пулл-реквесты. Я подумал, что это гениальная идея, и решил выяснить, можно ли сделать что-то такое для Hugo на внешнем сайте.
Ответ содержится в [Github Issue API](https://developer.github.com/v3/issues/). Процесс довольно простой и он уже работает для [этого поста в блоге](http://donw.io/post/github-comments/):
1. Для каждого опубликованного поста открывайте Issue в каком-нибудь репозитории на Github. Например, для этого поста он открыт [здесь](https://github.com/dwilliamson/donw.io/issues/1).
2. Все комментарии публикуются напрямую на Github.
3. Добавьте на сайт код Javascript, который считывает описание JSON комментариев этого Issue и отображает их.
Преимущества такого подхода вы получаете немедленно:
* Трекинг посетителей сайта сводится к нулю. Сам Github видит только сетевые запросы на чтение с безымянных IP.
* Все комментарии написаны на [Markdown](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet), с поддержкой встроенного кода, изображений, списков и форматирования.
* Вы можете использовать уведомления Github об ответах; не требуется даже заходить на этот сайт, чтобы читать комментарии и участвовать в обсуждении.
* Хотя это кажется лишним, но вы можете интегрировать эмодзи [Github Reactions](https://developer.github.com/v3/reactions/) (может быть полезно для более крупных сайтов).
Для чтения данных Github JSON не требуется ключ API; они полностью открыты для доступа. Комментарии к этому посту можно считать в виде JSON [здесь](https://api.github.com/repos/dwilliamson/donw.io/issues/1/comments). Первый комментарий выглядит так:
```
{
"url": "https://api.github.com/repos/dwilliamson/donw.io/issues/comments/295004846",
"html_url": "https://github.com/dwilliamson/donw.io/issues/1#issuecomment-295004846",
"issue_url": "https://api.github.com/repos/dwilliamson/donw.io/issues/1",
"id": 295004846,
"user": {
"login": "dwilliamson",
"id": 1532903,
"avatar_url": "https://avatars3.githubusercontent.com/u/1532903?v=3",
"gravatar_id": "",
"url": "https://api.github.com/users/dwilliamson",
"html_url": "https://github.com/dwilliamson",
"followers_url": "https://api.github.com/users/dwilliamson/followers",
"following_url": "https://api.github.com/users/dwilliamson/following{/other_user}",
"gists_url": "https://api.github.com/users/dwilliamson/gists{/gist_id}",
"starred_url": "https://api.github.com/users/dwilliamson/starred{/owner}{/repo}",
"subscriptions_url": "https://api.github.com/users/dwilliamson/subscriptions",
"organizations_url": "https://api.github.com/users/dwilliamson/orgs",
"repos_url": "https://api.github.com/users/dwilliamson/repos",
"events_url": "https://api.github.com/users/dwilliamson/events{/privacy}",
"received_events_url": "https://api.github.com/users/dwilliamson/received_events",
"type": "User",
"site_admin": false
},
"created_at": "2017-04-18T22:39:16Z",
"updated_at": "2017-04-18T22:39:16Z",
"body": "This is a comment"
},
```
Первым делом следует добавить новый шаблон в свой каталог с частями шаблонов. Он будет считывать и отображает комментарии Github (`comments.html`). Вот код, который я использовал:
```
var url = "https://github.com/dwilliamson/donw.io/issues/" + {{ $.Params.ghcommentid }}
var api_url = "https://api.github.com/repos/dwilliamson/donw.io/issues/" + {{ $.Params.ghcommentid }} + "/comments"
$(document).ready(function () {
$.ajax(api_url, {
headers: {Accept: "application/vnd.github.v3.html+json"},
dataType: "json",
success: function(comments) {
$("#gh-comments-list").append("Visit the **[Github Issue](" + url + ")** to comment on this post");
$.each(comments, function(i, comment) {
var date = new Date(comment.created_at);
var t = "";
t += "![](" + comment.user.avatar_url + ")";
t += "**[" + comment.user.login + "](" + comment.user.html_url + ")**";
t += " posted at ";
t += "*" + date.toUTCString() + "*";
t += "";
t += comment.body\_html;
t += "";
$("#gh-comments-list").append(t);
});
},
error: function() {
$("#gh-comments-list").append("Comments are not open for this post yet.");
}
});
});
```
Его можно вызвать со страницы поста:
```
{{ partial "comments.html" . }}
```
Переменные, на которые ссылается шаблон, следует добавить в заголовок html-страницы. В данном случае это единственная переменная `ghcommentid`, она устанавливает номер Issue, который используется для комментариев.
Резюме
------
Добавить больше нечего. Технически, вы можете вообще публиковать свои посты как Github Issues и забыть о блог-движке. Но это кажется использованием системы не по назначению.
Этот веб-сайт управляется на Github как [dwilliamson/donw.io](https://github.com/dwilliamson/donw.io). Там есть полный код для использования Github в качестве движка комментариев. | https://habr.com/ru/post/327424/ | null | ru | null |
# «Краткость сестра...» или интеграция SMS API в бизнес процессы
Иногда так хочется ненадолго вернуться в ранние нулевые. Ах, ностальгия! Сборная еще не взяла бронзу на Евро, сентябрь не сгорел, Бандурин и Вашуков выступают вместе, а SMS — отличное средство для быстрой коммуникации.
И если все остальное похоже не вернуть, то вот на счет SMS я не буду столь категоричен.
Нет, я не забыл принять свои таблетки, просто сегодня мы одним глазом посмотрим на новый SMS API от компании MTT.
Придерживаясь немного шутливого стиля мы на простых примерах рассмотрим следующее:
1. Пару примеров для быстрого старта с SMS API.
2. Пример скрипта для подсчета голосов, отправленных по SMS.
3. Пример интеграции SMS API в простой бизнес-процесс Camunda community edition.
В начале статьи важно уточнить, что ниже речь пойдет о новом SMS API от компании MTT. Также сделаю ставший стандартным дисклеймер о том, что я не разработчик, поэтому программный код, изложенный в статье, может быть далек от самых лучших практик.
Все, с формальностями покончено, теперь можем переходить к делу.
**Содержание:**
* [Общее описание SMS API](#a1)
* [Пример скрипта для подсчета голосов отправленных по SMS](#a2)
* [Пример интеграции SMS API в простой бизнес процесс Camunda community edition](#a3)
Общее описание SMS API
----------------------
Этот раздел, будет полезен, тем кто плохо знаком с базовыми принципами использования Telecom API. Если вы опытный специалист, то можете смело его пролистать.
Ниже я покажу только несколько примеров использования API, для всего остального можно заглянуть в [документацию](https://wiki.mtt.ru/pages/viewpage.action?pageId=132548112) и сделать по аналогии.
Новый SMS API, в первую очередь, позволяет нам отправлять и принимать SMS сообщения, но естественно только этим его функции не ограничиваются. С помощью этого инструмента мы можем:
* Отправлять сообщения.
* Принимать сообщения.
* Получать историю и общее количество отправленных сообщений.
* Получать уведомления об отправленных и полученных SMS.
* Управлять черным списком номеров.
* Просматривать и управлять настройками номеров для сервиса сообщений.
Чтобы упростить процесс, я сделал **коллекцию и окружение** для Postman. Вы можете их [скачать](https://github.com/bosonbeard/Funny-models-and-scripts/tree/master/6.Phone_bot/4.SMS_API) и [импортировать в Postman](https://learning.postman.com/docs/getting-started/importing-and-exporting-data/#importing-postman-data), а затем просто подставить в окружении ваше значения логина MTT и пароля (токена).
После того, как вы успешно справитесь с импортом коллекции и окружения, необходимо задать значения переменным окружения. Самый простой путь — это нажать кнопку в правом верхнем углу окна приложения и вставить актуальные данные в поля раздела current value.
ОкружениеСекция заголовка для авторизацииТеперь мы можем перейти к примерам.
Для начала убедимся, что всё работает.
Выберите в коллекции метод GetNumbеrs и откройте вкладку body.
Давайте расшифруем поля:
* customer\_name — это ваш идентификатор пользователя, как я уже писал выше мы подставляем сюда переменную mtt\_login
*(переменные в постман обрамляются двумя фигурными скобками)*
* limit — количество записей, которое мы получим в ответе
* offset — страница с которой начнем просмотр
*(например, если limit = 10, offset = 1, то мы получим записи начиная с 11)*
Отправьте запрос. Если всё выполнялось корректно, вы получите ответ:
Пример запросаЕсли перейти на вкладку Console, можно увидеть, как выглядит полностью адрес запроса.
Консоль PostmanТеперь, когда мы уверены, что все работает корректно, давайте приступим к самому главному — отправке SMS.
Выберите в коллекции метод GetNumbеrs и откройте вкладку body.
Давайте расшифруем поля:
* number — это номер, который будет отправлять и принимать SMS, мы подставляем сюда переменную mtt\_number
* destination — номер, на который мы отправляем SMS
* text — текст SMS *(можно писать, как по-английски, так и по-русски)*
Отправьте запрос. Если всё выполнялось корректно, вы получите ответ:
Пример запроса* success — это статус отправки (если true, то все хорошо)
* mesage\_id — идентификатор сообщения, его можно потом использовать в фильтрах для поиска конкретного сообщения.
Давайте проверим, как это работает в обратную сторону. Отправьте со своего телефона SMS на номер, который вы ввели в переменную mtt\_number
После отправки выберите в коллекции метод GetMessagesHistoryList и откройте вкладку body.
Давайте расшифруем поля:
* customer\_name - это ваш идентификатор пользователя, как я уже писал выше мы подставляем сюда переменную mtt\_login
Для простоты, я сейчас не стал указывать в запросе фильтры. Некоторые из них я объясню в разделе про голосование при помощи SMS.
Но просто помните: если дополнить наш запрос, например, полем
"event\_date\_gt":"2022-11-27T19:02:01.000Z", то будут показаны только сообщения отправленные после 19:02:01 27 ноября 2022 года.
Отправьте запрос. Если всё выполнялось корректно, вы получите ответ:
Пример запросаПробежимся по полям ответа:
* message\_id — ИД сообщения (разбирали выше)
* number — это наш mtt\_number
* sender — номер отправителя
*(если вы послали сообщение через API то он будет такой же как в поле number)*
* *receiver - номер получателя
(если вам послали сообщение через API то он будет такой же как в поле number)*
* text — текст сообщения
* direction — тип сообщения: входящее (incoming) или исходящее (outgoing)
* segments\_count - количество сегментов
(помните раньше 1 смс было 70 символов на кириллице - это и есть 1 сегмент)
* billing\_status - статус оплаты сообщения
* delivery\_status - статус доставки сообщения
* event\_date - дата отправки
* channel - канал (SMS)
Вот мы и попробовали в блиц режиме SMS API.
Как я говорил выше, это не все методы API, но для первого знакомства самое то.
Пример скрипта для подсчета голосов отправленных по SMS
-------------------------------------------------------
Мы могли бы с вами сегодня разобрать что-то современное и тривиальное, например, отправку кодов для проверки номера телефона или оповещение о статусе заказа, но это на мой взгляд скучно. Лучше продолжим погружаться в эстетику нулевых.
Давайте вспомним такое явление как SMS голосование. Представьте, что вы работаете на региональной радиостанции, и в вашей программе есть интерактивная передача с SMS голосованием. Эфир передачи торжественно завершит песня в честь победителя голосования. Но как же нам узнать глас народа? Интернет, знаете ли, может быть не у всех, обрабатывать звонки не удобно, а вот SMS — самое то!
По легенде в нашем голосовании участвуют два участника котики и песики. Чтобы голос учли надо отправить смс с текстом “cat” или “dog” на номер радиостанции. Следить за ходом голосования можно на сайте.
Страница будет выглядеть вот так:
Макет сайтаКакая красота! Табличная верстка, нет ни всяческих новомодных AJAXов, ни CSSов, только теплые ламповые HTML + PHP.
А поскольку на хостинг мы с вами тратиться сильно не хотим, то обойдемся без базы данных. Чтобы сэкономить средства и ресурсы, переложим хранение данных на плечи MTT, раз уж есть такая возможность.
Прежде чем перейти к коду, еще раз напомню, что я не программист, поэтому мои программные решения могут быть далеки от идеала. Воспринимайте код ниже, как демонстрацию работы с SMS API.
Также напомню, что все примеры можно скачать с [**GitHub**](https://github.com/bosonbeard/Funny-models-and-scripts/tree/master/6.Phone_bot/4.SMS_API).
Начнем с главной страницы.
Код страницы простой, там только HTML и вызов функции для голосования. Мы не будем его детально рассматривать.
Листинг я спрячу под спойлер.
index.php
```
Супер голосование
php
#settings for vore
require("count.php");
$number = "79610000000";
$date\_gt="2022-12-03T22:00:27.00Z";
$date\_lt="2022-12-04T02:00:27.00Z";
$first="cat";
$second="dog";
?
| Голосование!!! |
Котики
Cat |
Всего SMS
php
$result = count\_votes($number, $date\_gt, $date\_lt , $first,$second);
echo array\_sum($result);
? |
Песики
Dog |
| php echo $result[0] ?
php echo $result[1] ? |
```
Как вы уже догадались из листинга index.php, основная логика запросов прячется в файле count.php.
Под спойлером полный листинг файла.
count.php
```
php
function count_votes($number, $date_gt, $date_lt, $first, $second)
{
# $first - string for 1st candidate
# $second - string for 2ns candidate
#settings
$url = "https://api.mtt.ru/ms-customer-gateway/v1/GetMessagesHistoryList";
$customer_name = "testxxxxxxxt";
$token = 'eyJhbGciOiJIXXXXX…';
#curl request
$curl = curl_init();
curl_setopt_array($curl, array(
CURLOPT_URL = 'https://api.mtt.ru/ms-customer-gateway/v1/GetMessagesHistoryList',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 0,
CURLOPT_FOLLOWLOCATION => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'POST',
CURLOPT_POSTFIELDS =>'{
"customer_name": "'.$customer_name.'",
"number":"'.$number.'",
"event_date_gt":"'.$date_gt.'",
"event_date_lt":"'.$date_lt.'",
"direction":"incoming",
"delivery_status":"delivered"
}
',
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer '.$token.'',
'Content-Type: application/json'
),
));
$response = curl_exec($curl);
curl_close($curl);
# count voices
$msg = json_decode($response , true);
$count_first =0 ;
$count_second = 0;
foreach ($msg as $key ) {
foreach ($key as $key2=>$value ) {
if ( strtolower( $value["text"]) == $first )
{
$count_first+= 1;
}
if ( strtolower( $value["text"]) == $second )
{
$count_second+= 1;
}
}
}
return [$count_first,$count_second] ;
}
?>
```
Давайте на всякий случай разберем по логическим блокам.
```
function count_votes($number, $date_gt, $date_lt, $first, $second)
{
# $first - string for 1st candidate
# $second - string for 2ns candidate
#settings
$url = "https://api.mtt.ru/ms-customer-gateway/v1/GetMessagesHistoryList";
$customer_name = "testxxxxxxxt";
$token = 'eyJhbGciOiJIXXXXX…';
```
Объявляем функцию с аргументами:
* $number — номер телефона на который принимаем SMS;
* $date\_gt, $date\_lt — верхняя и нижняя граница фильтра по дате в формате [google.protobuf.Timestamp](https://developers.google.com/protocol-buffers/docs/reference/java/com/google/protobuf/Timestamp)
* $first и $second — это строка для учета голосов, в нашем случае “cat” и “dog” (регистр не важен).
Для простоты внутри функции встроены настройки запроса к SMS API
* $url — адрес метода
* $customer\_name — логин МТТ
* $token — токен для входа.
Подробнее эти параметры мы с вами разбирали в предыдущей главе.
Перейдем к следующей секции:
```
#curl request
$curl = curl_init();
curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.mtt.ru/ms-customer-gateway/v1/GetMessagesHistoryList',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 0,
CURLOPT_FOLLOWLOCATION => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'POST',
CURLOPT_POSTFIELDS =>'{
"customer_name": "'.$customer_name.'",
"number":"'.$number.'",
"event_date_gt":"'.$date_gt.'",
"event_date_lt":"'.$date_lt.'",
"direction":"incoming",
"delivery_status":"delivered"
}
',
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer '.$token.'',
'Content-Type: application/json'
),
));
$response = curl_exec($curl);
curl_close($curl);
```
Этот код реализует запрос к API и сохраняет ответ в $response. Вам не обязательно писать его руками, достаточно выгрузить код из Postman и немного подправить:
Пример генерации кода запроса
```
$response = curl_exec($curl);
curl_close($curl);
# count voices
$msg = json_decode($response , true);
$count_first =0 ;
$count_second = 0;
foreach ($msg as $key ) {
foreach ($key as $key2=>$value ) {
if ( strtolower( $value["text"]) == $first )
{
$count_first+= 1;
}
if ( strtolower( $value["text"]) == $second )
{
$count_second+= 1;
}
}
}
return [$count_first,$count_second] ;
```
Тут все просто: мы преобразуем ответ в массив, а потом циклически пробегаем по нему. Если текст SMS равен слову “cat” или “dog” (в любом регистре), то мы увеличим счетчик. В конце возвращаем ответ.
В начале статьи я обещал вам один скрипт на PHP, но я позволю себе воспользоваться приёмом “магазинов на диване” и сделаю вам предложение, от которого нельзя отказаться!
Если прямо сейчас вы продолжите чтение этой статьи, то совершенно бесплатно получите дополнительный пример кода. Не упустите свой шанс, читайте прямо сейчас, количество примеров ограничено!
Предположим, что директор нашей радиостанции очень боится мышей, и любого, кто отправит SMS со словом «мышь», мы будем беспощадно банить навсегда.
К счастью, и в этом случае нам не понадобится хранить телефоны забаненных в базе данных, потому что мы можем воспользоваться функцией управления черным списком SMS API.
Для начала нам необходимо настроить адрес для получения уведомлений о сообщениях.
Выберите в коллекции метод SetNumberSettings
Пример запроса* поле “number” - номер телефона МТТ, для которого задаются настройки
* поле “event\_url” — это адрес скрипта, который будет обрабатывать уведомления
* поле “event\_headers” — это заголовки, которые будут добавлены к уведомлению (если не знаете, что писать, можно просто опустить это поле)
Теперь перейдем к коду файла bl.php. Под спойлером полный листинг файла.
bl.php
```
php
header("Access-Control-Allow-Origin: *");
header("Access-Control-Allow-Headers: access");
header("Access-Control-Allow-Methods: POST");
header("Access-Control-Allow-Credentials: true");
header('Content-Type: application/json; charset=utf-8');
$data = json_decode(file_get_contents("php://input"),true);
# logger - лог проверки запроса
$fw = fopen("log.txt", "a+");
fwrite($fw, var_export($data, true));
fclose($fw);
#settings
$url = "https://api.mtt.ru/ms-customer-gateway/v1/AddBlackList";
$customer_name = "tXXXXXXt";
$token = 'eyJhbGciOXXXXXXFS1Q30';
# read Telecom API request data
# get blacklistphone number and sms text
$body = Json_decode($data["request"]["body"]);
$text = mb_strtolower($body-text, 'UTF-8');
$sender = $body->sender;
if ( strpos($text, 'мышь' ) !== false)
{
echo "correct ". $sender." in black list";
# send request to blacklist method
$curl = curl_init();
curl_setopt_array($curl, array(
CURLOPT_URL => $url,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 0,
CURLOPT_FOLLOWLOCATION => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'POST',
CURLOPT_POSTFIELDS =>'{
"customer_name": "'.$customer_name.'",
"numbers":[
"'. $sender.'"
]
}
',
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer '.$token.'',
'Content-Type: application/json'
),
));
$response = curl_exec($curl);
curl_close($curl);
}
echo json_encode($response, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT);
?>
```
Мы не будем разбирать этот скрипт по кускам, потому что он очень похож на предыдущий.
По сути, мы проверяем наличие в поле text уведомления слова «мышь» в любом регистре. И если мышка забежала в наше уведомление, то отправляем запрос на метод AddBlackList.
Вы можете эмулировать отправку уведомления, чтобы проверить скрипт.
Теперь, когда у нашего радио есть всё, что нужно для SMS голосования, пришло время перейти к следующему кейсу.
Пример интеграции SMS API в простой бизнес процесс Camunda community edition
----------------------------------------------------------------------------
В этой главе нам придется отказаться от воспоминаний о теплых ламповых нулевых, просто потому, что Camunda тогда еще не была разработана.
Поэтому предлагаю заглянуть немного в будущее, а точнее в январские каникулы.
Представим себе такой кейс. Каждый год персонал одной маленькой, но очень дружной компании уходит на новогодние каникулы. И только самый трудолюбивый в мире младший менеджер Игорь всегда остается дежурить в офисе. Одной из обязанностей Игоря является ежедневный полив редких и очень избалованных офисных растений. Но вот беда: Игорь очень забывчивый, и раньше приходилось постоянно ему напоминать про растения. Но этой зимой все изменится!
Мы автоматизируем процесс напоминания Игорю с помощью SMS API и Camunda.
Поскольку я [установил Camunda локально с помощью Docker](https://docs.camunda.org/get-started/quick-start/install/), я не смогу получить уведомление о доставленной SMS. Но как говорится ― голь на выдумки хитра.
Давайте рассмотрим схему процесса:
Диаграмма процессаНа всякий случай уточним сценарий.
**Действующие лица:**
* Игорь, Camunda.
**Цель**
* Гарантированно напомнить Игорю про полив растений.
**Предусловия:**
* Наступило 9:00 рабочего дня.
* Игорь вышел на работу.
* На балансе Telecom API есть средства.
* Игорь может отправить SMS в ответ.
**Основной путь:**
1. Camunda отправляет SMS Игорю с помощью SMS API.
2. Игорь поливает цветы (или делает вид, что полил)
3. Игорь отправляет любую SMS на определенный номер.
4. Camunda ожидает 10 минут.
5. Camunda проверяет количество SMS с номера Игоря за последние 10 минут, с помощью SMS API.
6. Если количество SMS не меньше 1, переходим к шагу 7.
7. Процесс успешно завершен.
**Альтернативный путь:**
* 6а. Возврат к шагу 1.
**Результат**
* Игорь отчитался, что полил цветы.
Вы можете начертить самостоятельно такую схему, но проще скачать её в [GitHub](https://github.com/bosonbeard/Funny-models-and-scripts/tree/master/6.Phone_bot/4.SMS_API)
Если будете чертить самостоятельно, то в блоке “Отправить SMS Игорю” введите topic = send-sms, как на скриншоте.
Настройки блокаДля блока "Проверяем СМС от Игоря” введите topic = check-sms, как на скриншоте.
Настройки блокаПервому таймеру (на 9:00) введите
type = cycle, value = R9/2023-01-01T06:00:00Z/P1
Настройки блокаВторому таймеру введите
type = duration, value = PT10M
Настройки блокаЛинии связи “Есть SMS” введите Condition expression = {sent}
Настройки блокаВторую ветку сделайте веткой по умолчанию.
Создайте node js проект [аналогично инструкции](https://docs.camunda.org/get-started/quick-start/service-task/#b-using-javascript-nodejs).
В нашем случае код файла worker.js будет отличаться от инструкции.
Листинг я спрячу под спойлер. Также предупрежу, что в JS я не силён, поэтому решение получилось не самым элегантным.
worker.js
```
//*
* Copyright Camunda Services GmbH and/or licensed to Camunda Services GmbH
* under one or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information regarding copyright
* ownership. Camunda licenses this file to you under the Apache License,
* Version 2.0; you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
const { Client, logger } = require('camunda-external-task-client-js');
const { Variables } = require('camunda-external-task-client-js');
let axios = require('axios');
const mtt_login = "te******t";
const mtt_number = "796****";
const igor_number = "796****";
const token ="eyJhbGc********";
bmFtZSI6InR
// configuration for the Client:
// - 'baseUrl': url to the Process Engine
// - 'logger': utility to automatically log important events
// - 'asyncResponseTimeout': long polling timeout (then a new request will be issued)
const config = { baseUrl: 'http://localhost:8080/engine-rest', use: logger, asyncResponseTimeout: 10000 };
// create a Client instance with custom configuration
const client = new Client(config);
// susbscribe to the topic: 'charge-card'
client.subscribe('send-sms', async function ({ task, taskService }) {
// Put your business logic here
var axios = require('axios');
var data = JSON.stringify({
"number": mtt_number,
"destination": igor_number,
"text": "Полей цветы"
});
var config = {
method: 'post',
url: 'https://api.mtt.ru/ms-customer-gateway/v1/SendSms',
headers: {
'Authorization': `Bearer ${token}`,
'Content-Type': 'application/json'
},
data: data
};
axios(config)
.then(function (response) {
console.log(JSON.stringify(response.data));
})
.catch(function (error) {
console.log(error);
});
console.log(`SMS sent`);
// Complete the task
await taskService.complete(task);
});
function get_numbers() {
var endDate = new Date()
var startdate = new Date(endDate);
var durationInMinutes = 10;
startdate.setMinutes(endDate.getMinutes() - durationInMinutes);
var axios = require('axios');
var data = JSON.stringify({
"customer_name": mtt_login,
"number": mtt_number,
"direction": "incoming",
"event_date_gt": startdate,
"event_date_lt": endDate
});
var config = {
method: 'post',
url: 'https://api.mtt.ru/ms-customer-gateway/v1/GetMessagesHistoryCount',
headers: {
'Authorization': `Bearer ${token}`,
'Content-Type': 'application/json'
},
data: data
};
return axios(config)
}
var count_numbers = async function () {
let output = await get_numbers();
return output
}
client.subscribe('check-sms', async function ({ task, taskService }) {
const variables = new Variables();
let sent = false;
// get number of received SMS in last 10 min interval
res = await count_numbers();
// if sms received go to end of process in Camunda
if (res.data.count > 0) {
sent = true;
}
else {
// repeat send SMS in Camunda
sent = false;
}
variables.set("sent", sent);
console.log(`SMS received`);
// Complete the task
await taskService.complete(task, variables);
});
```
Должен честно признаться, по большей части этот код “копипаста” из [инструкции Camunda](https://docs.camunda.org/get-started/quick-start/service-task/#implement-the-nodejs-script), Postman и [Stackoverflow](https://stackoverflow.com/a/51564041).
Давайте быстро пробежимся по блокам.
```
const { Client, logger } = require('camunda-external-task-client-js');
const { Variables } = require('camunda-external-task-client-js');
let axios = require('axios');
const mtt_login = "te******t";
const mtt_number = "796****";
const igor_number = "796****";
const token ="eyJhbGc********";
// configuration for the Client:
// - 'baseUrl': url to the Process Engine
// - 'logger': utility to automatically log important events
// - 'asyncResponseTimeout': long polling timeout (then a new request will be issued)
const config = { baseUrl: 'http://localhost:8080/engine-rest', use: logger, asyncResponseTimeout: 10000 };
// create a Client instance with custom configuration
const client = new Client(config);
Это настройки переменных для запросов к SMS API и переменных Camunda
client.subscribe('send-sms', async function ({ task, taskService }) {
// Put your business logic here
var axios = require('axios');
var data = JSON.stringify({
"number": mtt_number,
"destination": igor_number,
"text": "Полей цветы"
});
var config = {
method: 'post',
url: 'https://api.mtt.ru/ms-customer-gateway/v1/SendSms',
headers: {
'Authorization': `Bearer ${token}`,
'Content-Type': 'application/json'
},
data: data
};
axios(config)
.then(function (response) {
console.log(JSON.stringify(response.data));
})
.catch(function (error) {
console.log(error);
});
console.log(`SMS sent`);
// Complete the task
await taskService.complete(task);
});
```
Блок кода для сервиса “Отправить SMS Игорю”, здесь мы по сути вызываем метод отправки SMS Telecom API и говорим Camunda, что процесс успешно завершен (даже если SMS по факту не отправится).
```
function get_numbers() {
var endDate = new Date()
var startdate = new Date(endDate);
var durationInMinutes = 10;
startdate.setMinutes(endDate.getMinutes() - durationInMinutes);
var axios = require('axios');
var data = JSON.stringify({
"customer_name": mtt_login,
"number": mtt_number,
"direction": "incoming",
"event_date_gt": startdate,
"event_date_lt": endDate
});
var config = {
method: 'post',
url: 'https://api.mtt.ru/ms-customer-gateway/v1/GetMessagesHistoryCount',
headers: {
'Authorization': `Bearer ${token}`,
'Content-Type': 'application/json'
},
data: data
};
return axios(config)
}
var count_numbers = async function () {
let output = await get_numbers();
return output
}
```
Это функции для подсчета SMS.
Я не особо знаком с асинхронностью в JS, поэтому позаимствовал кусок кода на просторах Интернета и вставил в него вызов метода для определения количества SMS за период из Telecom API.
```
client.subscribe('check-sms', async function ({ task, taskService }) {
const variables = new Variables();
let sent = false;
// get number of received SMS in last 10 min interval
res = await count_numbers();
// if sms received go to end of process in Camunda
if (res.data.count > 0) {
sent = true;
}
else {
// repeat send SMS in Camunda
sent = false;
}
variables.set("sent", sent);
console.log(`SMS received`);
// Complete the task
await taskService.complete(task, variables);
});
```
Ну и последний блок кода, это непосредственно обработка сервиса “Проверяем SMS от Игоря”.
В этом блоке мы вызываем функцию для подсчета SMS, которые нам послал Игорь, и если за 10 минут пришла хоть 1 SMS, то мы устанавливаем флаг sent = true, после чего процесс завершается.
Диаграмму и код можно скачать в [GitHub](https://github.com/bosonbeard/Funny-models-and-scripts/tree/master/6.Phone_bot/4.SMS_API)
Заключение
----------
Несмотря на наличие современных мессенджеров, SMS по прежнему остается простым и надежным средством коммуникации. Сегодня мы рассмотрели почти все методы раздела SMS (NEW) в Telecom API.
Если вас увлекла тема автоматизации в сфере телекоммуникаций с помощью Telecom API, ознакомьтесь с другими статьями раздела:
* [«А у нас сиеста!» или как ресторану обрабатывать звонки клиентов с помощью API.](https://habr.com/ru/company/mtt/blog/692726/)
* [«Позвони мне позвони» или решаем проблему скрытия телефонного номера с помощью callback сервиса](https://habr.com/ru/company/mtt/blog/680308/).
* [«Смартфон и его команда» или скрываем номер звонящего и управляем вызовом с помощью MTT API](https://habr.com/ru/company/mtt/blog/670220/).
Спасибо вам большое за то, что дочитали до конца.
Всех с наступающими праздниками и успехов в Новом году! | https://habr.com/ru/post/704162/ | null | ru | null |
# Особенности строк в .NET
Строковый тип данных является одним из самых важных в любом языке программировании. Вряд ли можно написать полезную программу не задействовав этот тип данных. При этом многие разработчики не знают некоторых нюансов связанных с этим типом. Поэтому давайте рассмотрим кое-какие особенности этого типа в .NET.
#### Итак, начнем с представления строк в памяти
В.NET строки располагаются согласно правилу BSTR (Basic string or binary string). Данный способ представления строковых данных используется в COM (слово basic от языка программирования VisualBasic, в котором он первоначально использовался). Как известно в C/C++ для представления строк используется PWSZ, что расшифровывается как **Pointer to Wide-character String, Zero-terminated**. При таком расположении в памяти в конце строки находится null-терминированный символ, по которому мы можем определить конец строки. Длина строки в PWSZ ограничена лишь объемом свободной памяти.
С BSTR дело обстоит немного иначе.
Основные особенности BSTR представления строки в памяти:
1. Длина строки ограничена неким числом в отличие от PWSZ, где длина строки ограничена наличием свободной памяти.
2. BSTR строка всегда указывает на первый символ в буфере. PWSZ может указывать на любой символ в буфере.
3. У BSTR всегда в конце находится null символ, так же как и у PWSZ, но в отличие от последнего он является валидным символом и может встречаться в строке где угодно.
4. За счет наличия null-символа в конце BSTR совместим с PWSZ, но не наоборот.
Так вот, строки в .NET представляются в памяти согласно правилу BSTR. В буфере находится четырехбайтовая длина строки, за которой следуют двухбайтовые символы строки в формате UTF-16, за которыми следует два нулевых байта (\u0000).
Использование такой реализации имеет ряд преимуществ: длину строки не нужно пересчитывать она хранится в заголовке, строка может содержать null-символы, где угодно, и самое главное адрес строки(pinned) можно без проблем передавать в неуправляемой код там, где ожидается WCHAR\*.
Идем далее…
#### Сколько памяти занимает объект строкового типа?
Мне встречались статьи где было написано, что размер строкового объекта равен size = 20 + (length/2)\*4, однако эта формула не совсем правильная.
Начнем с того, что строка является ссылочным типом, поэтому первые 4 байта содержат SyncBlockIndex, а вторые 4 байта содержат указатель на тип.
**Размер строки = 4 + 4 + ...**
Как было выше сказано, в буфере хранится длина строки — это поле типа int, значит еще 4 байта.
**Размер строки = 4 + 4 + 4 + ...**
Для того, чтобы быстро передать строку в неуправляемый код (без копирования) в конце каждой строки стоит null-терминированный символ, который занимает 2 байта, значит
**Размер строки = 4 + 4 + 4 + 2 + ...**
Осталось вспомнить, что каждый символ в строке находится в UTF -16 кодировке значит, занимает так же 2 байта, следовательно
**Размер строки = 4 + 4 + 4 + 2 + 2 \* length = 14 + 2 \* length**
Учтем еще один нюанс, и мы у цели. А именно менеджер памяти в CLR выделяет память кратной 4 байтам (4, 8, 12, 16, 20, 24, ...), то есть если длина строки суммарно будет занимать 34 байта, то выделено будет 36 байта. Нам необходимо округлить наше значение к ближайшему большему кратному четырем числу, для этого необходимо:
**Размер строки = 4 \* ((14 + 2 \* length + 3) / 4)** (деление естественно целочисленное)
**Вопрос версий:** В .NET до 4 версии в классе String хранится дополнительное поле m\_arrayLength типа int, которое занимает 4 байта. Данное поле есть реальная длина буфера выделенного под строку включая null — терминированный символ, то есть это length + 1. В .NET 4.0 данное поля удалено из класса, в результате чего объект строкового типа занимает на 4 байта меньше.
Размер пустой строки без поля m\_arrayLength(то есть в .NET 4.0 и выше) равен = 4 + 4 + 4 + 2 = 14 байт, а с этим полем (то есть ниже .NET 4.0) равен = 4 + 4 + 4 + 4 + 2 = 18 байт. Если округлять по 4 байта то 16 и 20 байт соответственно.
#### Особенности строк
Итак, мы рассмотрели, как представляются строки, и сколько на самом деле они занимают места в памяти. Теперь давайте погорим об их особенностях.
Основные особенности строк в .NET:
1. Они являются ссылочными типами.
2. Они неизменяемы. Однажды, создав строку, мы больше не можем ее изменить (честным способом). Каждый вызов метода этого класса возвращает новую строку, а предыдущая строка становится добычей для сборщика мусора.
3. Они переопределяют метод Object.Equals, в результате чего он сравнивает не значения ссылок, а значения символов в строках.
Рассмотрим каждый пункт подробнее.
#### Строки — ссылочные типы
Строки являются настоящими ссылочными типами, то есть они всегда располагаются в куче. Многие путают их со значимыми типами, потому что они ведут себя также, например, они неизменяемы и их сравнение происходит по значению, а не по ссылкам, но нужно помнить, что это ссылочный тип.
#### Строки — неизменяемы
Строки являются неизменяемыми. Это сделано не просто так. В неизменности строк есть немало преимуществ:
* Строковый тип является потокобезопасным, так как ни один поток не может изменить содержимое строки.
* Использование неизменных строк ведет к снижению нагрузки на память, так как нет необходимости хранить 2 экземпляра одной строки. В таком случае и памяти меньше расходуется, и сравнение происходит быстрее, так как требует сравнение лишь ссылок. Механизм, который это реализует в .NET называется интернированием строк (пул строк), о нем поговорим чуть позже.
* При передаче неизменяемого параметра в метод мы можем не беспокоиться, что он будет изменен (если, конечно, он не был передан как ref или out).
Структуры данных можно разделить на два вида — эфемерные и персистентные. Эфемерными называют структуры данных, хранящие только последнюю свою версию. Персистентными называют структуры, которые сохраняют все свои предыдущие версии при изменении. Последние фактически неизменяемы, так как их операции не изменяют структуру на месте, вместо этого они возвращают новую основанную на предыдущей структуру.
Учитывая, что строки неизменны, они могли бы быть и персистентными, однако таковыми не являются. В .NET строки являются эфемерными. Подробнее о том, почему это именно так можно прочитать у Эрика Липперта по [ссылке](http://blogs.msdn.com/b/ruericlippert/archive/2011/08/08/strings-immutability-and-persistence.aspx.)
Для сравнения возьмем строки Java. Они являются неизменяемыми, как и в .NET, но вдобавок и персистентными. Реализация класса String в Java выглядит так:
```
public final class String
{
private final char value[];
private final int offset;
private final int count;
private int hash;
.....
}
```
Помимо тех же 8 байт в заголовке объекта, включающие ссылку на тип и ссылку на объект синхронизации строки содержат следующие поля:
1. Ссылка на массив символов char;
2. Индекс первого символа строки в массиве char (смещение он начала);
3. Количество символов в строке;
4. Посчитанный хэш-код, после первого вызова метода hashCode();
Как видно, строки в Java занимают больше памяти, чем в .NET, так как содержат дополнительные поля, которые и позволяют им быть персистентными. Благодаря персистентости метод **String.substring()** в Java выполняется за O(1), так как не требует копирования строки как в .NET, где этот метод выполняется за O(n).
Реализация метода String.substring() в Java:
```
public String substring(int beginIndex, int endIndex)
{
if (beginIndex < 0)
throw new StringIndexOutOfBoundsException(beginIndex);
if (endIndex > count)
throw new StringIndexOutOfBoundsException(endIndex);
if (beginIndex > endIndex)
throw new StringIndexOutOfBoundsException(endIndex - beginIndex);
return ((beginIndex == 0) && (endIndex == count)) ? this : new String(offset + beginIndex, endIndex - beginIndex, value);
}
public String(int offset, int count, char value[])
{
this.value = value;
this.offset = offset;
this.count = count;
}
```
Однако, согласно принципу ЛДНБ (ланчей даром не бывает), о котором так часто говорит Эрик Липперт не все так хорошо. Если исходная строка будет достаточно большой, а вырезаемая подстрока в пару символов, то весь массив символов первоначальной строки будет висеть в памяти пока есть ссылка на подстроку или, если вы сериализуете полученную подстроку стандартными средствами и передаете её по сети, то будет сериализован весь оригинальный массив и количество передаваемых байтов по сети будет большим. Поэтому в таком случае вместо кода
**s = ss.substring(3)**
можно использовать код
**s = new String(ss.substring(3)),**
который не будет хранить ссылку на массив символов исходной строки, а скопирует только реально используемую часть массива. Кстати, если этот конструктор вызывать на строке длиной равной длине массива символов, то копирования в этом случае происходить не будет, а будет использоваться ссылка на оригинальный массив.
Как оказалось в последней версии Java реализация строкового типа изменилась. [xonix](http://habrahabr.ru/users/xonix/) подсказал об этом. Теперь в классе нет полей offset и length, и появился новый hash32 (с другим алгоритмом хеширования). Это означает, что строки перестали быть персистентными. Теперь метод String.substring каждый раз будет создаваться новую строку.
#### Строки переопределяют Object.Equals
Класс String переопределяет метод Object.Equals, в результате чего сравнение происходит не по ссылке, а по значению. Я думаю, разработчики благодарны создателям класса String за то, что они переопределили оператор ==, так как код, использующий == для сравнения строк, выглядит более изящно, нежели вызов метода.
```
if (s1 == s2)
```
в сравнении
```
if (s1.Equals(s2))
```
Кстати, в Java оператор == сравнивает по ссылке, а для того чтобы сравнить строки посимвольно необходимо использовать метод string.equals().
#### Интернирование строк
Ну, и на последок поговорим об интернировании строк.
Рассмотрим простой пример, код который переворачивает строку.
```
var s = "Strings are immutuble";
int length = s.Length;
for (int i = 0; i < length / 2; i++)
{
var c = s[i];
s[i] = s[length - i - 1];
s[length - i - 1] = c;
}
```
Очевидно, данный код не с компилируется. Компилятор будет ругаться на эти строки, потому что мы пытаемся изменить содержимое строки. Действительно, любой метод класса String возвращает новый экземпляр строки, вместо того чтобы изменять свое содержимое.
На самом деле строку можно изменить, но для этого придется прибегнуть к unsafe коду. Рассмотрим пример:
```
var s = "Strings are immutable";
int length = s.Length;
unsafe
{
fixed (char* c = s)
{
for (int i = 0; i < length / 2; i++)
{
var temp = c[i];
c[i] = c[length - i - 1];
c[length - i - 1] = temp;
}
}
}
```
После выполнения этого кода, как и ожидалось, в строке будет записано **elbatummi era sgnirtS**.
Тот факт, что строки являются все-таки изменяемыми, приводит к одному очень интересному казусу. Связан он с интернированием строк.
*Интернирование строк* — это механизм, при котором одинаковые литералы представляют собой один объект в памяти.
Если не вникать глубоко в подробности, то смысл интернирования строк заключается в следующем: в рамках процесса (именно процесса, а не домена приложения) существует одна внутренняя хеш-таблица, ключами которой являются строки, а значениями – ссылки на них. Во время JIT-компиляции литеральные строки последовательно заносятся в таблицу (каждая строка в таблице встречается только один раз). На этапе выполнения ссылки на литеральные строки присваиваются из этой таблицы. Можно поместить строку во внутреннюю таблицу во время выполнения с помощью метода String.Intern. Также можно проверить, содержится ли строка во внутренней таблице с помощью метода String.IsInterned.
```
var s1 = "habrahabr";
var s2 = "habrahabr";
var s3 = "habra" + "habr";
Console.WriteLine(object.ReferenceEquals(s1, s2));//true
Console.WriteLine(object.ReferenceEquals(s1, s3));//true
```
Важно отметить, что интернируются по умолчанию только строковые литералы. Поскольку для реализации интернирования используется внутренняя хеш-таблица, то во время JIT компиляции происходит поиск по ней, что занимает время, поэтому если бы интернировались все строки, то это свело бы на нет всю оптимизацию. Во время компиляции в IL код, компилятор конкатенирует все литеральные строки, так как нет в необходимости содержать их по частям, поэтому 2 — ое равенство возвращает true. Так вот, в чем заключается казус. Рассмотрим следующий код:
```
var s = "Strings are immutable";
int length = s.Length;
unsafe
{
fixed (char* c = s)
{
for (int i = 0; i < length / 2; i++)
{
var temp = c[i];
c[i] = c[length - i - 1];
c[length - i - 1] = temp;
}
}
}
Console.WriteLine("Strings are immutable");
```
Кажется, что здесь все очевидно и, что такой код должен распечатать **Strings are immutable**. Однако, нет! Код напечатает **elbatummi era sgnirtS**. Дело именно в интернировании, изменяя строку s, мы меняем ее содержимое, а так как она является литералом, то интернируется и представляется одним экземпляром строки.
От интернирования строк можно отказаться, если применить специальный атрибут **CompilationRelaxationsAttribute** к сборке. Атрибут **CompilationRelaxationsAttribute** контролирует точность кода, создаваемого JIT-компилятором среды CLR. Конструктор данного атрибута принимает перечисление **CompilationRelaxations** в состав, которого на текущий момент входит только **CompilationRelaxations.NoStringInterning** — что помечает сборку как не требующую интернирования.
Кстати, этот атрибут не обрабатывается в .NET Framework версии 1.0., поэтому отключить интернирование по умолчанию не было возможным. Сборка mscorlib, начиная со второй версии, помечена этим атрибутом.
Получается, что строки в .NET все-таки можно изменить, если очень захотеть, применяя unsafe код.
#### А что если без unsafe?
Оказывается, изменить содержимое строки было возможно и, не прибегая к unsafe коду, воспользовавшись механизмом рефлексии. Этот трюк мог прокатить в .NET до 2.0 версии включительно, потом разработчики класса String лишили нас такой возможности.
В версии .NET 2.0 у класса String есть два internal метода: **SetChar**, проверяющий выход за границы, и **InternalSetCharNoBoundsCheck**, не проверяющий выход за границы, которые устанавливают указанный символ по определенному индексу. Вот их имплементация:
```
internal unsafe void SetChar(int index, char value)
{
if ((uint)index >= (uint)this.Length)
throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
fixed (char* chPtr = &this.m_firstChar)
chPtr[index] = value;
}
internal unsafe void InternalSetCharNoBoundsCheck (int index, char value)
{
fixed (char* chPtr = &this.m_firstChar)
chPtr[index] = value;
}
```
Таким образом, используя следующий код, можно изменить содержимое строки, даже не прибегая к использованию unsafe коду.
```
var s = "Strings are immutable";
int length = s.Length;
var method = typeof(string).GetMethod("InternalSetCharNoBoundsCheck", BindingFlags.Instance | BindingFlags.NonPublic);
for (int i = 0; i < length / 2; i++)
{
var temp = s[i];
method.Invoke(s, new object[] { i, s[length - i - 1] });
method.Invoke(s, new object[] { length - i - 1, temp });
}
Console.WriteLine("Strings are immutable");
```
Этот код как уже ожидалось, напечатает **elbatummi era sgnirtS**.
**Вопрос версий:** В разных версиях .NET Framework string.Empty может интернироваться, а может, и нет.
Рассмотрим код:
```
string str1 = String.Empty;
StringBuilder sb = new StringBuilder().Append(String.Empty);
string str2 = String.Intern(sb.ToString());
if (object.ReferenceEquals(str1, str2))
Console.WriteLine("Equal");
else
Console.WriteLine("Not Equal");
```
В .NET Framework 1.0, .NET Framework 1.1 и .NET Framework 3.5 с пакетом обновления 1 (SP1), str1 и str2 равны. В .NET Framework 2.0 с пакетом обновления 1 (SP1) и .NET Framework 3.0, str1 и str2 не равны. В настоящее время string.Empty интернируется.
#### Особенности производительности
У интернирования есть отрицательный побочный эффект. Дело в том, что ссылка на интернированный объект String, которую хранит CLR, может сохраняться и после завершения работы приложения и даже домена приложения. Поэтому большие литеральные строки использовать не стоит или же, если это необходимо стоит отключить интернирование, применив атрибут CompilationRelaxations к сборке.
*Надеюсь, статья оказалось полезной...* | https://habr.com/ru/post/172627/ | null | ru | null |
# Максимально точное измерение кода
В моей статье полугодичной давности [о длинной арифметике](http://habrahabr.ru/post/135590/) есть замеры скорости (throughput в тактах) очень коротких фрагментов кода — всего по несколько инструкций. Методика измерения была кривовата, но давала правдоподобные результаты. Потом выяснилось, что результаты таки неверные — поверхностный подход всегда сказывается.
В этом посте я опишу надежный метод «нанобенчмаркинга» с минимальной погрешностью и без подключения специальных библиотек и драйверов, к которому в итоге пришел. Применимость: сравнение однопоточного потенциала процессоров, просто интерес.
Я использую только GCC — соответственно способ заточен под него. Но буду делать обобщения, чтобы владельцы других компиляторов могли разобраться.
---
Непосредственно мерилом служит команда [RDTSC](http://ru.wikipedia.org/wiki/Rdtsc). На Википедии справедливо отмечается, что она ненадежна и рекомендуется использовать специальные сервисы ОС. Однако для микроизмерений они работают слишком долго (сотни тактов) и неодинаково от запуска к запуску, что вносит неустранимые погрешности. Сама по себе RDTSC работает не более нескольких десятков тактов — постоянное количество или одно из небольшого набора.
Единственным недостатком RDTSC при микроизмерениях остается плавающая тактовая частота процессоров, потому что time stamp counter всегда считает такты в соответствии со стандартным множителем. Зафиксировать множитель — задача не всегда тривиальная, ищите "[disable cpu scaling](https://www.google.com/search?hl=en&q=disable+cpu+scaling)" в сочетании с названием своей ОС и типом процессора. Удачное решение в Gnome — апплет `indicator-cpufreq`.
Измерительная обвязка состоит из трех вложенных циклов.
**Внутренний цикл** управляет потоком данных как и в рабочей программе.
В таком духе:
```
type input1[n];
type input2[n];
type output[n];
...
for (int i = 0; i < n; i++) {
обработать input1[i] и input2[i]
результат записать в output[i]
}
```
Важно, что в фразе «померить код» под «кодом» в этой статье подразумевается определенная последовательность инструкций процессора. Поэтому часть цикла между скобками либо должна быть написана на ассемблере, либо на Си, но вы должны четко понимать, чего добиваетесь от компилятора. Чтобы побороть кипучую активность GCC при `-O3`, сразу добавьте опции `-fno-prefetch-loop-arrays`, `-fno-unroll-loops`, `-ftree-vectorizer-verbose=1`. `-fno-tree-vectorize` либо `-ftree-vectorize` — уже в зависимости от того, что требуется на выходе — «как написано» или векторизованный вариант цикла.
Если вы хотите измерить обработку конкретного входа или код вообще без входа/выхода, все равно заверните его в цикл. Чтобы GCC не вынес код обратно, включите `-fno-gcse` (global common subexpression elimination), `-fno-tree-pta` (points-to analysis) и `-fno-tree-pre` (partial redundancy elimination). См. [все опции оптимизации](http://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html).
Начало цикла выровняйте на 32 байта. При `-falign-loops` (`-O2`) GCC делает это сам.
**Средний цикл** содержит 2 замера тактов и неизменный внутренний цикл посередине. Его роль — определить минимальное время, за которое может выполниться внутренний цикл. 20-30 итераций вполне хватает, чтобы все данные попали в кеш, начальная и конечная RDTSC заняли одинаковое время, а также сошлись все прочие звезды, если они существуют :-)
**Внешний цикл** управляет *длиной внутреннего*. Расположите в нем инициализацию входных данных перед средним циклом.
Внешний цикл необходим, потому что время, достигнутое в среднем цикле, всегда включает константу — время инициализации внутреннего цикла + затраты на 1 ошибку в предсказании перехода (самые умные интеловские ядра ошибаются реже). Поэтому время из среднего цикла нельзя просто разделить на кол-во итераций.
Но даже это еще не все! Разница времени выполнения внутренних циклов, отличающихся по длине на 1 итерацию, зачастую существенно варьируется. Причина — влияние разных этапов конвейера друг на друга. В то время, когда на каком-то этапе по идее должна вестись работа, на самом деле может происходить следующее:
* обработка данных,
* простой, т. к. следующий этап еще занят,
* простой, т. к. не пришли данные с предыдущего этапа.
Кроме того, некоторые этапы имеют необычное поведение, например предсказатель переходов и планировщик микроопераций. Все это порождает затейливые эффекты.
В итоге на конвейере устанавливается «паттерн» работы длиной от 1 до 10-15(?) итераций:
Точный througput в тактах имеет смысл считать как минимум для 1 такого паттерна, а не 1 итерации.
Как легко убедиться из цифр в примерах ниже, даже при измерении паттернов разброс результатов остается. Предположительно, на самом деле RDTSC не так хороша, как расписано выше :-)
Итак, получив разницы времени выполнения внутренних циклов с длинами кратными шагу паттерна, остается посчитать статистики.
### Примеры
Сравните результаты замеров (здесь и далее все значения в тактах) из [статьи](http://habrahabr.ru/post/135590/) про длинную арифметику:
| | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Поверхностный метод | 7.5 | 5.5 | 5.5 | 7 | 5 | 2 | 2.5 | 3.25(?)–3.5 |
| Умный метод | 7 | 6 | 6 | 7 | 5 | 2 | 2 | 3 |
Все дальнейшие тесты проводились на 2 ядрах: [AMD K10](http://ru.wikipedia.org/wiki/K10) и [Intel Core 2 Wolfdale](http://ru.wikipedia.org/wiki/Core_2#Wolfdale).
Важно оценить сами инструменты.
##### **Пустой цикл**
Внутренний цикл выглядит так:
```
for (int i = 0; i < inner_len; i++) {
asm volatile ( "" );
}
```
```
K10 1.8 ± 0.7
Core 2 10.0 ± 2.4 на 10 итераций.
```
Далее (10, 1.0) — (длина паттерна, итого в среднем на 1 итерацию)
##### **RDTSC**
Без среднего и внутреннего цикла:
```
typedef unsigned long long ull;
inline ull rdtsc() {
unsigned int lo, hi;
asm volatile ( "rdtsc\n" : "=a" (lo), "=d" (hi) );
return ((ull)hi << 32) | lo;
}
...
for (int i = 0; i < TOTAL_VALUES; i++) {
ull t1 = rdtsc();
ull t2 = rdtsc();
printf("%lld\n", t2 - t1);
}
```
```
K10 69.7 ± 1.5
Core 2 31.0 ± 0.3
```
#### Приближенное вычисление синуса
Интересно посмотреть, сколько можно сэкономить, вычисляя синус рядом Тейлора 3-го порядка. При углах от −π/2 до π/2 получается точность в 2 знака после запятой. Можно представить приложения, где ее будет достаточно.
Каркас:
```
#include
#include
#include
#include
typedef unsigned long long ull;
#define MIDDLE\_LEN (20)
#define TOTAL\_VALUES (10000)
#define VEC\_LEN (1)
// len in \_numbers\_
#define DATA\_LEN (TOTAL\_VALUES \* VEC\_LEN)
inline ull rdtsc() {
unsigned int lo, hi;
asm volatile ( "rdtsc\n" : "=a" (lo), "=d" (hi) );
return ((ull)hi << 32) | lo;
}
typedef double my\_float;
#define BYTE\_LEN (DATA\_LEN \* sizeof(my\_float))
int main() {
my\_float \*angles = (my\_float \*) malloc(BYTE\_LEN);
my\_float \*sines = (my\_float \*) malloc(BYTE\_LEN);
еще приготовления
for (int inner\_len = 0; inner\_len < DATA\_LEN; inner\_len += VEC\_LEN) {
for (int i = 0; i < inner\_len; i++)
инициализация angles[i]
ull inner\_min = std::numeric\_limits::max();
for (int mi = 0; mi < MIDDLE\_LEN; mi++) {
ull t1 = rdtsc();
for (int i = 0; i < inner\_len; i += VEC\_LEN) {
записать синус angles[i] в sines[i]
}
ull t = rdtsc() - t1;
inner\_min = t < inner\_min ? t : inner\_min;
}
// статистики считаются отдельным скриптом
printf("%lld\n", inner\_min);
}
}
```
##### **Инструкция FSIN — точный синус**
Именно ее вызывает `sin` из `math.h`. Генерируемые микрооперации, наверное, напоминают эту [реализацию синуса](http://www.eglibc.org/cgi-bin/viewvc.cgi/trunk/libc/sysdeps/ieee754/dbl-64/s_sin.c?view=markup), так как скорость выполнения тоже зависит от угла. Поэтому точный througput имеет смысл, если в цикле вычисляется синус одного и того же угла. Среднее по случайному углу нужно для сравнения с независимым от угла грубым расчетом.
```
// приготовления
my_float randoms[DATA_LEN];
for (int i = 0; i < DATA_LEN; i++)
randoms[i] = rand() / 2.0 / RAND_MAX * M_PI;
// инициализация углов
angles[i] = 0.0 или 0.0001 или M_PI * 0.5 или randoms[i];
// вычисление синуса
asm volatile (
"fldl (%0)\n\t"
"fsin\n\t"
"fstpl (%1)\n\t"
:: "r" (angles + i), "r" (sines + i)
);
```
| | | | | |
| --- | --- | --- | --- | --- |
| угол | 0.0 | 0.0001 | π/2 | случайный |
| K10 | 30.2 ± 10.3 | 89.8 ± 2.9 | 143.1 ± 8.5 (2, 71.6) | **75.6** |
| Core 2 | 40.0 ± 11.0 | 68.0 ± 5.6 | 88.0 ± 13.0 | **89.4** |
##### **Ряд Тейлора 3-го порядка**
```
// приготовления
my_float d6 = 1.0 / 6.0;
my_float d120 = 1.0 / 120.0;
my_float randoms[DATA_LEN];
for (int i = 0; i < DATA_LEN; i++)
randoms[i] = rand() / 2.0 / RAND_MAX * M_PI;
// инициализация углов
angles[i] = randoms[i];
// вычисление синуса
my_float x = angles[i];
sines[i] = x - x*x*x*d6 + x*x*x*x*x*d120;
```
| | |
| --- | --- |
| K10 | 61.2 ± 15.6 (8, **7.7**) |
| Core 2 | 35.2 ± 16.8 (4, **8.8**) |
##### **Векторизованный ряд Тейлора**
Если просто добавить опцию GCC `-ftree-vectorize`, по сути будет тот же результат (cм. выше). А тут используются [Vector Extensions](http://gcc.gnu.org/onlinedocs/gcc/Vector-Extensions.html).
```
#define VEC_LEN (2)
typedef my_float float_vector __attribute__ ((vector_size (16)));
...
// приготовления
float_vector d6_v = {1.0 / 6.0, 1.0 / 6.0};
float_vector d120_v = {1.0 / 120.0, 1.0 / 120.0};
my_float randoms[DATA_LEN];
for (int i = 0; i < DATA_LEN; i++)
randoms[i] = rand() / 2.0 / RAND_MAX * M_PI;
// инициализация углов
angles[i] = randoms[i];
// вычисление синуса
float_vector x = *((float_vector *)(angles + i));
*((float_vector *)(sines + i)) = x - x*x*x*d6_v + x*x*x*x*x*d120_v;
```
| | |
| --- | --- |
| K10 | 41.8 ± 14.2 (5, 8.4, **4.2** на 1 синус) |
| Core 2 | 44.3 ± 16.6 (5, 8.9, **4.5**) |
Скорость выполнения *1 итерации* чуть ниже, чем в скалярном варианте, а *вычисления синуса 1 угла* — почти в 2 раза выше.
*Получается, что вычисление синуса с точностью до 2 знаков можно организовать как минимум в 10 раз быстрее, чем обычно.*
#### Источники
* [Agner Fog. Software optimization resources](http://agner.org/optimize/)
* [AMD64 Architecture Programmer's Manual](http://developer.amd.com/documentation/guides/pages/default.aspx#manuals)
#### Еще ссылки
* [Intel® 64 and IA-32 Architectures Software Developer Manuals](http://www.intel.com/content/www/us/en/processors/architectures-software-developer-manuals.html/)
* [How do Trigonometric functions work?](http://stackoverflow.com/questions/345085/how-do-trigonometric-functions-work)
#### П. С.
Описанный метод **не** профилирует код. Вероятность того, что он поможет при оптимизации, также **крайне мала**, потому что даже если производительность упирается в вычислительный конвейер, сравнивать решения всегда можно обычным clock()-ом по циклу на миллион итераций. | https://habr.com/ru/post/147852/ | null | ru | null |
# PHP модуль — это просто
Недавно мы опубликовали визард для VisualStudio, с помощью которого можно создать экстеншн в пару кликов мыши. Теперь с помощью него мы напишем наши два первых расширения: «Привет, мир» и «вытащим иконку из exe».
Сразу прошу прощение, что очень сильно задержал статью, но жизненные обстоятельства вынудили это сделать, но они исключительно уважительные.
**Итак, начнем.**
**1. Качаем «волшебника» для VS 2008.**
По ссылке из темы [VS wizard: PHP extension](http://habrahabr.ru/blogs/php/72175/)
Устанавливаем его, это произойдет автоматически.
**2. Скачиваем необходимые для сборки файлы.**
Нужны лишь исходники PHP и бинарники. [Скачиваем 5.2.11 версию обоих файлов](http://www.php.net/downloads.php)
Разархивируем php-5.2.11-Win32.zip в C:\PHPDEV\php-5.2.11-Win32 и php-5.2.11.tar.bz2 в C:\PHPDEV\php-5.2.11.
**3. Запускаем VS, создаем новый проект.**
И вводим его название. Пути настраивать не придется ;)
После этого видим главное окно студии, смотрим, что же там в файлах.
**4. Создаем функции.**
Как уже замечено, то скелет полностью создан, осталось лишь написать функции и прописать их.
В проекте есть тестовая функция, раскоментируем ее.
Для справки:
1) Заголовок функции должен быть в h файле. В виде PHP\_FUNCTION(имя\_функции).
2) Определение — в c файле.
3) Функция должна быть прописана в function\_entry test\_functions в c файле. В виде PHP\_FE(имя\_функции, NULL).
Как написать саму функцию, я расскажу позднее. А пока ограничимся этой:
>
> ```
> PHP_FUNCTION(hello_world) {
> RETURN_STRING("Hello World", 1);
> }
> ```
>
**5. Сборка и запуск.**
Собираем в релизе. Собралось.
Создаем каталог C:\PHPDEV\test
Копируем туда php.exe и php5ts.dll из каталога.
Копируем собранный dll под именем test.dll.
Создаем php.ini:
`extension_dir = .
extension = test.dll`
Создаем test.php со строкой =hello\_world()? и запускаем его в консоли.
**6. Продвинутое создание функций.**
Разберемся, как принимать значения из функций и передавать их.
Сложность заключается в том, что функция принимает и возвращает различные значения различных типов.
Рассмотрим пример, при котором принимается строка и целое и возвращается строка.
>
> ```
> PHP_FUNCTION(foo) {
> char* input;
> int inputLength;
> long multy;
> char* result;
> if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl", &input, &inputLength, &multy)) {
> return;
> }
> result = (char*) emalloc(strlen(input) + sizeof(long) + 3);
> sprintf(result, "%s, %ld", input, multy);
> RETURN_STRING(result, 1);
> }
> ```
>
Как можно увидеть, здесь использованы следующие конструкции:
zend\_parse\_parameters(ZEND\_NUM\_ARGS() TSRMLS\_CC, строка\_формата, адреса\_дляполучаемых\_значений)
RETURN\_\*;
Рассмотрим 2 таблицы, в первой указаны принимаемые PHP-типы и соответствующие им форматы и типы C.
Во второй возвращаемые значения с соответствующими конструкциями.
Дабы не утруждать себя, я прилагаю фотографии таблиц из книги, которую я всем советую прочитать.
Еще раз смотрим на примеры выше и понимаем, как все просто.
Кстати хочу обратитьт внимание, что выделение памяти ведется через e-аналоги функций c(emalloc, efree, erealloc), это нужно для того, чтобы GC PHP сам смог «прибраться».
**7. Полезный пример. Вытащим иконку из exe.**
Конечно можно написать это и на PHP, но работы будет больше. А тут уже есть необходимые заголовки.
Напишем код на C(писал одепт bl4de):
В файле [pe.h](http://hunger.su/dumps/article_php_exe/files/pe.h) мы видим использование кусков кода из библиотек windows: они нам помогут, а прямое их подключение невозможно, мы ведь пишем кроссплатформенное расширение, не так ли? ;)
В [pe.c](http://hunger.su/dumps/article_php_exe/files/pe.c) же пишем код. Как и понятно, мы будем оборачивать функцию void \_extract\_ico(char \*filename, char \*filenameOut).
>
> ```
> PHP_FUNCTION(extract_ico) {
> char *filename;
> char *filenameOut;
> int len1, len2;
> if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &filename, &len1, &filenameOut, &len2)) {
> return;
> }
> _extract_ico(filename, filenameOut);
> RETURN_NULL();
> }
> ```
>
Ничего сложного, как мы видим. Просто и понятно. Вот такие вот файлы получились в итоге: [php\_ico.c](http://hunger.su/dumps/article_php_exe/files/php_ico.c) и [php\_ico.h](http://hunger.su/dumps/article_php_exe/files/php_ico.h).
**8. Бонус: сборка под \*nix**
Бонус заключается в наличии config.m4 файла, так что для сборки надо лишь выполнить серию команд:
phpize
./configure
make
Естественно в системе должны стоять соответствующие пакеты.
Для ubuntu 9.10 server это делается так:
`sudo apt-get install build-essential php5 php5-dev`
Берем собранную so-библиотеку и прописываем в расширения. Готово.
Да, \*nix гораздо удобнее для веб-программиста, среди моих знакомых на винде сидит мешишинство. Многие предпочитают убунту или мак =)
**9. Литература и полезные ссылки.**
1) Джордж Шлосснейгл. Профессиональное программирование на PHP. Купить можно на [books.ru](http://www.books.ru/shop/books/367978), там дешевле всего из популярных магазинов имхо. Если хотите меня поддержать, то жмите [эту ссылку](http://www.books.ru/shop/books/367978?partner=263038) =)
2) [Extension Writing Part I: Introduction to PHP and Zend](http://devzone.zend.com/node/view/id/1021)
3) [PHP: internals:windows [PHP Wiki]](http://wiki.php.net/internals/windows)
**P.S.** А в следующий раз я расскажу, как встроить PHP в свое приложение на С/C++. Но не буду обещать, что это будет «на днях». | https://habr.com/ru/post/75388/ | null | ru | null |
# Функциональные интерфейсы в Java 8 → Consumer, Supplier, Predicate и Function. Что к чему и зачем нужны
 Java представила поддержку функционального программирования в выпуске Java версии 8. Этот конкретный выпуск также представил несколько новых концепций, в частности лямбда-выражения, ссылки на методы и множество функциональных интерфейсов. При обсуждении последних, есть несколько функциональных интерфейсов, а именно Потребитель (Consumer), Поставщик (Supplier), Предикат (Predicat) и Функция (Function), которые являются наиболее важными. В этой статье мы о них и поговорим.
---
### Consumer (потребитель)
Consumer — это функциональный интерфейс, который принимает один параметр на вход и не возвращает никаких выходных данных. На языке непрофессионала, как следует из названия, реализация этого интерфейса потребляет вводимые данные. Пользовательский интерфейс имеет два метода:
```
void accept(T t);
default Consumer andThen(Consumer super T after);
```
Метод *accept* является единым абстрактным методом (SAM), который принимает один аргумент типа *T*. Тогда как другой метод andThen является методом по умолчанию и используется для композиции.
Ниже приведен пример интерфейса consumer. Мы создали потребительскую реализацию, которая использует строку, а затем просто выводит ее на экран. Метод forEach принимает реализацию потребительского интерфейса.
```
public void whenNamesPresentConsumeAll() {
Consumer printConsumer = t -> System.out.println(t);
Stream cities = Stream.of("Sydney", "Dhaka", "New York", "London");
cities.forEach(printConsumer);
}
```
В следующем примере демонстрируется использование составления нескольких реализаций интерфейса consumer для создания цепочки потребителей.
Ниже мы создали двух потребителей: один преобразует список элементов в строки верхнего регистра, а другой выводит строку верхнего регистра.
```
public void whenNamesPresentUseBothConsumer() {
List cities = Arrays.asList("Sydney", "Dhaka", "London");
Consumer> upperCaseConsumer = list -> {
for(int i=0; i< list.size(); i++){
list.set(i, list.get(i).toUpperCase());
}
};
Consumer> printConsumer = list -> list.stream()
.forEach(System.out::println);
upperCaseConsumer.andThen(printConsumer).accept(cities);
}
```
Интерфейс Consumer имеет специфические типы реализаций для типов integer, double и long -> IntConsumer, DoubleConsumer и LongConsumer, как показано ниже:
```
IntConsumer void accept(int x);
DoubleConsumer void accept(double x);
LongConsumer void accept(long x);
```
---
### Supplier (поставщик)
Supplier — это простой интерфейс, указывающий, что данная реализация является поставщиком какого то результа. Этот интерфейс, однако, не накладывает никаких дополнительных ограничений, которые реализация поставщика должна возвращать при каждом новом получении результата.
У поставщика есть только один метод get() и нет никаких других методов по умолчанию или статических методов.
```
public void supplier() {
Supplier doubleSupplier1 = () -> Math.random();
DoubleSupplier doubleSupplier2 = Math::random;
System.out.println(doubleSupplier1.get());
System.out.println(doubleSupplier2.getAsDouble());
}
```
Интерфейс поставщик имеет свои примитивные варианты, такие как IntSupplier, DoubleSupplier и т. д., как показано ниже. Обратите внимание, что имя метода — get() используется для универсального интерфейса поставщика. Однако для примитивных вариантов этот метод соответствует примитивному типу.
```
IntSupplier int getAsInt();
DoubleSupplier double getAsDouble();
LongSupplier long getAsLong();
BooleanSupplier boolean getAsBoolean();
```
Одно из основных применений этого интерфейса это использование для включения отложенного выполнения. Это означает отсрочку выполнения до тех пор, пока оно не понадобится. Например, в классе Optional есть метод orElseGet. Этот метод срабатывает, если у option нет данных. Это показано ниже:
```
public void supplierWithOptional() {
Supplier doubleSupplier = () -> Math.random();
Optional optionalDouble = Optional.empty();
System.out.println(optionalDouble.orElseGet(doubleSupplier));
}
```
### Predicate (предикат)
Интерфейс Predicate представляет собой логическую функцию аргумента. Он в основном используется для фильтрации данных из потока (stream) Java. Метод фильтра потока принимает предикат для фильтрации данных и возврата нового потока, удовлетворяющего предикату. У предиката есть метод test(), который принимает аргумент и возвращает логическое значение.
```
public void testPredicate() {
List names = Arrays.asList("Smith", "Samueal", "Catley", "Sie");
Predicate nameStartsWithS = str -> str.startsWith("S");
names.stream().filter(nameStartsWithS).forEach(System.out::println);
}
```
В приведенном выше примере мы создали предикат, который проверяет имена, начинающиеся с S. Этот предикат передается потоку.
Predicate также предоставляет несколько стандартных и статических методов для композиции и других целей:
```
default Predicate and(Predicate super T other);
default Predicate or(Predicate super T other);
static Predicate isEquals(Object targetRef);
default Predicate negate();
```
В следующем примере демонстрируется использование и метод для составления цепочки предикатов.
```
public void testPredicateAndComposition() {
List names = Arrays.asList("Smith", "Samueal", "Catley", "Sie");
Predicate startPredicate = str -> str.startsWith("S");
Predicate lengthPredicate = str -> str.length() >= 5;
names.stream()
.filter(startPredicate.and(lengthPredicate))
.forEach(System.out::println);
}
```
### Function (функция)
Интерфейс Function — это более общий интерфейс, который принимает один аргумент и выдает результат. В нем применяется единый абстрактный метод (SAM), который принимает аргумент типа *T* и выдает результат типа *R*. Одним из распространенных вариантов использования этого интерфейса является метод Stream.map. Пример использования показан ниже:
```
public void testFunctions() {
List names = Arrays.asList("Smith", "Gourav", "John", "Catania");
Function nameMappingFunction = String::length;
List nameLength = names.stream()
.map(nameMappingFunction).collect(Collectors.toList());
System.out.println(nameLength);
}
```
---
Подведем итоги
--------------
Введение функционального программирования представило новую парадигму языка Java. И интерфейсы Consumer, Supplier, Predicate и Function играют решающую роль в том, как это реализовано в Java. Освоение этих интерфейсов и связанных с ними примитивных вариантов, безусловно, помогает писать более качественный функциональный код.
Источник: [статьяОдногоУмногоПарня](https://medium.com/swlh/understanding-java-8s-consumer-supplier-predicate-and-function-c1889b9423d) | https://habr.com/ru/post/677610/ | null | ru | null |
# Просто Angular
**Введение**
------------
8-9-го декабря 2016 года была [проведена первая конференция](https://www.youtube.com/watch?v=aJIMoLgqU_o) по Angular в Бельгии. [Игор Минар](https://github.com/igorminar) (ведущий разработчик Angular) выступил в качестве основного докладчика с несколькими интересными объявлениями относительно того, по какому графику будет выпускаться Angular. И представьте себе, в марте 2017 года нас ждет релиз [Angular 4](https://en.wikipedia.org/wiki/AngularJS#Angular_4). При этом, на данный момент уже опубликована [бета-версия](https://github.com/angular/angular/blob/master/CHANGELOG.md).
**От переводчиков**
-------------------
Всем привет, с вами [Максим Иванов](https://github.com/splincode) и [Дмитрий Сергиенков](https://habrahabr.ru/users/blackbaron/), и сегодня мы выясним куда делась третья версия, и почему мы по-прежнему можем быть верны Angular. Сейчас начинающему фронтенд-разработчику, изучающему JavaScript, довольно трудно определиться: какой же фреймворк или библиотеку им взять и изучить, оставаясь в тренде? Конечно, без слова React, сейчас не обходится ни один разговор на тему фронтенда, однако, в свое время я начал с первой версии Angular, начитался много [руководств по написанию фронтенда на ES6](https://github.com/toddmotto/angular-styleguide) (с классами и прочим добром) и до сих пор не жалею. Да, вы можете писать корпоративные приложения с использованием только jQuery, но по мере развития и сложности проекта вы начнете закапывать себя в спагетти-коде, смешивая логику и представление, MV\*-фреймворки же этого сделать вам не дадут.
**Содержание**
--------------
1. [Почему Angular 4? Где Angular 3? Что происходит?](#s1)
* [Спецификация семантического версионирования](#s1_1)
* [Критические изменения не должны приносить боль](#s1_2)
* [Теперь это просто «Angular»](#s1_3)
* [Новые правила версионирования](#s1_4)
* [Почему мы решили все же пропустить третью версию](#s1_5)
* [Предварительный график релизов](#s1_6)
* [Вывод: не беспокойтесь](#s1_7)
2. [Angular2 Webpack Starter](#s2)
* [Быстрый старт](#s2_1)
* [Содержательный видеокурс (eng)](#s2_2)
3. [Что хорошего появилось в уходящем 2016 году вместе с Angular 2](#s3)
* [Статистика](#s3_1)
* [Angular 2 быстрее](#s3_2)
* [Официальное руководство по написанию кода](#s3_3)
* [Материальный дизайн для приложений на Angular 2](#s3_4)
* [Прогрессивные web-приложения с Angular Mobile Toolkit](#s3_5)
* [Шаблонизация на стороне сервера](#s3_6)
* [Быстрая разработка приложения через терминал при помощи Angular CLI](#s3_7)
* [Большое количество туториалов](#s3_8)
* [Опциональная типизация в вашем web-приложении](#s3_9)
* [Хорошие инструменты для отладки](#s3_10)
* [Платформа для разработки бизнес-приложений Firebase](#s3_11)
* [Кроссплатформенные мобильные приложения с NativeScript + Angular 2](#s3_12)
* [Простое тестирование благодаря зонам](#s3_13)
**Почему Angular 4? Где Angular 3? Что происходит?**
----------------------------------------------------
### **Спецификация семантического версионирования**
Еще в сентябре, когда вышла вторая версия, [Angular Team](https://github.com/angular) объявила о том, что она будет поддерживать семантическое версионирование ([SEMVER](http://semver.org/lang/ru/)).
Как видно из названия, семантическое версионирование — это добавление смысла каждому номеру версии. Семантика номера версии позволяет разработчику определить, что за модернизация была проведена в данной версии продукта, к тому же, мы можем настроить наши инструменты, например, менеджер пакетов NPM, таким образом, чтобы [при сборке приложения выбиралась конкретная версия зависимых библиотек](https://blog.nodejitsu.com/package-dependencies-done-right/), чтобы при этом мы ничего не сломали.
Семантика версии состоит из трех чисел:
Всякий раз, когда Вы исправляете ошибку в коде (баг) и выпускаете продукт заново, Вы увеличиваете последнюю цифру; если же просто была добавлена новая функция в вашем продукте, вы увеличиваете вторую цифру, но когда Вы выпускаете продукт с кардинальными (критическими) изменениями, которые ломают работу вашего старого кода, Вы увеличиваете первую цифру.
Критические изменения появляются тогда, когда Вам, как разработчику, который использует данную библиотеку, придется вмешаться в свой код и изменить его после обновления и перехода на новую версию.
Что это может означать для Angular Team? Понятно, что для любого бурно развивающегося программного обеспечения наступает момент, когда приходится проводить критические изменения. И поэтому, по объективным соображениям, Angular Team сменила версию 1.x на 2.x, из-за того, что те изменения, которые были выполнены, сломали работу основного кода.
### **Критические изменения не должны приносить боль**
Сообщество Angular точно поймет, о чем идет речь. Пользователям, чтобы перейти на вторую версию, пришлось переписать весь код. Хотя многие и полюбили Angular 1.x, но по объективным причинам были сделаны общие критические изменения, был написан новый API, новые шаблоны. Это было очевидно, и в конечном счете, Angular 2 был полностью переписан ([хотя и существует способ менее болезненно мигрировать на новую версию](https://angular.io/docs/ts/latest/guide/upgrade.html)).
Сейчас решено, что переход от версии 2 до версии 4, 5,… не должен быть таким болезненным, как это было с первой версией. Теперь код не будет полностью переписываться, наши изменения будут затрагивать только отдельные библиотеки, поставляемые сейчас с Angular 2, в свою очередь они будут соблюдены согласно SEMVER. Кроме того, постепенно мы будем включать Deprecation фазы (предупреждения консоли разработчика о том, что в следующих версиях данный функционал поддерживаться не будет), чтобы позволить разработчикам своевременно перейти на новый функционал.
Angular Team использует собственный инструмент контроля изменений и обработки автоматических обновлений. Команда упорно работает над ним, и запланировала выпуск совместно с выходом Angular 5 в 2017 году.
### **Теперь это просто «Angular»**
Как вы, возможно, уже догадались, термин «Angular 2» будет устаревшим с выходом 4-ой или 5-ой версии. Тем не менее, теперь следует начать называть его просто «Angular» без версии. Кроме того, вы должны начать избегать библиотек с GitHub/NPM с префиксом ng2- или angular2-. Существует единый ресурс с документацией — [angular.io](https://angular.io/) c официальным [сообществом](https://github.com/angular) на GitHub.
### **Новые правила версионирования**
С этого момента, старайтесь избегать использования номера версии, если он не является действительно необходимым для устранения неоднозначности.
Три простых руководящих принципа:
* Используйте «Angular» по умолчанию (например, «Я angular-разработчик», «Это Angular-Meetup», «Angular сообщество быстро развивается»)
* Используйте «Angular 1», «Angular 2», «Angular 4», когда речь идет о специфичных вещах («Это эта функция X появилась в Angular 4», «Мы обновились с Angular 1 до 2», «Я предлагаю это изменение в Angular 5»)
* Используйте полную версию semver при сообщении об ошибке (например, «Эта проблема присутствует в Angular 2.3.1»)
Вся документация, даже для Angular 1.x, будут приведены в соответствие с этими правилами в ближайшие недели. Но если вы пишите что-то в своем блоге, пишите статьи, курсы, книги или всякий раз, старайтесь ориентироваться на специфическую версию Angular, дописывайте версию в заголовках публикации, якобы в данной статье используется Angular 2.3.1. Это помогает избежать путаницы для ваших читателей, особенно, когда вы пишете о конкретных API.
### **Почему мы решили все же пропустить третью версию**
Библиотеки ядра Angular находятся [в одном репозитории на GitHub](https://github.com/angular/angular). Все они имеют свою версию и распространяются как различные пакеты NPM:
Из-за несовпадения в версиях [маршрутизатор пакетов стал сразу искать Angular 4](http://angularjs.blogspot.ru/2016/06/improvements-coming-for-routing-in.html). Поэтому мы решили, что семантическое версионирование должно быть строгим для основных пакетов ядра, которые гораздо легче поддерживать, а версия Angular именоваться, исходя из последней версии зависимостей.
Кроме того, важно понимать, что Angular используется в Google. Большинство приложений Google используют Angular из основной ветки репозитория на GitHub. Всякий раз, когда происходит обновление в ветке master, все сразу же интегрируется в основной внутренний репозиторий Google (в компании используется один монолитный репозиторий), где располагаются такие продукты как Google Maps, Adsense и другие. В результате все проекты, использующие Angular падают, если они имеют критические изменения, поэтому приходится все переписывать, что, в свою очередь, неудобно. Таким образом, лучше всего иметь полностью унифицированную версию, которую было бы легче поддерживать в течение долгого времени, что помогло бы команде быть более продуктивной в выпуске новых функций.
### **Предварительный график релизов**
Тот факт, что критические изменения все же будут, не означает, что они появятся сразу же через неделю. Angular Team уверяет в том, что в дальнейшем у вас останется обратная совместимость между версиями, теперь изменения будут иметь четкий характер и идти по конкретному графику в течение трех циклов:
* патч-релизы каждую неделю
* каждые 3 месяца будут появляться незначительные изменения (minor) в функционале
* каждые 6 месяцев новая версия Angular с незначительной миграцией
Следующие 3 месяца будут посвящены доработке Angulr 4.0.0.
После Angular 4.0.0 вас ждет предварительный график дальнейших выпусков:
### **Вывод: не беспокойтесь**
В конце Игор Минар подытожил:
* не беспокойтесь о номерах версий
* мы должны развиваться вместе с Angular, чтобы не допускать такого, как это было с различиями между Angular 1.x и 2.x, мы должны сделать это вместе как сообщество, развивать и улучшать наш любимый продукт
* вы должны осознать почему нам пришлось поступить так с Angular 1.x и переписать все с нуля
**Angular2 Webpack Starter**
----------------------------
[Angular2 Webpack Starter](https://github.com/AngularClass/angular2-webpack-starter) — представляет из себя репозиторий для быстрого старта с [Angular](https://angular.io/) и [TypeScript](https://www.typescriptlang.org/play/), посредством сборщика проектов [Webpack](https://learn.javascript.ru/screencast/webpack).
Что включено в данный репозиторий:
* Лучшие практики по организации файлов и каталогов на Angular 2
* Система сборки Webpack 2 с TypeScript
* Демонстрационный пример на основе Angular 2
* Свежая версия Angular
* Ahead of Time (AoT) для быстрой загрузки вашего приложения
* Tree shaking для автоматического удаления неиспользуемого кода из вашего проекта
* Тестирование с использованием Jasmine и Karma
* Покрытие тестами с Istanbul и Karma
* End-to-end Angular 2 тестирование с Protractor
* Менеджер типов с @types
* Material Design
* Hot Module Replacement
* Поддержка Angular 4 путем изменения package.json и любых других будущих версий
### **Быстрый старт**
Убедитесь, что у вас есть Node.js версии >= 5.0 и NPM >= 3.0
```
# клонируем наш репозиторий
git clone --depth 1 https://github.com/angularclass/angular2-webpack-starter.git
# выбираем директорию
cd angular2-webpack-starter
# устанавливаем зависимости посредством npm
npm install
# далее по желанию
# запускаем сервер
npm start
# запускаем Hot Module Replacement
npm run server:dev:hmr
```
Переходим на <http://0.0.0.0:3000> или <http://localhost:3000> в вашем браузере. Более подробно на [официальном репозитории](https://github.com/AngularClass/angular2-webpack-starter).
### **Содержательный видеокурс**
Курс даст возможность быстро начать создавать свои приложения с использованием одного из самых популярных фреймворков – Angular 2. В процессе прохождения курса шаг за шагом вы сделаете реальное приложение и хорошо разберетесь в специфике Angular 2. Курс на английском, но на самом деле, если у вас хромает язык, главное попытаться вникнуть в код, который пишет автор, в основном все прикрепляется слайдами, которые тоже интуитивно понятны. Платить ничего не нужно, сиди и развивайся.
* [Плей-лист курса Angular 2 Tutorials (27 видеоуроков)](https://www.youtube.com/playlist?list=PL4cUxeGkcC9jqhk5RvBiEwHMKSUXPyng0)
* [Getting Started with Angular 2](https://school.scotch.io/getting-started-with-angular-2)
**Что хорошего появилось в уходящем 2016 году вместе с Angular 2**
------------------------------------------------------------------
### **Статистика (на сентябрь 2016 года)**
* 1.2 миллиона разработчиков использующих Angular 1
* 623 тысячи уже используют Angular 2
Если Angular 1 был монолитным проектом, то теперь Angular 2 следует рассматривать как платформу.
Angular 1 использовал 43 встроенных директивы, теперь в Angular 2 мы используем [ ] и ( ).
**Angular 2 быстрее**
---------------------
Изначально Angular 1 весил 56K. При этом ядро самого Angular 2 было — 170K. Angular Team оптимизировали тонны кода и теперь ядро Angular 2 весит 45K.
#### **Отложенная загрузка**
Основная задача Angular Team была в том, чтобы добиться автоматической отложенной загрузки. Это гарантирует нашим приложениям только то, что необходимо для текущей страницы. Ленивая загрузка также была включена при маршрутизации в приложениях.
#### **Быстрый рендеринг**
По сравнению с первой версией приложения на Angular 2 работают в 2,5 раза быстрее, а перерисовка в 4,2 раза быстрее. Команда Angular считает, что она может сделать рендеринг еще более быстрым.
### **Официальное руководство по написанию кода**
Во времена Angular 1 появилось большое количество руководств по написанию кода. Это привело к большому количеству отличительных стилей, что привело к разночтению в Интернете. Для Angular 2 теперь есть [официальное руководство по стилю](https://angular.io/styleguide).
### **Материальный дизайн для приложений на Angular 2**
[Angular Material](https://material.angular.io/) выглядит действительно хорошо. Использовать материальный стиль в вашем приложении достаточно легко, просто встраивайте компоненты.
### **Прогрессивные web-приложения с Angular Mobile Toolkit**
[Angular Mobile Toolkit](https://mobile.angular.io/) позволит легко создавать веб-приложений, которые загружаются мгновенно на любом устройстве, даже без подключения к Интернету.
[Прогрессивные веб-приложения](https://developer.mozilla.org/ru/Apps/Progressive) очень интересны для многих веб-разработчиков. Создание и повторное использование вашего кода для создания мобильного приложения с хорошей производительностью, почти равное нативному мобильному приложению. Angular Mobile Toolkit является еще одним шагом к осуществлению этой мечты.
### **Шаблонизация на стороне сервера**
Большой проблемой приложений на Angular 1 было то, что они собирались только в браузере. Это означает, что ваши приложения были совершенно SEO-неориентированные.
Команда Angular вынесли основной компонент сборки, и теперь ваши приложения можно собирать где угодно, [в том числе и на сервере](https://universal.angular.io/).
Достаточно легко это сделать при помощи NodeJS для сборки шаблонов на стороне сервера.
Наши приложения теперь будут работать еще быстрее для наших пользователей, теперь мы можем сэкономить драгоценное время рендеринга в браузере.
### **Быстрая разработка приложения через терминал при помощи Angular CLI**
Самое приятное — это [Angular CLI](https://cli.angular.io/). Установка приложения занимает много этапов, где много вещей может пойти не так:
* настройка типизации с TypeScript
* настройка импортов компонентов
* запуск приложения
* использование System.js
Angular CLI делает установку простой в одну строку:
```
ng new scotch-app
```
Чтобы начать работать с Angular CLI, все, что вам нужно сделать, это:
```
npm install -g angular-cli
ng new scotch-app
cd scotch-app
ng serve
```
Больше нам не требуется Gulp, Grunt, Webpack, Browserify.
### **Большое количество туториалов**
Например, это видео вполне объясняет как построить приложение на Angular 2:
### **Опциональная типизация в вашем web-приложении**
Есть много интересных вещей, которые может сделать [TypeScript](https://www.typescriptlang.org/play/). Есть много причин, почему вы должны использовать TypeScript. Благодаря TypeScript Angular 2 стал лучше развиваться.
### **Хорошие инструменты для отладки**
Любой человек, который использует [Batarangle](http://rangle.github.io/batarangle-io/) с Angular 1 знает, что его способность видеть переменные и состояние вашего приложения в браузере является большим подспорьем при разработке.
Теперь есть [Angular Augury](https://augury.angular.io/), он позволяет нам сделать именно это. Нет необходимости в console.log () в каждой части вашего приложения, чтобы увидеть состояние переменной, иерархию и наследование в вашем браузере.
### **Платформа для разработки бизнес-приложений Firebase**
Вы можете построить приложение в режиме реального времени с Angular 2, [Firebase](https://firebase.google.com/) и [AngularFire2](https://github.com/angular/angularfire2) примерно за 10 минут, например чат. Есть много функциональных возможностей, которые реализуются в короткий промежуток времени.
### **Кроссплатформенные мобильные приложения с NativeScript + Angular 2**
В то время как Angular Mobile Toolkit сосредоточено на создании прогрессивных веб-приложений, [NativeScript](https://www.nativescript.org) больше заинтересован на создании нативных приложений с Angular 2.
В чем разница, спросите вы? Например в анимации. Имея нативную анимации, отличную от браузерной все будет выглядеть гладко даже при большом количестве объектов.
### **Простое тестирование благодаря зонам**
[Zone.js](https://github.com/angular/zone.js/) библиотека для [управления асинхронными задачи](http://www.sdblog.ru/archives/zony-i-change-detection-v-ionic-2-i-angular-2/), способ управления контекстом выполнения. Много фантастических слов, но основная идея состоит в том, что тестирование будет намного проще в Angular 2!
Все эти асинхронные задачи отслеживаются благодаря zone.js. В своем видео Джули Ральф рассказывает как это работает:
**В заключении**
----------------
Я очень горжусь тем, что Angular вырос из обычного фреймворка в целую платформу, благодаря которой теперь можно легко разрабатывать не только веб-приложения, но и нативные, не уступая в качестве. Много работы проделала Angular Team, и за это им я благодарен. Конечно, вокруг есть много всего хорошего, но быть частью чего-то большого куда приятней. С наступающим Новым годом дорогие читатели, мы желаем вам всего наилучшего и удачи! | https://habr.com/ru/post/318682/ | null | ru | null |
# Клиентский мониторинг производительности
Привет, Хабр! Меня зовут Влад, я лид направления Web Performance в Тинькофф.
В этом цикле статей я расскажу о подходах, инструментах и показателях, с помощью которых мы наблюдаем за производительностью наших проектов. Но для начала пара слов о том, почему производительность — это важно.
Производительность как один из атрибутов качества программного обеспечения, в значительной степени может влиять на успех конечного продукта. Существует [множество историй](https://wpostats.com/) о том, как даже самые небольшие оптимизации положительно сказывались на опыте взаимодействия и бизнес-показателях компании.
Ведущие игроки IT-индустрии продолжают обращать внимание на [важность производительности](https://developers.google.com/web/fundamentals/performance/why-performance-matters), проводят [масштабные исследования](https://web.dev/defining-core-web-vitals-thresholds/) и эксперименты, разрабатывают новые [концепции](https://web.dev/rail/), [инструменты](https://github.com/GoogleChrome/lighthouse) и [API](https://chromium.googlesource.com/chromium/src/+/master/docs/speed_metrics/README.md#APIs-we-own). А в ближайшем будущем Google и вовсе будет учитывать основные показатели производительности в [поисковой выдаче](https://webmasters.googleblog.com/2020/05/evaluating-page-experience.html).
Пользователям нравятся отзывчивые интерфейсы, а бизнесу — прибыльные проекты. И если производительность играет в этом не последнюю роль, то почему бы не заняться ее оптимизацией?
Содержание
----------
* [Мониторинг](#monitoring)
+ [Современные методы измерения производительности](#sovremennye-metody-izmereniya-proizvoditelnosti)
+ [Сбор метрик отражающих восприятие производительности](#sbor-metrik-otrazhayuschih-vospriyatie-proizvoditelnosti)
+ [Отсутствие влияния на производительность приложения](#otsutstvie-vliyaniya-na-proizvoditelnost-prilozheniya)
* [Метрики](#metriki)
+ [Cumulative Layout Shift](#cumulative-layout-shift)
- [Принцип работы](#princip-raboty)
- [Использование](#ispolzovanie)
- [Оценка результатов](#ocenka-rezultatov)
- [Способы оптимизации](#sposoby-optimizacii)
+ [Largest Contentful Paint](#largest-contentful-paint)
- [Принцип работы](#princip-raboty-1)
- [Использование](#ispolzovanie-1)
- [Оценка результатов](#ocenka-rezultatov-1)
- [Способы оптимизации](#sposoby-optimizacii-1)
+ [First Input Delay](#first-input-delay)
- [Принцип работы](#princip-raboty-2)
- [Использование](#ispolzovanie-2)
- [Оценка результатов](#ocenka-rezultatov-2)
- [Способы оптимизации](#sposoby-optimizacii-2)
+ [Custom Metrics](#custom-metrics)
- [Инициализация приложения](#inicializaciya-prilozheniya)
- [Взаимодействие с приложением](#vzaimodeystvie-s-prilozheniem)
* [Анализ данных](#analiz-dannyh)
* [Бюджеты производительности](#byudzhety-proizvoditelnosti)
* [Заключение](#zaklyuchenie)
Мониторинг
----------
Прежде чем приступать к каким-либо оптимизациям, необходимо определить конкретные места проекта, которые в этом нуждаются. А чтобы обнаружить такие места, нужны измерения.
Когда у нас возникла потребность в подобных измерениях, найти соответствующий инструмент, удовлетворяющий всем нашим требованиям, не удалось. Поэтому было принято решение о создании собственного мониторинга производительности. Так появился проект [Perfectum Client](https://github.com/TinkoffCreditSystems/perfectum/tree/master/packages/client).
Perfectum Client — это легковесная библиотека для измерения клиентских показателей производительности. Рассмотрим основные принципы, которыми мы руководствовались при ее создании.
### Современные методы измерения производительности
Библиотека основана на работе с [PerformanceObserver API](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver).
Ниже приведен пример использования, в котором происходит наблюдение за событием первой отрисовки контента (First Contentful Paint).
```
const performanceObserver = new PerformanceObserver((performanceEntryList) => {
const performanceEntries = performanceEntryList.getEntries();
for (const performanceEntry of performanceEntries) {
if (performanceEntry.name === 'first-contentful-paint') {
const firstContentfulPaint = performanceEntry.startTime;
console.log('FCP is', firstContentfulPaint);
}
}
});
performanceObserver.observe({ type: 'paint', buffered: true }); // Свойство buffered позволяет получить информацию о событиях возникших до этапа инициализации observer'а
```
### Сбор метрик отражающих восприятие производительности
Библиотека сосредоточена на сборе только тех метрик, которые отражают реальное [восприятие производительности](https://wiki.developer.mozilla.org/en-US/docs/Glossary/Perceived_performance) проекта.
Мы не собираем статичные метрики, которые можно посмотреть в инструментах разработчика. Мы не собираем метрики, которые плохо или не всегда коррелируют с реальной производительностью. Мы не собираем ничего, что не принесет пользу в дальнейшей диагностике и оптимизации проекта.
### Отсутствие влияния на производительность приложения
Библиотека нацелена на минимизацию операций, оказывающих негативное влияние на производительность приложения.
Она не требует ранней инициализации или размещения в head документа. Позволяет загружать свой код на любом этапе работы приложения. Использует не блокирующие основной поток и управляемые браузером методы [Beacon API](https://developer.mozilla.org/ru/docs/Web/API/Beacon_API). Не включает тяжелых операций форматирования, агрегирования и тд.
Метрики
-------
Существует огромное количество показателей производительности:
* **FCP** — First Contentful Paint;
* **FMP** — First Meaningful Paint;
* **LCP** — Largest Contentful Paint;
* **CLS** — Cumulative Layout Shift;
* **FID** — First Input Delay;
* **FCI** — First CPU Idle;
* **TTI** — Time To Interactive;
* **TBT** — Total Blocking Time;
* **VC** — Visually Complete;
* **SP** — Speed Index и тд.
И хоть это далеко не полный список, на первый взгляд даже он может показаться бессвязным набором аббревиатур и словосочетаний.
Современные метрики производительности имеют определенный набор признаков, благодаря которым их можно разделить на категории. Например — среда использования. Одни метрики предназначены для использования в промышленной среде, а другие — на этапе мониторинга производительности в CI/CD. Причин такому разделению несколько.
Первая связана с отсутствием возможности измерений как таковых. Например, измерение метрики первой задержки ввода (First Input Delay) за пределами промышленной среды не имеет практического смысла.
Вторая причина заключается в том, что алгоритм работы некоторых метрик — трудоемкий с вычислительной точки зрения процесс. Поэтому использование определенных показателей в том или ином окружении может быть нецелесообразно, а порой и вовсе недопустимо.
Единственной средой, в которой мы работаем с данными производительности реальных пользователей, является промышленная среда. Поэтому такое окружение я назову клиентским, а все остальные — синтетическими. Разделив показатели по признаку среды использования, мы можем увидеть следующую картину:
Стоит отметить, что это не строгое разделение, и некоторые метрики могут использоваться сразу в обоих окружениях.
Нас будет интересовать первая категория показателей. Вторая, подробно рассматривается в статье о [синтетическом мониторинге производительности](https://habr.com/ru/company/tinkoff/blog/508258/).
### Cumulative Layout Shift
Cumulative Layout Shift (**CLS**) позволяет обнаружить непредвиденные сдвиги макета.
#### Принцип работы
В случае обнаружения сдвига алгоритм работы метрики пытается определить область вьюпорта, в которой произошло смещение.
Используя отличия между соседними фреймами страницы, происходит поиск всех *сместившихся DOM-элементов*.
Далее определяется их предыдущая и текущая *области расположения*,
объединение которых образует *область смещения* макета:
После того как *область смещения* найдена, определяется степень ее воздействия относительно размеров вьюпорта.
Для этого производится расчет соотношения *площади области смещения* и *площади области просмотра*.
*Площадь области смещения* / *Площадь области просмотра* = (192 × 308) /(220 × 320) = 0.84
Первоначально алгоритм работы метрики не включал в себя определение других параметров сдвига. Но возникла проблема, заключающаяся в отсутствии учета расстояния.
Когда элемент смещался всего на пару пикселей, результат такого смещения был не сильно заметен пользователю. При этом, если размеры элемента изначально были большими, то даже такие незначительные сдвиги заметно влияли на *область смещения* и, соответственно, на значение метрики.
Поэтому в формулу оценки сдвига макета добавили учет *расстояния смещения*.
В случае сдвига сразу нескольких элементов по любой из осей макета (горизонтальной или вертикальной) происходит поиск *максимального расстояния смещения*.
Далее определяется *наибольшая размерность вьюпорта* (ширина или высота). В нашем случае это высота.
После чего производится расчет соотношения данных показателей.
*Максимальное расстояние смещения* / *Наибольшая размерность вьюпорта* = 87 / 320 = 0.27
В итоге мы получили относительные значения двух параметров сдвига:
1. *Область смещения*
2. *Расстояние смещения*
Чтобы определить *оценку смещения* макета, необходимо найти произведение этих параметров.
*Оценка смещения* = *Область смещения* × *Расстояние смещения* = 0.84 × 0.27 = 0.2268
Но, так как мы оперировали результатами отличия соседних фреймов страницы, полученная *оценка смещения* (Layout Shift) будет показателем сдвига для одного-единственного фрейма. Для определения *совокупной оценки смещения* (Cumulative Layout Shift), необходимо просуммировать результаты каждого фрейма от начала загрузки страницы до ее закрытия.
Также не будет лишним рассказать и о трудностях, с которыми столкнулась команда разработки метрики.
Первоочередной проблемой был сдвиг макета, являющийся частью логики работы интерфейса. Ведь когда в ответ на взаимодействие пользователя определенные элементы страницы должны смещаться, они очевидным образом приведут к сдвигу макета, что в конечном счете отрицательно скажется на результатах метрики.
Одним из самых простых вариантов решения, являлось бы игнорирование сдвигов макета происходящих в обработчиках событий. Но события, повлекшие сдвиги макета, могут возникать не только в обработчиках, они также могут происходить после выполнения асинхронного запроса или внутри пользовательских планировщиков. А это значит, что для определения причины сдвига потребовался бы сложный анализ последовательности асинхронных шагов, что само по себе не является тривиальной задачей.
Окончательным решением стало предоставление временного окна, на протяжении которого сдвиги макета не учитываются. Временное окно возникает сразу после события пользовательского ввода. Продолжительность окна составляет 500 мс. Следовательно, любые смещения макета, случившиеся на протяжении 500 мс после условного клика мыши, не будут учитываться в общей оценке показателя.
Другой проблемой стала анимация. Анимирование [css-свойств](https://csstriggers.com/), которые вызывают операцию перерасчета макета (Layout), будет влиять на конечный результат метрики.
В тоже время анимация с использованием свойств, создающих отдельный контекст наложения, подобных перерасчетов не вызывает. К таким свойствам относятся *transform*, *opacity* и все, что не связано с позиционированием и геометрией элементов страницы.
Частичным решением проблемы стало игнорирование сдвигов макета, которые были вызваны анимацией свойств, не вызывающих операций перерасчета макета. Поэтому для поддержания значения **CLS** на должном уровне команда разработки метрики рекомендует создавать анимации с использованием свойства [transform](https://developer.mozilla.org/en-US/docs/Web/CSS/transform).
#### Использование
Значение метрики можно получить используя уже знакомый PerformanceObserver API:
```
let cumulativeLayoutShift = 0;
const performanceObserver = new PerformanceObserver((performanceEntryList) => {
const performanceEntries = performanceEntryList.getEntries();
for (const performanceEntry of performanceEntries) {
if (!performanceEntry.hadRecentInput) { // Свойство hadRecentInput позволяет не учитывать события сдвига макета вызванные пользовательским вводом
cumulativeLayoutShift += performanceEntry.value;
console.log('CLS is', cumulativeLayoutShift);
}
}
});
performanceObserver.observe({ type: 'layout-shift', buffered: true });
```
Для отображения смещений макета на экране можно включить соответствующую опцию в меню инструментов разработчика. Пример для chromium-based браузеров:
Также подробную информацию о результатах **CLS** можно получить на панели Performance:
#### Оценка результатов
В идеальном мире приложения не должны иметь каких-либо сдвигов макета, но на практике достичь такого результата получается не всегда. К тому же в любом проекте могут быть осознанные компромиссы, связанные с логикой работы интерфейса и влияющие на значение **CLS**.
Поэтому команда разработки метрики рекомендует использовать следующие градации при оценке результатов показателя:
#### Способы оптимизации
Рассмотрим способы оптимизации наиболее частых случаев смещения макета.
**Атрибуты размерности изображений**
Загрузка изображений, у которых отсутствует явное указание размерности, может привести к сдвигам макета. Атрибуты ширины и высоты, указываемые в тэге ![](), помогут избежать непредвиденных смещений.
Для получения более подробной информации рекомендую ознакомиться со статьей [Setting Height And Width On Images Is Important Again](https://www.smashingmagazine.com/2020/03/setting-height-width-images-important-again/).
**Загрузка шрифтов и стратегия визуализации текста**
В процессе загрузки шрифтов браузеры сразу или по таймауту отображают текст страницы, используя резервный шрифт.
По окончанию загрузки происходит замена резервного шрифта на основной, в результате текстовое содержимое страницы перерисовывается. В большинстве случаев подобные перерисовки вызывают смещение элементов макета, которые можно минимизировать, явно определив стратегию визуализации текста.
Для управления стратегией визуализации правило [@font-face](https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face) предоставляет возможность определить дескриптор [font-display](https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-display). Дескриптор имеет множество значений, одно из которых позволяет свести к минимуму перерисовки и сдвиги макета.
Речь идёт о значении *optional*, основная суть которого в том, что если за первые 100 мс основной шрифт не загрузился, то текст отрисовывается с использованием резервного, без какой-либо замены. Однако при следующем посещении страницы текстовое содержимое отобразится с использованием основного шрифта — разумеется, если он был успешно загружен и добавлен в кэш с прошлого раза.
Преимуществом такого подхода является то, что в обоих случаях пользователь не столкнется с перерисовкой текстового содержимого, а разработчик — с отрицательной оценкой сдвига макета.
Подробную информацию по использованию дескриптора совместно с предварительной загрузкой можно найти в статье [Prevent layout shifting by preloading optional fonts](https://web.dev/preload-optional-fonts/).
**Динамический контент страницы**
Под динамическим контентом страницы подразумевается контент, появление которого не является прямым ответным действием на ввод пользователя. Это могут быть баннеры, реклама, блоки с просьбой подписаться на рассылку или установить мобильное приложение.
Для динамического контента небольших размеров рекомендуется использовать свойства абсолютного позиционирования. А для более крупного — заранее резервировать место на странице — например, используя скелетные экраны загрузки.
**Анимация**
Как упоминалось ранее, анимацию [свойств](https://csstriggers.com/), вызывающих события перерасчета макета, следует заменить на анимацию с использованием свойства *transform*.
### Largest Contentful Paint
Largest Contentful Paint (**LCP**) измеряет время отображения наибольшего элемента страницы.
Но прежде чем перейти к описанию принципов работы **LCP** стоит рассказать о предпосылках, которые побудили команду [Chrome Speed Metrics](https://chromium.googlesource.com/chromium/src/+/master/docs/speed_metrics/README.md#mission) на создание новой метрики.
Клиентские показатели производительности, которые мы определили в самом начале, можно дополнительно разделить по фазам загрузки приложения. Я назову эти фазы следующим образом:
* *фаза начальной загрузки* — когда пользовать зашел в приложение;
* *фаза отображения основного контента* — когда на экране пользователя начинают появляться значимые элементы страницы;
* *фаза наступления интерактивности* — когда страница готова стабильно отвечать на действия пользователя.
Если расставить основные клиентские метрики по фазам загрузки, представив картину, использовавшуюся до недавнего времени, мы получим приблизительно следующее:
Здесь может возникнуть резонный вопрос: если все фазы загрузки приложения покрыты соответствующими метриками, зачем понадобилась ещё одна? Ответ заключается в метрике **FMP** (First Meaningful Paint), у которой есть ряд проблем.
Команда Chrome Speed Metrics, имея огромный опыт в создании показателей производительности, определила [набор свойств](https://chromium.googlesource.com/chromium/src/+/master/docs/speed/good_toplevel_metrics.md), которыми должна обладать хорошая метрика.
К сожалению, метрика **FMP** не обладает некоторыми из них — в частности, свойствами [простоты](https://chromium.googlesource.com/chromium/src/+/master/docs/speed/good_toplevel_metrics.md#Simple) и [гибкости](https://chromium.googlesource.com/chromium/src/+/master/docs/speed/good_toplevel_metrics.md#Elastic). Первым — по причине сложности в стандартизации используемых решений, а вторым — из-за большого количества эвристики. В результате от этого показателя было решено отказаться.
После отказа от **FMP** фаза отображения основного контента остается без метрики, а значит, без соответствующего наблюдения.
Чтобы найти полноценную замену, команда разработки рассматривала несколько метрик-кандидатов, реализованных в Chrome:
* Largest image paint;
* Largest text paint;
* Largest image OR text paint;
* Last image paint;
* Last text paint;
* Last image OR text paint.
В ходе анализа данных, собранных с более чем тысячи сайтов, было выявлено, что метрика Largest image OR text paint является наиболее подходящим кандидатом. Впоследствии эта метрика получила название Largest Contentful Paint.
#### Принцип работы
Как упоминалось ранее, метрика **LCP** измеряет время отображения наибольшего элемента страницы. А поскольку рендеринг приложения происходит постепенно, то и кандидат на звание наибольшего элемента со временем может меняться.
Визуально этот процесс можно представить следующим образом:
Светло-зеленым цветом выделены элементы, которые по мере загрузки страницы рассматривались как наибольшие.
Осталось разобраться, какие типы элементов учитываются, как определяется размер и время отображения.
На данный момент алгоритм работы метрики **LCP** отслеживает следующие типы элементов:
* изображения:
+ ![]() элементы,
+ элементы внутри SVG-документов,
+ элементы с фоновым изображением;
* видео с poster-изображением;
* текст в блочных элементах.
Размер наибольшего элемента определяется по следующей формуле:
*Размер* = *Ширина* × *Высота*
Внешние и внутренние отступы, а также рамки элемента не учитываются.
Определение времени отображения происходит следующим образом:
* Для изображений фиксируется момент отрисовки, наступающий сразу после события load ресурса. Для изображений, загружаемых из сторонних источников, необходимо наличие заголовка [Timing-Allow-Origin](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Timing-Allow-Origin). В противном случае временем отрисовки элемента будет считаться момент наступления события load ресурса.
* Для видеоэлементов фиксируется момент отрисовки poster-изображения. Алгоритм определения времени отображения идентичен вышеописанному для изображений.
* Для текстовых элементов фиксируется время первого отображения, независимо от будущей загрузки основного шрифта и последующей перерисовки текстового содержимого страницы.
Также не будет лишним рассказать и о некоторых особенностях работы данной метрики.
Как упоминалось ранее, в процессе загрузки приложения статус наибольшего элемента страницы может переходить от одного элемента к другому. По сути, происходит поиск *последнего наибольшего элемента*, появившегося в области просмотра.
Но встает вопрос о том, когда алгоритм работы метрики принимает решение остановить наблюдение за появлением новых элементов. Ведь нас интересует исключительно этап загрузки приложения.
Очевидным вариантом решения стал момент взаимодействия пользователя со страницей — будь то клик или прокрутка. Поэтому после наступления события пользовательского ввода поиск новых кандидатов для метрики **LCP** останавливается.
Ещё одной особенностью является механизм работы метрики после удаления DOM-элемента. При определении наибольшего элемента страницы, который в последствии удаляется из DOM-дерева, начинается поиск нового кандидата. Наиболее частый пример — это отображение прелоадера, который впоследствии исчезает.
Логика дальнейшего поиска обусловлена тем, что элементы, которые удаляются в процессе загрузки, скорее всего, не являются значимыми с точки зрения пользователя, поэтому и учитывать результаты их отрисовки не имеет особого смысла.
Стоит упомянуть и более сложный сценарий, когда на сайте используется компонент карусели с автоматической сменой элементов по таймауту. Большинство реализаций подобных компонентов предполагает удаление отображаемого элемента карусели после его смены другим. Но если по окончании загрузки страницы пользовательского ввода не случилось, а элементы карусели были помечены как наибольшие и продолжают сменять друг друга, то с каждой последующей сменой значение метрики будет обновляться на все более и более некорректный результат.
Команда разработки метрики знает об этой проблеме и работает над ее устранением.
#### Использование
Значение метрики можно получить используя PerformanceObserver API:
```
const performanceObserver = new PerformanceObserver((performanceEntryList) => {
const performanceEntries = performanceEntryList.getEntries();
const lastPerformanceEntry = performanceEntries[performanceEntries.length - 1];
const largestContentfulPaint = lastPerformanceEntry.startTime;
console.log('LCP is', largestContentfulPaint);
});
performanceObserver.observe({ type: 'largest-contentful-paint', buffered: true });
```
Также подробная информация о результатах **LCP** доступна на панели Performance:
#### Оценка результатов
При оценке результатов показателя рекомендуется использовать следующие градации:
#### Способы оптимизации
Как правило, любые оптимизации, направленные на увеличение скорости загрузки страницы, положительно скажутся на показателе **LCP**.
Вот краткий список рекомендаций:
* Уменьшите количество блокирующих рендер [ресурсов](https://web.dev/render-blocking-resources/).
* Используйте [сжатие](https://web.dev/reduce-network-payloads-using-text-compression/#data-compression) текстовых файлов, но делайте это [эффективно](https://csswizardry.com/2020/04/real-world-effectiveness-of-brotli/).
* Оптимизируйте [изображения](https://images.guide/), а в идеале [автоматизируйте](https://github.com/tcoopman/image-webpack-loader) этот процесс.
* Устанавливайте [предварительное соединение](https://web.dev/preconnect-and-dns-prefetch/) со сторонними доменами и [приоритизируйте](https://developers.google.com/web/fundamentals/performance/resource-prioritization) загрузку ресурсов.
* Проверьте, что время ответа сервера находится на [приемлемом уровне](https://web.dev/time-to-first-byte/), а статические файлы приложения имеют эффективную политику [кэширования](https://web.dev/http-cache/).
* И, разумеется, [минификация](https://web.dev/unminified-javascript/), [код-сплиттинг](https://web.dev/reduce-javascript-payloads-with-code-splitting/), [оптимизация зависимостей](https://github.com/GoogleChromeLabs/webpack-libs-optimizations) и [удаление неиспользуемого кода](https://web.dev/remove-unused-code/).
### First Input Delay
First Input Delay (**FID**) измеряет продолжительность задержки пользовательского ввода при первом взаимодействии со страницей.
#### Принцип работы
Для начала посмотрим на временную шкалу, представляющую типичную загрузку страницы:
Шкала отображает выполнение сетевых запросов за основными ресурсами страницы, файлами CSS и JS (помечено серым цветом).
После загрузки ресурса происходит его обработка и выполнение в основном потоке браузера (помечено бежевым цветом).
В большинстве случаев, продолжительные задержки первого ввода (First Input Delay, **FID**), возникают между событиями первой отрисовки контента (First Contentful Paint, **FCP**) и наступлением интерактивности (Time To Interactive, **TTI**).
Добавим эти события на шкалу загрузки страницы:
На временном отрезке между метриками **FCP** и **TTI** можно заметить выполнение некоторых задач в основном потоке браузера. Любая задача, которая длится более 50 мс, называется [продолжительной](https://w3c.github.io/longtasks/#long-task). Ограничение в 50 мс соответствует одному из [требований](https://web.dev/rail/#response:-process-events-in-under-50ms) модели производительности RAIL.
Обозначим продолжительные задачи соответствующим цветом:
Если пользователь начнет взаимодействовать со страницей во время выполнения одной из таких задач, он столкнется с видимой задержкой. Задержка будет продолжаться до тех пор, пока основной поток браузера не завершит работу связанную с данной задачей.
Проиллюстрируем этот момент на временной шкале загрузки:
Как можно заметить, пользовательский ввод случился во время выполнения продолжительной задачи. Ответ на поступивший ввод произошел после того, как задача завершила свою работу. А время, прошедшее с момента появления события ввода до возможности его обработки, будет являться значением **FID**.
Значимость мониторинга данной метрики возрастает в разы, если ваш проект использует SSR (server-side rendering). Это связано с тем, что пользователь практически сразу получает наполненную контентом страницу, что дает ему мнимое ощущение готовности для взаимодействия с ней. Однако до окончания загрузки файлов скриптов и гидратации страница не сможет реагировать на ввод пользователя.
Ситуация ухудшается еще больше, когда в таком проекте пытаются улучшить время первой отрисовки контента (**FCP**), не обращая внимания на время наступления интерактивности (**TTI**). Поскольку улучшение метрик отрисовки без улучшения метрик интерактивности будет приводить к увеличению интервала между отображением интерфейса и его реальной готовностью к взаимодействию. Что, скорее всего, негативно скажется на показателе **FID** и впечатлениях при работе с вашим приложением.
#### Использование
Значение метрики можно получить используя PerformanceObserver API:
```
const performanceObserver = new PerformanceObserver((performanceEntryList) => {
const performanceEntry = performanceEntryList.getEntries()[0];
const { startTime, processingStart } = performanceEntry;
const firstInputDelay = processingStart - startTime;
console.log('FID is', firstInputDelay);
});
performanceObserver.observe({ type: 'first-input', buffered: true });
```
#### Оценка результатов
При оценке результатов показателя рекомендуется использовать следующие градации:
#### Способы оптимизации
Основным улучшением, которое может оказать значительное влияние на показатель **FID**, является уменьшение количества JS-ресурсов на странице. Начиная от оптимизации [зависимостей](https://github.com/GoogleChromeLabs/webpack-libs-optimizations) и удаления [неиспользуемого](https://web.dev/remove-unused-code/) кода, заканчивая [код-сплиттингом](https://web.dev/reduce-javascript-payloads-with-code-splitting/) и эффективной доставкой [полифиллов](https://web.dev/serve-modern-code-to-modern-browsers/).
Если вы уже проделали все вышеперечисленное, то вот пара дополнительных рекомендаций. Для SSR-проектов, есть смысл поэкспериментировать с частичной гидратацией. Подробности в следующих материалах:
* [The cost of rehydration](https://addyosmani.com/blog/rehydration/) — о проблеме гидратации.
* [The case of partial hydration](https://medium.com/@luke_schmuke/how-we-achieved-the-best-web-performance-with-partial-hydration-20fab9c808d5) — о решении проблемы на примере Next и Preact.
* [How to drastically reduce time to interactive](https://markus.oberlehner.net/blog/how-to-drastically-reduce-estimated-input-latency-and-time-to-interactive-of-ssr-vue-applications/) — о решении проблемы на примере Vue.js.
* [Introducing Concurrent Mode (Experimental)](https://reactjs.org/docs/concurrent-mode-intro.html) — конкурентный режим в React, позволяющий реализовать механизм частичной гидратации и не только.
Также рекомендую ознакомиться со стратегией выполнения кода [Idle Until Urgent](https://philipwalton.com/articles/idle-until-urgent/).
### Custom Metrics
Еще один тип метрик, пользу которых сложно переоценить, — [пользовательские метрики](https://github.com/TinkoffCreditSystems/perfectum/tree/master/packages/client#custom-metrics). Они позволяют измерять производительность отдельных элементов страницы или операций, выполняемых в приложении.
В Perfectum Client реализовано два подхода для работы с пользовательскими метриками: один — для этапа инициализации приложения, другой — для этапа взаимодействия с ним.
Рассмотрим непосредственно каждый из них.
#### Инициализация приложения
На данном этапе может понадобиться измерить время появления важных элементов страницы, например hero-изображения, cta-элемента, lead-формы и т.д.
Для этого необходимо добавить атрибут *elementtiming* к интересующему html-элементу:
```
Example App
===========
```
После того как он отобразится на экране пользователя, в общее хранилище метрик добавится запись со значением указанного атрибута и временем появления элемента.
Взаимодействие с приложением
----------------------------
После инициализации приложения на странице может происходить множество ключевых событий, за производительностью которых также хотелось бы наблюдать. Это может быть выполнение приоритетных задач, рендеринг, загрузка ресурсов или даже пользовательские переходы между страницами приложения.
Для того чтобы измерить производительность таких операций, необходимо использовать интерфейс, представленный в виде двух статических методов класса Perfectum:
```
import Perfectum from '@perfectum/client';
Perfectum.startMeasure('metric-name');
someKindOfImportantTask();
Perfectum.stopMeasure('metric-name');
```
После вызова метода *stopMeasure* в общее хранилище метрик добавится запись со значением переданного аргумента и временем, прошедшем с момента вызова метода *startMeasure*.
Анализ данных
-------------
За результатами работы клиентского мониторинга мы наблюдаем в Grafana. Например, так выглядит отображение показателя **LCP** для отдельно взятого проекта:
Как вы могли заметить, отображение показателей производительности разделено по типу используемых устройств (desktop/mobile). Для нас такое сегментирование крайне важно, поскольку 55% наших пользователей заходят в web-версию сайта с мобильных устройств.
Данные на графиках отображаются в агрегированном виде и показывают распределение по процентилям (50%, 80%, 95%). Процентиль — это показатель порогового значения для некоторой части данных.
Например, значение Largest Contentful Paint (p80), приведенное на графике выше, говорит о том, что у 80% desktop-пользователей показатель отрисовки наибольшего элемента не превышает 2 секунд.
Бюджеты производительности
--------------------------
После интеграции клиентского мониторинга и последующего анализа данных, хорошим шагом будет являться фиксирование показателей производительности. Это пригодится не только в постановке целей для будущих оптимизаций, но и для наблюдения за возможными регрессами.
Одним из вариантов такого фиксирования является практика внедрения бюджетов производительности.
Бюджет производительности — это набор ограничений, накладываемых на показатели производительности проекта.
Значения [бюджетов производительности](https://github.com/TinkoffCreditSystems/perfectum/blob/master/packages/cli/perfectum.json#L8) мы используем в настройке оповещений Grafana:
Красной линией на графике обозначен бюджет, установленный для данного показателя.
Определение бюджетов и настройка оповещений позволяет отслеживать возможные регрессы производительности.
Например, в случае появления события, показанного на графике выше, мы получим соответствующее уведомление.
Что касается принципов построения бюджетов производительности, то их существует огромное множество, поэтому я ограничусь рассказом про тот, который используем мы.
Изначально мы исходим из того, что наши проекты не включают сложных технологических процессов, которые требуют создания real-time систем наблюдения. Например, таких, которые используются на атомных электростанциях (АСУ ТП, САУ, SCADA-системы).
Поэтому необходимости устанавливать строгие требования к точности, времени задержки и в целом к математической модели наблюдений у нас нет. В результате чего, мы используем упрощённую схему работы с отклонениями и определением бюджета.
Прежде всего мы предполагаем, что у нас уже есть данные необходимого нам показателя.
Далее для определения бюджета мы используем *среднее значение по 80-му процентилю* с добавлением *допустимого отклонения* в 20%.
Формула:
**P** — среднее значение показателя по 80-му процентилю
**K** — допустимое отклонение
**B** — бюджет
**B** = **P** + **K**
Пример:
**P** — 5000 (мс)
**K** — 20 (%)
**B** — ?? (мс)
**B** = 5000 + (5000 × 0.20) = 6000
*Среднее значение по 80-му процентилю* — это медиана, то есть значение середины отсортированного списка.
Например, у нас есть список значений за определенный период времени, и этот список выглядит следующим образом: [4500, 5200, 5500, 4600, 5000]. Чтобы найти медиану, нам необходимо отсортировать данный список — [4500, 4600, 5000, 5200, 5500] — и взять значение из середины — 5000.
Использование медианы обусловлено тем фактом, что оно менее подвержено влиянию выбросов, по сравнению с обычным средним арифметическим.
*Допустимое отклонение* в 20% взято из принципа описанного в статье [The Perception Of Time](https://www.smashingmagazine.com/2015/09/why-performance-matters-the-perception-of-time/#the-need-for-performance-optimization-the-20-rule). Принцип основывается на результатах исследований в области психофизики и гласит, что минимально заметная разница, которую способен увидеть человек, в нашем случае — пользователь приложения, находится на уровне тех самых 20%.
В итоге алгоритм определения бюджета выглядит следующим образом:
1. Берем выборку данных в пиковые часы работы приложения (например, с 10:00 до 19:00).
2. Находим среднее значение 80-го процентиля.
3. Прибавляем отклонение в 20%.
Заключение
----------
Внедрение клиентского мониторинга — отличный шаг в сторону успешных оптимизаций проекта. Потому что любые оптимизации должны быть обоснованными, целенаправленными и, главное, измеряемыми.
А чтобы превентивно выявлять регрессы производительности, рекомендую ознакомиться с нашей статьей о [синтетическом мониторинге](https://habr.com/ru/company/tinkoff/blog/508258/). | https://habr.com/ru/post/508256/ | null | ru | null |
# Мониторинг проектов: сравнительный анализ существующих решений
*Предлагаем вашему вниманию публикацию, написанную по мотивам выступления [Антона Баранова](http://conf.1c-bitrix.ru/summer2015/agenda/Monitoring_proektov_sravnitelnyy_analiz_sushchestvuyushchikh_resheniy/), ITSumma, на летней конференции [BitrixSummerFest](http://conf.1c-bitrix.ru/summer2015/agenda/Dostavlyaya_nepriyatnosti_o_professionalnykh_nakazaniyakh_podchinennykh_v_intellektualnoy_itsrede/).*
В этом посте я расскажу, что нужно с самого начала мониторить в проектах, в том числе высоконагруженных. Разберем аспекты, связанные с open source-системами мониторинга, в частности Zabbix и Graphite, а также присмотримся к нескольким SaaS-решениям для мониторинга.
Итак, нужно с самого начала решить для себя, какие параметры системы необходимо мониторить. Условно можно выделить три направления мониторинга:
1. Потребление ресурсов.
2. Работа серверного ПО.
3. Бизнес-логика приложения.
### Ресурсы
Они делятся на два вида: критические и важные. К критическим относятся те ресурсы, нехватка которых гарантированно приведёт к неработоспособности вашего приложения. Например, если процессор полностью загружен, то новые запросы не будут обработаны быстро. А это может привести к уходу пользователей.
Также к критическим ресурсам относятся оперативная память, пропускная способность дисковой подсистемы, пропускная способность сети. При нехватке каждого из этих ресурсов отзывчивость вашего сервиса может упасть настолько, что вы начнёте терять аудиторию.
Важные ресурсы — это те, по динамике изменений которых можно предположить, что с проектом скоро возникнут проблемы. Например, если у вас начинает использоваться своп-файл, то в большинстве случаев это говорит о нехватке оперативной памяти. К тому же использование своп-файла снижает производительность системы, и в результате это может привести к недоступности проекта для пользователей.
Статус RAID, то есть дисковой подсистемы, статус «здоровья» самих дисков, может свидетельствовать о скором возникновении сбоя и потере информации. Также достаточно важной метрикой является IOPS — количество операций ввода/вывода в секунду. Обращайте внимание и на AVIO диска — среднее время ответа на запросы к диску. Если, например, AVIO равно порядка 10 миллисекунд, то пора задуматься, не поменять ли конкретный диск. Очень рекомендуется мониторить количество использованных сокетов на сервере, температуру процессора и скорость вращения вентиляторов.
Особенно обращаю ваше внимание на температуру процессора — бывают случаи, что когда процессор перегревается, то сервер просто не может нормально обрабатывать все поступающие запросы.
### Серверное ПО
Здесь необходимо ясно представлять себе, что и зачем мониторится. То есть нужно полностью отдавать себе отчёт, для чего нужен каждый параметр, который мы ставим на мониторинг, для которого настраиваем уведомления, за что он отвечает.
**Nginx**. Для этого продукта RPS, безусловно, самая важная характеристика. Эта аббревиатура расшифровывается как requests per second, то есть количество запросов к вашему сайту в секунду.
**PHP-FPM**. Здесь нужно также мониторить RPS, количество активных процессов, сообщения о том, что pool PHP-FPM достиг предела по количеству процессов.
**Sphinx**. Это система полнотекстового поиска на сайтах. Здесь необходимо мониторить количество запросов и Fatal Error. Дело в том, что в версиях Sphinx ниже 3.х в отдельных случаях могут регистрироваться ошибки, ведётся лог, но при этом система работает, принимает запросы и не отвечает на них. В этом случае мы получаем очень нехорошую ситуацию: казалось бы, всё работает замечательно, запросы на Sphinx идут, но при этом на сайте пустая страничка с кодом 200.
**MySQL**. Необходимо мониторить количество запросов к базе данных: select, update, insert. Необходимо отслеживать количество обрабатываемых строк. Например, вы немного изменили логику проекта и у вас теперь используются другие запросы, а вот индексы вы забыли добавить. Следующий параметр для отслеживания: скорость обработки столбцов. Скажем, если раньше у вас обрабатывалось 10 миллионов в минуту и всё было хорошо, то теперь совершенно внезапно обрабатывается 120 миллионов столбцов, диски работают на пределе, всё тормозит. Так что отслеживание этого параметра может дать понять, в чём именно проблема после очередного деплоя.
Также необходимо контролировать buffer pool usage и replica status. Cтатус реплики очень важен в том случае, когда применяется отказоустойчивая схема. Таким образом мы отслеживаем, чтобы резерв был в активном состоянии.
**Exim**. Мониторьте размер очереди почтового сервера. Если она очень быстро растет или долго не уменьшается, это может говорить о том, что, например, какой-нибудь почтовый сервис забанил наш сервер и считает все письма с него спамом.
### Бизнес-логика
Необходимо мониторить группу параметров, которые относятся к бизнес-логике приложения. Почему-то многие про них забывают, сосредотачиваясь на сервере и логах ПО. В самом проекте можно мониторить компоненты бизнес-процессов. Например, количество новых регистраций пользователей, которые хотят совершить покупки. В ряде случаев снижение количества может быть и косвенным свидетельством каких-то поломок в проекте.
Но если процесс регистрации работает некорректно, то пользователь не сможет разместить заказ, оформить покупку, оплатить и т.д. Поэтому в отдельных ситуациях, когда мы не уверены в том, что у нас не поломался процесс регистрации, имеет смысл мониторить весь процесс от начала и до конца. То есть от момента ввода пользователем своих данных до того, как он нормально залогинится и увидит в корзине свои товары.
В зависимости от принятой бизнес-логики на сайтах, которые занимаются распространением приложений, необходимо мониторить, например, количество скачиваний. В рекламных проектах рекомендуется отслеживать количество показов баннеров, их просмотров, отношение просмотров к кликам и т.д.
Косвенный, но не менее важный параметр — это доступность сервисов компаний-партнёров, используемых в вашем проекте. К пример, Java-скрипт, который подгружается со стороннего сервера. Если у партнера тормозят серверы, то Java-скрипт будет грузиться медленно. Это будет особенно нехорошо, если ваш сайт построен так, что без этого Java-скрипта загрузка страницы дальше не идёт. Получается, что проблемы у чужого дяди, а страдают ваши пользователи.
Также в отдельных ситуациях помогает статистика по запросам с тем или иным реферером. Это очень актуально для партнёрок: мы может понять, где и кто накручивает трафик. Если вы или ваш клиент предполагаете, что где-то в коде закралась ошибка и статистика считается неправильно, то можно скорректировать её по логам.
Как мониторить сложные цепочки бизнес-логики? Например, проверить работу формы регистрации? Можно поступить так:
* Создаём почтовый сервер.
* Пишем PHP-скрипт, который идёт на клиентский сайт и регистрируется как обычный пользователь.
* После этого скрипт проверяет содержимое ящика, парсит письмо, берёт из него ссылку подтверждения регистрации, проходит по ней, получает ответ, парсит его и логинится с теми данными, с которыми зарегистрировался.
* В завершение всех процедур скрипт отправляет в систему мониторинга 1 или 0, в зависимости от результатов проверки. Естественно, все действия скрипта должны подробно логгироваться.
### Проблемы с системой мониторинга
Мониторинг тоже может ломаться. Поэтому очень важно отслеживать работоспособность самой системы мониторинга. Это может быть какой-то отдельный скрипт, запускающийся по cron, или какая-то другая проверка. Но самое главное — необходимо проверять, что мониторинг доступен, работает, оправляет уведомления, проверяет значения, сверяет их с настроенными вами уведомлениями и т.д. Без этой проверки в один прекрасный момент вы можете обнаружить, что вроде бы графики рисуются, а сервис лежит уже третий день.
### Инструменты мониторинга
Начнем с open source-систем, Zabbix и Graphite.
#### Zabbix
Бэкенд системы написан на PHP, в качестве БД для хранения метрик может использоваться MySQL, PostgreSQL, SQLite или Oracle. На клиентской стороне может применяться либо Zabbix-агент, либо SNMP, либо какие-то скрипты, которые посылают данные в Zabbix. Под «клиентом» подразумевается сервер, который мы мониторим.
Как строится процесс мониторинга в Zabix:
* Создаем хост в Zabbix.
* Добавляем сервер, который будем мониторить.
* Устанавливаем на нём Zabbix-агент.
* Настраиваем в Zabbix шаблоны, которые надо мониторить, например, Nginx, MySQL. Если каких-то шаблонов нет, можно их нагуглить или написать.
* Настраиваем агента, чтобы он посылал в Zabbix необходимые параметры.
* Настраиваем web-сценарий для того, чтобы проверять URL на проекте.
Мониторинг Nginx:
* Находим и импортируем шаблоны, поскольку в самом Zabbix нет встроенной проверки Nginx.
* На стороне клиента пишем bash-скрипт, который будет отправлять в Zabbix данные из Nginx-статуса в нужном формате.
* Прописываем include в Zabbix-агент.
После всех этих манипуляций Zabbix начинает мониторить Nginx.
Уведомления в Zabbix построены по принципу у шаблона. У каждого из них есть метрики для мониторинга. Например, RPS, количество запросов и т.д.
У каждой из метрик есть триггер. Скажем, при мониторинге Nginx мы можем сделать для RPS триггер, который сработает, если RPS = 0 в течение пяти минут. При срабатывании триггера отправляется уведомление на почтовый ящик или в любую другую систему уведомлений, которую мы выбрали.
В целом, Zabbix довольно сложен в конфигурировании. Zabbix-сервер масштабируется также, как и любое другое web-приложение, то есть мы можем распараллелить базы данных, web-серверы. При желании можно автоматизировать мониторинг новых услуг. Например, взять любимую систему управления конфигурациями и настроить так, чтобы новый узел после создания автоматически добавлялся в Zabbix.
#### Cacti
Это система с открытым исходным кодом. В качестве бэкенда базы данных для внутренних моментов используется MySQL. Информация о метриках хранится в формате rrdtool, то есть все данные метрик, как и сама Cacti, написаны на PHP. На клиентской стороне используется SNMP-демон, который отправляет данные на сервер Cacti.
Как строится процесс мониторинга в Cacti:
* Устанавливаем на сервер snmppd.
* Конфигурируем rocommunity в snmpd — идентификатор этого сервера.
* Добавляем хост Cacti.
Как видите, всё предельно просто. Сложности начинаются дальше. По умолчанию доступен мониторинг только самых базовых ресурсов — CPU, память, трафик. Все остальные параметры (Nginx, MySQL, почта и т.д.) мониторятся при помощи сторонних плагинов, которые устанавливаются дополнительно. Даже для уведомлений на e-mail требуется плагин. То же самое относится и к мониторингу URL (доступности вашего сайта), настройки уведомлений по превышению каких-то значений и многого другого.
Процесс создания алерта выглядит так:
Выбираем сервер, график и метрику. На этом графике, например, у нас метрики System, User, Nice, загрузка CPU. Уведомление отправляется при превышении загрузки CPU User.
Cacti нельзя назвать гибкой системой. Если Zabbix, например, позволяет с помощью плагинов отправлять уведомления через самые разные системы, в том числе Jabber, Slack и т.д., то в Cacti уведомлению отправляются только через e-mail посредством отдельного плагина.
Так выглядит уведомление, пришедшее на e-mail:
Подведём итог. Мониторинг в Cacti осуществляется либо посредством SNMPD, в котором мы прописали отправку информации на сервер через какие-то наши скрипты, либо с помощью каких-то плагинов, которые устанавливаются на сам сервер Cacti. Уведомления отправляются только на e-mail.
С автоматизацией у Cacti тоже всё достаточно плохо: здесь есть только cli-скрипты из командной строки, которые выполняются на стороне сервера и обладают плохой гибкостью. Масштабируется Cacti как обычное web-приложение, то есть можно горизонтально масштабировать MySQL, можно поставить Nginx, за которым будет несколько web-nod и т.д.
#### Graphite
Эта система с открытым исходным кодом поинтереснее, чем Zabbix и Cacti. Серверная часть системы состоит из трёх частей — Carbon, Whisper и web-приложение Graphite. Последний компонент представляет собой подсистему для отрисовки графиков и их отображения в web.
* Carbon — демон, в который стекаются данные мониторинга с клиентов.
* Whisper — база данных на стороне сервера, в которой накапливается статистика по мониторингу.
* Web-приложение Graphite — подсистема, которая показывает в браузере красивую страничку с графиками.
На клиентской стороне мы можем установить любое ПО, которое будет отсылать Graphite данные в нужном формате. Существует достаточно много решений, можно написать и своё собственное, если готовые вас чем-то не устраивают.
Мониторинг с помощью Graphite предельно прост:
* Устанавливаем не клиент, например, collectd.
* Включаем нужные плагины.
* Указываем, какие параметры надо мониторить.
* Конфигурируем их соответствующим образом. Например, прописываем доступ к MySQL или к статусу Nginx, и настраиваем оправку данных в Graphite.
```
Host "127.0.0.1"
User "root"
Password "sohW2ax0Eenox9t"
Database "test1"
MasterStats false
```
Можно мониторить что угодно и чем угодно. Лишь бы ваше приложение нормально отправляло данные в Graphite. Так выглядит стандартное джанговое приложение, которое отрисовывает данные с Graphite.
Если нужны более красивые графики, то можно использовать другие приложения.
Уведомления настраиваются достаточно гибко. К пример, есть решения, которые позволяют отправлять уведомления через почту, HipChat, Slack, либо на свои собственные сервисы. Пример настройки уведомлений:
```
"alerts": [
{
"name": "Memory",
"query": "aliasByNode(collectd.*.memory.memory-free, 1)",
"interval": "1minute",
"format": "bytes",
"rules": ["warning: < 300MB", "critical: < 200MB"]
},
```
Всё делается в текстовом формате, после чего перезагружаем систему уведомлений, и она подхватывает новые параметры. Пример уведомления, пришедшего на почту:
Graphite довольно гибкая система, которая позволяет мониторить практически всё, что угодно. Конфигурировать надо в основном на клиентской стороне, то есть ту часть, которая отправляет данные мониторинга на сервер. Уведомления настраиваются как угодно. Автоматизация осуществляется просто, в текстовом формате.
Graphite масштабируется горизонтально. У используемого в нём движка хранения Whisper есть ограничения: при большом количестве серверов (от нескольких десятков) мы упираемся в ограничение самого формата, и в этом случае надо менять бэкенд. Но такое происходит не часто, поэтому изначально можно использовать только Whisper.
Если у вас много рабочих серверов, и один сервер мониторинга не справляется со всеми метриками, то для масштабирования можно использовать решение Graphite-relay.
### SaaS-мониторинг
Данный подход применяется, когда сервер мониторинга находится на стороне компании-разработчика.
В качестве примера рассмотрим сервер Density. Регистрируемся в сервисе и добавляем туда свой сервер. Нам выдают ссылку, по которой мы скачиваем агент и устанавливаем на свой сервер.
У нас есть наш сервер, добавленный в SaaS-сервис, и Python-демон, запущенный на нашем сервере. От нас теперь требуется только настройка этого Python-демона: например, добавить данные для Nginx-статуса и данные доступа для MySQL. После перезагрузки, в настройках Server Density надо активироват отображение графиков для MySQL и Nginx.
При использовании SaaS-мониторинга можно отслеживать многие параметры. Например, URL нашего интернет-магазина. При этом будет мониториться код ответа на запрос, время ответа и т.д. Можно создать необходимые нам уведомления по любому параметру.
Большинство сервисов SaaS-мониторинга построены следующим образом: есть некий web-интерфейс, через который мы добавляем сервер, устанавливаем агент на свой сервер — и всё. Больше от нас никаких сложных действий по настройке мониторинга не требуется. Только в понятном web-интерфейсе настраиваем уведомления по нужным нам параметрам.
### Какой инструмент выбрать?
Основные факторы, влияющие на ваш выбор: количество узлов, которые необходимо мониторить и задачи, которые планируется решать. Например, для маленького стартапа с одним сервером идеальным вариантом будет Server Density. Для организации с распределённой сетевой инфраструктурой и большим количеством серверов в разных городах наилучшим решением будет Zabbix. Для небольшого офиса, где необходимо мониторить какие-то базовые показатели серверов, великолепно подойдет Cacti. | https://habr.com/ru/post/270341/ | null | ru | null |
# Создание и использование собственных атрибутов AD в PowerShell
В этой статье я покажу вам, как можно расширять схему AD, создавать нестандартные атрибуты и управлять ими в AD — и всё это с помощью Windows PowerShell. Следуя этому руководству, вы сможете устанавливать и управлять собственными атрибутами AD с помощью PowerShell точно так же, как вы управляете другими атрибутами AD.
Стандартная схема Active Directory содержит большинство атрибутов, которые обычно требуются организации в инфраструктуре AD. Однако стандартных атрибутов не всегда достаточно, когда речь идёт о больших организациях. Когда я управлял Active Directory в крупной школе, меня попросили установить несколько атрибутов для пользователей, которые не были доступны в AD по умолчанию. Тогда мне пришлось расширять схему AD для определения кастомных атрибутов и устанавливать эти атрибуты для пользователей.
Атрибуты могут быть любыми, но для целей этой статьи предположим, что мы добавляем два атрибута — «Название кампуса» (`Campus Name`) и «ID кампуса» (`Campus ID`).
Небольшое предостережение
-------------------------
Обратите внимание, что внесение изменений в схему AD подобно операции на мозге. Любое изменение, хорошее или плохое, которое вы внесёте в схему AD, повлияет на весь «лес» AD. Кроме того, изменения схемы необратимы и не могут быть отменены. Пожалуйста, не пробуйте использовать эти команды непосредственно в производственной среде. Даже если вы эксперт по AD — могут произойти плохие вещи. Я настоятельно рекомендую сначала выполнить эти шаги в тестовой среде.
Необходимые условия
-------------------
Чтобы успешно выполнить действия, описанные в этой статье, вы должны соблюдать следующие требования:
* Вы должны быть членом группы Active Directory **Schema Admins**.
* На DC должен быть установлен [модуль Active Directory для Windows PowerShell](https://4sysops.com/wiki/how-to-install-the-powershell-active-directory-module/).
* Вы можете выполнить эти шаги непосредственно на DC или через интерактивный сеанс PowerShell (Enter-PSSession) на DC.
Создание идентификаторов OID для объектов AD
--------------------------------------------
Все объекты AD имеют уникальный идентификатор, называемый идентификатором объекта (OID). Сначала мы создадим скрипт для генерации OID для пользовательских атрибутов (Campus Name и Campus ID), которые мы будем добавлять в схему AD. Мы создадим скрипт и назовём его «**Generate-OID.ps1**».
Чтобы создать скрипт:
Скопируйте приведённый ниже код и сохраните его в файле с именем «**Generate-OID.ps1**».
```
$Prefix = "1.2.840.113556.1.8000.2554"
$GUID = [System.Guid]::NewGuid().ToString()
$GUIDPart = @()
$GUIDPart += [UInt64]::Parse($GUID.SubString(0,4), "AllowHexSpecifier")
$GUIDPart += [UInt64]::Parse($GUID.SubString(4,4), "AllowHexSpecifier")
$GUIDPart += [UInt64]::Parse($GUID.SubString(9,4), "AllowHexSpecifier")
$GUIDPart += [UInt64]::Parse($GUID.SubString(14,4), "AllowHexSpecifier")
$GUIDPart += [UInt64]::Parse($GUID.SubString(19,4), "AllowHexSpecifier")
$GUIDPart += [UInt64]::Parse($GUID.SubString(24,6), "AllowHexSpecifier")
$GUIDPart += [UInt64]::Parse($GUID.SubString(30,6), "AllowHexSpecifier")
$OID = [String]::Format("{0}.{1}.{2}.{3}.{4}.{5}.{6}.{7}", $Prefix, $GUIDPart[0], $GUIDPart[1], $GUIDPart[2], $GUIDPart[3], $GUIDPart[4], $GUIDPart[5], $GUIDPart[6])
Write-Host $OID -ForegroundColor Green
```
Сохраните этот скрипт в нужном месте и удалите расширение файла **.txt**. Я сохраняю его на диске **Z:** для более удобного доступа.
Когда скрипт **Generate-OID.ps1** будет готов, вы сможете запустить его для генерации OID. На следующем изображении показано, как его запустить.
*Запуск скрипта Generate OID.ps1*
Убедитесь, что консоль PowerShell запущена с повышенными привилегиями. Чтобы запустить скрипт, загруженный из Интернета, необходимо временно изменить **ExecutionPolicy** для текущего процесса PowerShell. Когда вы запустите этот скрипт, вы увидите сгенерированный OID в зелёном цвете. При каждом запуске генерируется новый OID. Вам нужно скопировать сгенерированный OID и использовать его в следующем разделе, чтобы вы могли держать этот сеанс PowerShell открытым для следующего раздела.
Создание индивидуальных атрибутов в AD
--------------------------------------
Прежде чем непосредственно добавить атрибуты, давайте я покажу вам, что они ещё не созданы в моём AD. Я выполню команду **Get-ADUser** для пользователя **student1**.
*Получаем ошибку кастомных атрибутов ADUser «Одно или несколько значений недопустимы» (`Get-ADUser : One or more properties are invalid.`)*
Посмотрите на вывод команды **Get-ADUser**. Там говорится: «Одно или несколько значений недопустимы», что означает, что свойства «Campus Name» и «Campus ID» ещё не существуют в моей среде AD.
Чтобы добавить пользовательские атрибуты «Campus Name» и «Campus ID» в схему AD, мы воспользуемся Windows PowerShell ISE.
1. Чтобы запустить ISE из уже открытой консоли PowerShell, просто введите «`ise`» без кавычек и нажмите `Enter`. PowerShell ISE запустится в той же рабочей директории.
2. Кликните на иконку нового скрипта, чтобы открыть панель скриптов.
3. Скопируйте и вставьте следующий код в панель скриптов ISE:
```
# получить путь к схеме AD
$adSchema = (Get-ADRootDSE).schemaNamingContext
# получить схему пользователя
$userSchema = Get-ADObject -SearchBase $adSchema -Filter "Name -eq 'User'"
# задать короткое имя для кастомного атрибута без пробелов
$attributeName = "CampusName"
# установить краткое описание для кастомного атрибута
$attributeDesc = "Campus Name"
# вставить OID, созданный скриптом "Generate-OID.ps1"
$OID = "1.2.840.113556.1.8000.2554.56779.46056.47028.16885.40810.7627542.10407433"
# oMSyntax - "64" для String (Unicode). Другие типы см. по этой ссылке: https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/7cda533e-d7a4-4aec-a517-91d02ff4a1aa
$oMSyntax = 64
# attributeSyntax - "2.5.5.12" для String (Unicode). Другие типы см. по этой ссылке: https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/7cda533e-d7a4-4aec-a517-91d02ff4a1aa
$attributeSyntax = "2.5.5.12"
# Установите значение indexable в "1", если вы хотите, чтобы AD индексировал этот атрибут. Устанавливайте это значение только в том случае, если вы будете часто запрашивать этот атрибут AD
$indexable = 0
# создание кастомных атрибутов hashtable
$adAttributes = @{
lDAPDisplayName = $attributeName;
adminDescription = $attributeDesc;
attributeId = $OID;
oMSyntax = $oMSyntax;
attributeSyntax = $attributeSyntax;
searchflags = $indexable
}
# создание кастомного атрибута в схеме AD
New-ADObject -Name $attributeName -Type attributeSchema -Path $adSchema -OtherAttributes $adAttributes
# добавление кастомного атрибута в класс пользователя
$userSchema | Set-ADObject -Add @{mayContain = $attributeName}
```
Данный скрипт также прилагается и для наглядности.
1. Каждая строка кода имеет поясняющий комментарий к работе. Пожалуйста, не запускайте этот код сразу. Есть некоторые разделы, которые необходимо изменить в соответствии с вашими требованиями, прежде чем вы сможете выполнить этот код.
*Модификация скрипта PowerShell*
* Как минимум вам нужно изменить значения переменных `attributeName`, `attributeDesc` и `OID`, которые отмечены красным цветом на изображении выше. Вы можете установить эти значения по своему усмотрению.
* Значение переменной `OID` будет сгенерировано скриптом **Generate-OID.ps1**, который мы создали в предыдущем разделе.
* Вы также можете изменить значения `oMSyntax`, `attributeSyntax` и *индексируемых* переменных. Дополнительные сведения о поддерживаемых значениях атрибутов см. во внутристрочных комментариях.
2. После внесения изменений, показанных выше, вы можете нажать кнопку «Run Script» или клавишу «F5» для выполнения скрипта
3. Если вы не получаете никаких ошибок, ваш пользовательский атрибут (Campus Name) был добавлен
4. Чтобы создать второй атрибут (Campus ID), измените значения переменных `attributeName`, `attributeDesc` и `OID` в скрипте и выполните его снова
5. После создания атрибутов в схеме AD подождите немного, чтобы изменения смогли воспроизвестись на других контроллерах домена в вашем «лесу». Это может занять некоторое время, в зависимости от размера вашей инфраструктуры Active Directory
6. Теперь, когда наши кастомные атрибуты созданы, необходимо перезапустить **доменные службы Active Directory**, чтобы изменения вступили в силу. Чтобы перезапустить службы с помощью PowerShell, выполните следующую команду:
`Get-Service NTDS -DependentServices | Restart-Service -Force -Verbose`
7. После успешного перезапуска служб AD повторите ту же команду, которую мы выполняли в начале этого раздела:
`Get-ADUser student1 -Properties Name, CampusName, CampusID`
*Кастомные атрибуты Get-ADUser*
Видите? Ошибку «Одно или несколько значений недопустимы» — мы больше не получаем. Но подождите минутку! А где же пользовательские атрибуты, которые мы только что создали?
В обычном состоянии эти атрибуты не видны. Чтобы увидеть их, нам нужно выполнить команду PowerShell, показанную ниже:
```
Get-ADUser student1 -Properties * | Select -Property Name, CampusName, CampusID
```
*Фильтр кастомных атрибутов Get-ADUser*
Нам просто нужно сказать модулю AD PowerShell о том, чтобы он получил все параметры для выбранного пользователя, а затем передал результаты командлету Select-Object для фильтрации и отображения только выбранных свойств (`Name`, `CampusName` и `CampusCode`).
В следующем разделе мы обсудим, как управлять этими пользовательскими атрибутами с помощью Windows PowerShell.
Управление кастомными атрибутами с помощью PowerShell
-----------------------------------------------------
На данном этапе у нас уже есть собственные атрибуты, доступные для использования в Active Directory. Вы можете использовать инструменты GUI или Windows PowerShell для управления (установки, изменения или удаления) этими кастомными атрибутами для пользователей AD. Поскольку мы все делали с помощью PowerShell, то давайте этого и придерживаться.
### Установка кастомных атрибутов
Чтобы установить значение для наших атрибутов, выполните следующую команду в консоли PowerShell:
```
Set-ADUser student1 -Add @{CampusName="NewYorkISD"; CampusID="NYISD001"}
```
Мы использовали формат PowerShell hashtable с параметром `-Add` для присвоения значений кастомным атрибутам.
### Вывод данных из кастомных атрибутов
Чтобы вывести в командной строке данные из настроенных нами атрибутов, выполните следующую команду:
```
Get-ADUser student1 -Properties * | Select -Property Name, CampusName, CampusID
```
*Настройка Get-ADUser на добавление кастомных атрибутов*
Как вы видите, значения теперь присвоены созданным нами атрибутам.
### Модификация кастомных атрибутов
Как только мы зададим атрибуты, вы больше не сможете использовать параметр `-Add` вместе с командой `Set-ADUser`. Это связано с тем, что мы создали кастомные атрибуты, которые могут содержать только единичные значения. Чтобы изменить значение наших атрибутов, нам нужно использовать параметр `-Replace`. Обновлённая команда будет выглядеть следующим образом:
```
Set-ADUser student1 -Replace @{CampusName="LAISD"; CampusID="LAISD001"}
```
*Настройка Get-ADUser на модификацию кастомных атрибутов*
### Удаление значений кастомных атрибутов
Чтобы удалить значения настроенных нами атрибутов, выполните следующую команду:
```
Set-ADUser student1 -Remove @{CampusName="LAISD"; CampusID="LAISD001"}
```
Чтобы удалить все значения атрибутов, мы используем параметр -Remove.
*Настройка Get-ADUser на удаление кастомных атрибутов*
> На этом мы заканчиваем данную статью. Сегодня вы узнали, как расширять схему Active Directory для добавления кастомных атрибутов и как управлять этими атрибутами с помощью Windows PowerShell!
---
НЛО прилетело и оставило здесь промокод для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**. | https://habr.com/ru/post/654627/ | null | ru | null |
# PVS-Studio in the Clouds: CircleCI
This is a new piece of our series of articles about using the PVS-Studio static analyzer with cloud CI systems. Today we are going to look at another service, CircleCI. We'll take the Kodi media player application as a test project and see if we can find any interesting bugs in its source code.
**Note.** The previous articles on integrating PVS-Studio with cloud CI systems:
* [PVS-Studio in the Clouds: Azure DevOps](https://www.viva64.com/en/b/0670/)
* [PVS-Studio in the Clouds — Running the Analysis on Travis CI](https://www.viva64.com/en/b/0636/)
Before setting up the work environment and examining the analysis report, I'd like to say a few words about the software we are going to use and check.
[CircleCI](https://circleci.com/) is a cloud CI service for automated software building, testing, and deployment. It supports project building both in containers and on virtual machines on Windows, Linux, and macOS.
[Kodi](https://en.wikipedia.org/wiki/Kodi_(software)) is a free and open-source cross-platform media player application. It allows users to play and view most streaming media, such as videos, music, podcasts, and videos from the Internet, as well as all common digital media files from local and network storage media. It supports the use of themes and skins and functionality extensions through plugins. Kodi is available for Windows, Linux, macOS, and Android.
[PVS-Studio](https://www.viva64.com/en/pvs-studio/) is a static analyzer for detecting bugs and potential vulnerabilities in the source code of applications written in C, C++, C#, and Java. The analyzer runs on Windows, Linux, and macOS.
Setting up
----------
First we need to go to the [CircleCI](https://circleci.com/) main page and click «Sign Up»
On the next page, we are offered to authorize with a GitHub or Bitbucket account. We choose GitHub and get to the CircleCI authorization page.
After authorizing the application (by clicking the green button «Authorize circleci»), we are redirected to the «Welcome to CircleCI!» page:
Here we can specify right away which projects we want CircleCI to build. We tick our repository and click «Follow».
After adding the repository, CircleCI will automatically start the build process, but since we don't have a configuration file in our repository yet, the build job will be aborted with an error message.
Before adding a configuration file, we need to add a couple of variables containing analyzer license data. To do that, we click «Settings» on the left sidebar, select «Projects» in the «ORGANIZATION» section, and click the cogwheel button to the right of our project's name. A settings window will appear.
We go to the «Environment Variables» page. Here we create two variables, *PVS\_USERNAME* and *PVS\_KEY*, which contain the username and analyzer license key.
When starting the build, CircleCI reads the job configuration from the file stored in the repository at .circleci/config.yml. Let's add it.
First we need to specify the image of the virtual machine that the analyzer will be running on. The complete list of images is available [here](https://circleci.com/docs/2.0/configuration-reference/#available-machine-images).
```
version: 2
jobs:
build:
machine:
image: ubuntu-1604:201903-01
```
Next, we add the necessary repositories to apt and install the project's dependencies:
```
steps:
- checkout
- run: sudo -- sh -c "
add-apt-repository -y ppa:team-xbmc/xbmc-ppa-build-depends
&& add-apt-repository -y ppa:wsnipex/vaapi
&& add-apt-repository -y ppa:pulse-eight/libcec
&& apt-get update"
- run: sudo apt-get install -y
automake autopoint build-essential cmake
curl default-jre gawk gdb gdc gettext git-core
gperf libasound2-dev libass-dev libbluray-dev
libbz2-dev libcap-dev libcdio-dev libcec4-dev
libcrossguid-dev libcurl3 libcurl4-openssl-dev
libdbus-1-dev libegl1-mesa-dev libfmt3-dev
libfontconfig-dev libfreetype6-dev libfribidi-dev
libfstrcmp-dev libgif-dev libgl1-mesa-dev
libglu1-mesa-dev libiso9660-dev libjpeg-dev
liblcms2-dev libltdl-dev liblzo2-dev libmicrohttpd-dev
libmysqlclient-dev libnfs-dev libpcre3-dev libplist-dev
libpng-dev libpulse-dev libsmbclient-dev libsqlite3-dev
libssl-dev libtag1-dev libtinyxml-dev libtool libudev-dev
libusb-dev libva-dev libvdpau-dev libxml2-dev libxmu-dev
libxrandr-dev libxrender-dev libxslt1-dev libxt-dev
mesa-utils nasm pmount python-dev python-imaging
python-sqlite rapidjson-dev swig unzip uuid-dev yasm
zip zlib1g-dev wget
```
Adding the PVS-Studio repository and installing the analyzer:
```
- run: wget -q -O - https://files.viva64.com/etc/pubkey.txt
| sudo apt-key add -
&& sudo wget -O /etc/apt/sources.list.d/viva64.list
https://files.viva64.com/etc/viva64.list
- run: sudo -- sh -c "apt-get update
&& apt-get install pvs-studio -y"
```
Then we are building the dependencies:
```
- run: sudo make -C tools/depends/target/flatbuffers PREFIX=/usr/local
```
After that, we generate Makefiles in the build directory:
```
- run: mkdir build && cd build && cmake -DCMAKE_BUILD_TYPE=Debug ..
```
The next step is setting up and starting an analysis of the project.
First we create an analyzer license file. Another command will start tracing the project build by the compiler.
The next command following the tracing runs the analysis as such. If you use a demo version of PVS-Studio, launch it with the parameter:
*--disableLicenseExpirationCheck*.
The final command converts the analyzer's report file into an html report:
```
- run: pvs-studio-analyzer credentials -o PVS.lic ${PVS_USER} ${PVS_KEY}
- run: pvs-studio-analyzer trace -- make -j2 -C build/
- run: pvs-studio-analyzer analyze -j2 -l PVS.lic
-o PVS-Studio.log --disableLicenseExpirationCheck
- run: plog-converter -t html -o PVS-Studio.html PVS-Studio.log
```
Once the tests are over, we save the reports:
```
- run: mkdir PVS_Result && cp PVS-Studio.* ./PVS_Result/
- store_artifacts:
path: ./PVS_Result
```
Here's the complete text of the .circleci/config.yml file:
```
version: 2.1
jobs:
build:
machine:
image: ubuntu-1604:201903-01
steps:
- checkout
- run: sudo -- sh -c "
add-apt-repository -y ppa:team-xbmc/xbmc-ppa-build-depends
&& add-apt-repository -y ppa:wsnipex/vaapi
&& add-apt-repository -y ppa:pulse-eight/libcec
&& apt-get update"
- run: sudo apt-get install -y automake autopoint
build-essential cmake curl default-jre gawk gdb
gdc gettext git-core gperf libasound2-dev libass-dev
libbluray-dev libbz2-dev libcap-dev libcdio-dev
libcec4-dev libcrossguid-dev libcurl3 libcurl4-openssl-dev
libdbus-1-dev libegl1-mesa-dev libfmt3-dev libfontconfig-dev
libfreetype6-dev libfribidi-dev libfstrcmp-dev libgif-dev
libgl1-mesa-dev libglu1-mesa-dev libiso9660-dev libjpeg-dev
liblcms2-dev libltdl-dev liblzo2-dev libmicrohttpd-dev
libmysqlclient-dev libnfs-dev libpcre3-dev libplist-dev
libpng-dev libpulse-dev libsmbclient-dev libsqlite3-dev
libssl-dev libtag1-dev libtinyxml-dev libtool libudev-dev
libusb-dev libva-dev libvdpau-dev libxml2-dev libxmu-dev
libxrandr-dev libxrender-dev libxslt1-dev libxt-dev mesa-utils
nasm pmount python-dev python-imaging python-sqlite
rapidjson-dev swig unzip uuid-dev yasm zip zlib1g-dev wget
- run: wget -q -O - https://files.viva64.com/etc/pubkey.txt
| sudo apt-key add –
&& sudo wget -O /etc/apt/sources.list.d/viva64.list
https://files.viva64.com/etc/viva64.list
- run: sudo -- sh -c "apt-get update && apt-get install pvs-studio -y"
- run: sudo make -C tools/depends/target/flatbuffers PREFIX=/usr/local
- run: mkdir build && cd build && cmake -DCMAKE_BUILD_TYPE=Debug ..
- run: pvs-studio-analyzer credentials -o PVS.lic ${PVS_USER} ${PVS_KEY}
- run: pvs-studio-analyzer trace -- make -j2 -C build/
- run: pvs-studio-analyzer analyze -j2 -l PVS.lic
-o PVS-Studio.log --disableLicenseExpirationCheck
- run: plog-converter -t html -o PVS-Studio.html PVS-Studio.log
- run: mkdir PVS_Result && cp PVS-Studio.* ./PVS_Result/
- store_artifacts:
path: ./PVS_Result
```
Once this file is uploaded to the repository, CircleCI will automatically start the build.
Once the job is finished, the files with the analysis results can be downloaded on the «Artifacts» tab.
Analysis results
----------------
OK, now let's take a look at some of the warnings output by the analyzer.
**PVS-Studio warning:** [V504](https://www.viva64.com/en/w/v504/) It is highly probable that the semicolon ';' is missing after 'return' keyword. AdvancedSettings.cpp:1476
```
void CAdvancedSettings::SetExtraArtwork(const TiXmlElement* arttypes,
std::vector& artworkMap)
{
if (!arttypes)
return
artworkMap.clear();
const TiXmlNode\* arttype = arttypes->FirstChild("arttype");
....
}
```
The code formatting suggests the following execution logic:
* if *arttypes* is a null pointer, the method returns;
* if *arttypes* is a non-null pointer, the *artworkMap* vector gets cleared and some actions are then performed.
But the missing ';' character breaks it all, and the actual execution logic is as follows:
* if *arttypes* is a null pointer, the *artworkMap* vector gets cleared and the method returns;
* if *arttypes* is a non-null pointer, the program executes whatever actions come next but the *artworkMap* vector doesn't get cleared.
To cut a long story short, this situation does look like a bug. After all, you hardly expect anyone to write expressions like *return artworkMap.clear();* :).
**PVS-Studio warnings:**
* [V547](https://www.viva64.com/en/w/v547/) Expression 'lastsector' is always false. udf25.cpp:636
* [V547](https://www.viva64.com/en/w/v547/) Expression 'lastsector' is always false. udf25.cpp:644
* [V571](https://www.viva64.com/en/w/v571/) Recurring check. The 'if (lastsector)' condition was already verified in line 636. udf25.cpp:644
```
int udf25::UDFGetAVDP( struct avdp_t *avdp)
{
....
uint32_t lastsector;
....
lastsector = 0; // <=
....
for(;;) {
....
if( lastsector ) { // <= V547
lbnum = lastsector;
terminate = 1;
} else {
//! @todo Find last sector of the disc (this is optional).
if( lastsector ) // <= V547
lbnum = lastsector - 256;
else
return 0;
}
}
....
}
```
Note the spots marked with *// <=*. The *lastsector* variable is assigned the value 0 and then used as a conditional expression in two *if* statements. Since the value doesn't change either in the loop or between the assignments, control will never get into the *else* branches of both *if* statements.
However, it could also mean that the developers simply haven't implemented the intended functionality yet (note the *[todo](https://habr.com/ru/users/todo/)* remark).
By the way, as you probably noticed, this snippet triggered three warnings at once. But even that many warnings for one piece of code wouldn't look convincing enough to some users, and they would keep believing that the analyzer is wrong… This aspect is discussed in detail in a post by one of my teammates: "[One Day from PVS-Studio User Support](https://www.viva64.com/en/b/0671/)" :).
**PVS-Studio warning:** [V547](https://www.viva64.com/en/w/v547/) Expression 'values.size() != 2' is always false. GUIControlSettings.cpp:1174
```
bool CGUIControlRangeSetting::OnClick()
{
....
std::vector values;
SettingConstPtr listDefintion = settingList->GetDefinition();
switch (listDefintion->GetType())
{
case SettingType::Integer:
values.push\_back(m\_pSlider->
GetIntValue(CGUISliderControl::RangeSelectorLower));
values.push\_back(m\_pSlider->
GetIntValue(CGUISliderControl::RangeSelectorUpper));
break;
case SettingType::Number:
values.push\_back(m\_pSlider->
GetFloatValue(CGUISliderControl::RangeSelectorLower));
values.push\_back(m\_pSlider->
GetFloatValue(CGUISliderControl::RangeSelectorUpper));
break;
default:
return false;
}
if (values.size() != 2)
return false;
SetValid(CSettingUtils::SetList(settingList, values));
return IsValid();
}
```
The *values.size() != 2* check is redundant here since this conditional expression will always evaluate to *false*. Indeed, if execution enters one of the *case* branches of the *switch* statement, two elements will be added to the vector, and since it was initially empty, its size will naturally become equal to 2; otherwise (i.e. if the *default* branch is executed), the method will return.
**PVS-Studio warning:** [V547](https://www.viva64.com/en/w/v547/) Expression 'prio == 0x7fffffff' is always true. DBusReserve.cpp:57
```
bool CDBusReserve::AcquireDevice(const std::string& device)
{
....
int prio = INT_MAX;
....
res =
dbus_bus_request_name(
m_conn,
service.c_str(),
DBUS_NAME_FLAG_DO_NOT_QUEUE |
(prio == INT_MAX ? 0 : DBUS_NAME_FLAG_ALLOW_REPLACEMENT), // <=
error);
....
}
```
The *prio* variable is initialized to the *INT\_MAX* value and then used as an operand of the ternary operator in the *prio == INT\_MAX* comparison, though its value doesn't change after the initialization. It means the *prio == INT\_MAX* expression is *true* and the ternary operator will always return 0.
**PVS-Studio warnings:**
* [V575](https://www.viva64.com/en/w/v575/) The potential null pointer is passed into 'memcpy' function. Inspect the first argument. Check lines: 39, 38. DVDOverlayImage.h:39
* [V575](https://www.viva64.com/en/w/v575/) The potential null pointer is passed into 'memcpy' function. Inspect the first argument. Check lines: 44, 43. DVDOverlayImage.h:44
```
CDVDOverlayImage(const CDVDOverlayImage& src)
: CDVDOverlay(src)
{
Data = (uint8_t*)malloc(src.linesize * src.height);
memcpy(data, src.data, src.linesize * src.height); // <=
if(src.palette)
{
palette = (uint32_t*)malloc(src.palette_colors * 4);
memcpy(palette, src.palette, src.palette_colors * 4); // <=
}
....
}
```
Both warnings have the same pattern: a pointer returned by the *malloc* function is used further in the *memcpy* function without being checked for *NULL* first.
Some may argue that *malloc* will never return a null pointer, and if it does, it would be better for the application to crash. It's a subject of a separate discussion, but whatever your opinion is, I recommend reading this post by my teammate: "[Why it is important to check what the malloc function returned](https://www.viva64.com/en/b/0558/)".
If you wish, you can customize the analyzer so that it doesn't assume that *malloc* could return a null pointer – this will keep it from outputting this type of warnings. More details can be found [here](https://www.viva64.com/en/m/0040/).
**PVS-Studio warning:** [V522](https://www.viva64.com/en/w/v522/) There might be dereferencing of a potential null pointer 'entry'. Check lines: 985, 981. emu\_msvcrt.cpp:985
```
struct dirent *dll_readdir(DIR *dirp)
{
....
struct dirent *entry = NULL;
entry = (dirent*) malloc(sizeof(*entry));
if (dirData->curr_index < dirData->items.Size() + 2)
{
if (dirData->curr_index == 0)
strncpy(entry->d_name, ".\0", 2);
....
}
```
This example is similar to the previous one. The pointer returned by the *malloc* function is stored to the *entry* variable, and this variable is then used without a prior null check (*entry->d\_name*).
**PVS-Studio warning:** [V773](https://www.viva64.com/en/w/v773/) Visibility scope of the 'progressHandler' pointer was exited without releasing the memory. A memory leak is possible. PVRGUIChannelIconUpdater.cpp:94
```
void CPVRGUIChannelIconUpdater::SearchAndUpdateMissingChannelIcons() const
{
....
CPVRGUIProgressHandler* progressHandler =
new CPVRGUIProgressHandler(g_localizeStrings.Get(19286));
for (const auto& group : m_groups)
{
const std::vector members = group->GetMembers();
int channelIndex = 0;
for (const auto& member : members)
{
progressHandler->UpdateProgress(member.channel->ChannelName(),
channelIndex++, members.size());
....
}
progressHandler->DestroyProgress();
}
```
The value of the *progressHandler* pointer was returned by the *new* operator. But there is no *delete* operator for this pointer. This means a memory leak.
**PVS-Studio warning:** [V557](https://www.viva64.com/en/w/v557/) Array overrun is possible. The 'idx' index is pointing beyond array bound. PlayerCoreFactory.cpp:240
```
std::vector m\_vecPlayerConfigs;
bool CPlayerCoreFactory::PlaysVideo(const std::string& player) const
{
CSingleLock lock(m\_section);
size\_t idx = GetPlayerIndex(player);
if (m\_vecPlayerConfigs.empty() || idx > m\_vecPlayerConfigs.size())
return false;
return m\_vecPlayerConfigs[idx]->m\_bPlaysVideo;
}
```
The *if* statement restricts the *m\_vecPlayerConfigs* vector's size to a certain range by having the method return if the size-checking condition is true. As a result, when execution reaches the last *return* statement, the *m\_vecPlayerConfigs* vector's size will be within the specified range, [1; idx]. But a couple of lines later, the program is indexing the vector at *idx*: *m\_vecPlayerConfigs[idx]->m\_bPlaysVideo*. It means that if *idx* is equal to the vector's size, we'll be indexing beyond the valid range.
Let's wind up this article with a couple of examples from the code of the **Platinum** library.
**PVS-Studio warning:** [V542](https://www.viva64.com/en/w/v542/) Consider inspecting an odd type cast: 'bool' to 'char \*'. PltCtrlPoint.cpp:1617
```
NPT_Result PLT_CtrlPoint::ProcessSubscribeResponse(...)
{
....
bool subscription = (request.GetMethod().ToUppercase() == "SUBSCRIBE");
....
NPT_String prefix = NPT_String::Format("
PLT_CtrlPoint::ProcessSubscribeResponse %ubscribe for
service \"%s\" (result = %d, status code = %d)",
(const char*)subscription?"S":"Uns", // <=
(const char*)service->GetServiceID(),
res,
response?response->GetStatusCode():0);
....
}
```
The developers have had wrong assumptions about the operations' precedence. What gets cast to *const char\** is not the result returned by the ternary operator (*subscription? «S»: «Uns»*) but the *subscription* variable. This looks strange, at the very least.
**PVS-Studio warning:** [V560](https://www.viva64.com/en/w/v560/) A part of conditional expression is always false: c == '\t'. NptUtils.cpp:863
```
NPT_Result NPT_ParseMimeParameters(....)
{
....
case NPT_MIME_PARAMETER_PARSER_STATE_NEED_EQUALS:
if (c < ' ') return NPT_ERROR_INVALID_SYNTAX; // END or CTLs are invalid
if (c == ' ' || c == '\t') continue; // ignore leading whitespace
....
}
```
The code of the space character is 0x20, and the code of the tab character is 0x09. Therefore, the *c == '\t'* subexpression will always evaluate to *false* as this case is already covered by the *c < ' '* check (which, if true, will cause the function to return).
Conclusion
----------
As this article demonstrates, we successfully set up an analysis by PVS-Studio on yet another CI system (CircleCI). I invite you to [download and try](https://www.viva64.com/en/pvs-studio-download/) the analyzer on your own project. If you have any questions about the setting-up or use of PVS-Studio, don't hesitate to [contact us](https://www.viva64.com/en/about-feedback/) – we'll be glad to help.
And, of course, we wish you bugless code. :) | https://habr.com/ru/post/470465/ | null | en | null |
# Добавляем watermark к изображению
Привет, Хабрахабр!
Вчера, прочитав [статью](http://sergeyvoyteshonok.habrahabr.ru/blog/41499/ "статья") [SergeyVoyteshonok](https://habrahabr.ru/users/sergeyvoyteshonok/), посвященную отрисовке логотипа сайта или компании (проще говоря, «водяного знака») на загружаемых пользователями изображениях, я был удивлен некоторой тяжеловесностью предложенного автором решения.
Тогда я [пообещал](http://sergeyvoyteshonok.habrahabr.ru/blog/41499/#comment_1013630 "мой комментарий") немного поэкспериментировать и предложить более рациональный вариант.
В моей версии метод отрисовки выглядит так:
> `public void DrawWatermark(Image original, Bitmap watermark,
>
> WatermarkPosition position, Color transparentColor, float opacity)
>
> {
>
> if (original == null)
>
> throw new ArgumentNullException("original");
>
> if (watermark == null)
>
> throw new ArgumentNullException("watermark");
>
> if (opacity < 0 || opacity > 1)
>
> throw new ArgumentOutOfRangeException("Watermark opacity value is out of range");
>
>
>
> Rectangle dest = new Rectangle(
>
> GetDestination(original.Size, watermark.Size, position), watermark.Size);
>
>
>
> using (Graphics g = Graphics.FromImage(original))
>
> {
>
> ImageAttributes attr = new ImageAttributes();
>
> ColorMatrix matrix = new ColorMatrix(new float[][] {
>
> new float[] { opacity, 0f, 0f, 0f, 0f },
>
> new float[] { 0f, opacity, 0f, 0f, 0f },
>
> new float[] { 0f, 0f, opacity, 0f, 0f },
>
> new float[] { 0f, 0f, 0f, opacity, 0f },
>
> new float[] { 0f, 0f, 0f, 0f, opacity } });
>
> attr.SetColorMatrix(matrix);
>
> watermark.MakeTransparent(transparentColor);
>
>
>
> g.DrawImage(watermark, dest, 0, 0, watermark.Width, watermark.Height,
>
> GraphicsUnit.Pixel, attr, null, IntPtr.Zero);
>
> g.Save();
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Дополнительно, мы используем также две вещи:
> `public enum WatermarkPosition
>
> {
>
> TopLeft = 0,
>
> TopRight,
>
> BottomLeft,
>
> BottomRight,
>
> Middle
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
для указания точки привязки, и метод, возвращающий нам конкретную точку расположения водяного знака в зависимости от размеров изображений и точки привязки:
> `private static Point GetDestination(Size originalSize, Size watermarkSize, WatermarkPosition position)
>
> {
>
> Point destination = new Point(0, 0);
>
> switch (position)
>
> {
>
> case WatermarkPosition.TopRight:
>
> destination.X = originalSize.Width - watermarkSize.Width;
>
> break;
>
> case WatermarkPosition.BottomLeft:
>
> destination.Y = originalSize.Height - watermarkSize.Height;
>
> break;
>
> case WatermarkPosition.BottomRight:
>
> destination.X = originalSize.Width - watermarkSize.Width;
>
> destination.Y = originalSize.Height - watermarkSize.Height;
>
> break;
>
> case WatermarkPosition.Middle:
>
> destination.X = (originalSize.Width - watermarkSize.Width) / 2;
>
> destination.Y = (originalSize.Height - watermarkSize.Height) / 2;
>
> break;
>
> }
>
> return destination;
>
> }
>
> \* This source code was highlighted with Source Code Highlighter.`
На мой взгляд, все достаточно прозрачно. Собственно отрисовка логотипа заняла всего 15 строк, учитывая все навороты форматирования, а без них — и того меньше! Такого результата позволило достичь применение для решения задачи возможностей .NET-класса ColorMatrix.
Вообще, класс [ColorMatrix](http://msdn.microsoft.com/en-us/library/system.drawing.imaging.colormatrix.aspx "reference") обладает очень широкими возможностями манипуляции настройками изображения. С помощью него можно не только задавать прозрачность, но и изменять контрастность, насыщенность картинки, делать из нее негатив и многое другое.
В заключение нужно отметить две вещи. Первая — логотип, используемый в качестве водяного знака, лучше сохранять в PNG. GIF-формат для простых логотипов также допустим. В этом случае мы можем не задавать transparentColor (точнее, вообще убрать строчку `watermark.MakeTransparent(transparentColor);`) и расширить тип watermark до Image.
Вторая, несколько более важная — мой метод выполняет отрисовку прямо на переданной ему картинке, не создавая нового экземпляра. Поэтому, если вам необходимо сохранять и оригинал, нужно будет немного переделать метод для отрисовки с тем, чтобы он возвращал измененное изображение, не затрагивая исходного.
**UPD:** Если вы загружали исходное изображение из файла и хотите сохранить его под тем же именем, вам также нужно будет создать копию и сохранить ее вне блока using.
**UPD2:** По [просьбе](http://habrahabr.ru/blogs/net/41546/#comment_1015440) [Sergeyev](https://habrahabr.ru/users/sergeyev/) добавил демонстрацию результата (слева — исходная картинка, справа — она же с известным всем логотипом. Не фотошоп! :)
 
Ну вот, собственно, и все!
**P.S.:** Вот так, совершенно незаметно, появился мой первый топик на Хабре :) | https://habr.com/ru/post/41546/ | null | ru | null |
# Недружественные почтовые сервера
«Не препятствуйте доставке почты»Всем привет. Долго думал, о чём здесь написать — к сожалению, редко находится на это время и желание. Но недавно случилась одна не очень хорошая история, из которой я сделал выводы и решил, что эта информация может быть кому-то полезна, поэтому хочу рассказать о том, что произошло. История эта связана с электронной почтой, а если быть более точным — с отказом сетевой инфраструктуры РЖД в обслуживании персонального почтового сервера из-за его «недружественности».
Я старался не углубляться сильно в технические моменты, так как посчитал, что для понимания ситуации они не очень важны. Но если кому-то будет интересно, могу попробовать рассказать более подробно о технической стороне вопроса в следующих публикациях.
**UPD 29.04.2022:** Написал [статью](https://habr.com/ru/post/663566/) о настройке VPN-туннеля для обхода ограничений.
Введение
--------
Начну издалека. Мне всегда было интересно, как работает электронная почта в интернете, особенно когда я узнал о том, что протокол SMTP очень старый и сохранился в текущем виде до настоящего времени практически без изменений. В конечном итоге я решил попробовать свои силы в настройке собственного почтового сервера. Кто-то скажет, что это не нужно, хотя лично для меня это был весьма интересный и полезный опыт. Но я не буду здесь излагать технические подробности, так как статья вообще не об этом. Могу лишь сказать, что «туториалов» по поднятию своей почтовой системы в интернете сейчас можно найти довольно много, но я бы не рекомендовал считать их абсолютной истиной в последней инстанции, ведь тонкая настройка в конечном итоге вам всё равно потребуется, и понимать, за что именно отвечает тот или иной параметр конфигурации, необходимо.
Следует заметить, что когда я выбирал хостинг-провайдера, я не рассматривал варианты размещения сервера на территории РФ (думаю, причины этого понятны). Изучая различные предложения, в конце концов я остановил свой выбор на небольшом не очень известном провайдере из страны ЕС, географически расположенной недалеко от России (чтобы пинг был поменьше) — здесь без конкретики, чтобы никто не подумал, что я занимаюсь рекламой. Конечно, всё это происходило ещё до начала всем известных событий, поэтому тогда я не мог даже предполагать, что в будущем могут возникнуть проблемы с оплатой. Интересно, что когда всё это началось, провайдер прислал мне уведомление с предложением внести предоплату за как можно больший период времени — и это было ещё до того, как Visa и MasterCard объявили об уходе из РФ. Не знаю, действительно ли они могли предвидеть будущее, но я им очень благодарен — у меня как раз было некоторое количество свободных средств, и я решил воспользоваться ими и продлить аренду сервера на несколько лет вперёд. О прекращении обслуживания российских клиентов, равно как и вообще о своей позиции по отношению к происходящему, провайдер до сих пор не сообщил — поэтому пока можно надеяться, что сервер будет оставаться доступным в ближайшие годы, если только нас не отключат от мирового интернета. А когда наступит время следующей оплаты, ситуация может измениться (хотелось бы, чтобы в лучшую сторону).
Проблема
--------
До недавнего времени никаких серьёзных проблем с отправкой и получением почты я не испытывал — я не осуществляю массовых рассылок, сервер поднимал в первую очередь для личного и семейного пользования. Да, иногда письма у получателей могут попадать в спам, но это общеизвестная проблема для мелких серверов, и со временем она проходит, если всё настроено корректно. Но, как это обычно бывает, беда пришла оттуда, откуда не ждали.
Примерно с начала марта я стал замечать, что мне перестали приходить на почту бланки электронных билетов от РЖД — я люблю ездить по железным дорогам и нередко покупаю билеты онлайн. Само по себе отсутствие бланков не является чем-то катастрофическим, так как все билеты доступны в приложении, а на большинство поездов есть электронная регистрация и при посадке нужно показывать только паспорт. Но сам факт того, что письма раньше приходили, а теперь перестали, насторожил.
Я решил связаться с поддержкой РЖД, отправив письмо по электронному адресу [ticket@rzd.ru](mailto:ticket@rzd.ru)... и столкнулся с невозможностью это сделать. Сначала в логах почтового сервера начали появляться сообщения об ошибке DNS-резолвинга MX-хостов для домена [rzd.ru](http://rzd.ru).
Небольшое отступление по поводу DNSДля тех, кто не знает, как работает электронная почта: для каждого домена, на который приходят письма, в DNS должны быть прописаны MX-записи, которые содержат имена серверов входящей почты для этого домена. Например, чтобы отправить письмо на адрес [test@example.com](mailto:test@example.com), следует сначала получить MX-записи для домена [example.com](http://example.com) и затем соединяться по протоколу SMTP с серверами, на которые эти записи указывают. Если MX-записей нет, вместо них могут использоваться A (или AAAA) записи, но обычно так делать не рекомендуется.
Важный технический момент: одной из мер по предотвращению спама является необходимость обращаться к публичным провайдерам чёрных (и белых) списков доменов и IP-адресов. Эти списки реализованы как DNS-сервера, и их владельцы обычно разрешают использовать их бесплатно в некоммерческих целях, если количество запросов не очень большое. Но при использовании открытых DNS-резолверов (таких как 1.1.1.1 или 8.8.8.8) отследить количество запросов невозможно, потому что этими резолверами пользуется огромное число людей по всему миру. Решением данной проблемы является установка на почтовый сервер локального рекурсивного DNS-резолвера (такого как, например, [Unbound](https://www.nlnetlabs.nl/projects/unbound/)), который будет выполнять обращения к DNS-серверам самостоятельно.
Решить проблему с ошибкой резолвинга MX для [rzd.ru](http://rzd.ru) было просто — Unbound позволяет перенаправлять запросы на другой DNS-сервер для любой зоны. Я добавил в конфигурацию следующие строчки:
```
forward-zone:
name: "rzd.ru."
forward-addr: 1.1.1.1
```
После этого резолвинг заработал, но письмо на [ticket@rzd.ru](mailto:ticket@rzd.ru) всё равно не шло. На этот раз причина была в том, что соединение с сервером входящей почты РЖД не устанавливалось из-за таймаута. Сначала я решил, что это какая-то временная проблема, и оставил письмо в очереди. Через 5 дней (да, тогда у меня ещё было терпение) письмо вернулось обратно как недоставленное — соединиться с серверами РЖД так и не удалось.
Переписка с РЖД
---------------
Здесь я вспомнил, что в новостях некоторое время назад сообщали о DDoS-атаках на инфраструктуру РЖД, и предположил, что подсеть, где находится мой почтовый сервер, была заблокирована в целях защиты от этих атак. Я не знаю, действительно ли велись из данной подсети какие-то атаки или нет, но мне точно известно, что мой сервер в них не участвовал — наверное, если я напишу об этом в РЖД, его разблокируют? С этими наивными мыслями я решил составить обращение через [форму обратной связи РЖД](https://company.rzd.ru/ru/9265/). Ответ они обещали дать в течение 30 дней, но, как ни странно, он пришёл относительно быстро — за 9 дней. Только вот либо я недостаточно подробно изложил суть проблемы, либо сами РЖД решили не заморачиваться, поэтому весь их ответ свёлся к просьбе проверить папку «Спам»:
Ответ на первое обращение (в нём две страницы, но на второй нет ничего интересного)Интересно, что в контактной форме я указывал обратный адрес, обслуживаемый моим почтовым сервером. И ответ пришёл именно на него, но не с серверов РЖД, а с серверов Google. С серверами РЖД связи всё ещё не было (спойлер: и нет до сих пор). Какое-то время я ждал, надеясь, что проблема всё-таки временная и разрешится через несколько дней — но, конечно же, этого не произошло, поэтому я написал ещё одно письмо уже непосредственно в поддержку на [ticket@rzd.ru](mailto:ticket@rzd.ru), где постарался изложить ситуацию как можно подробнее. По понятным причинам мне пришлось делать это с аккаунта Gmail, который раньше был моим основным почтовым аккаунтом, а теперь используется как резервный. Для солидности я представился не единственным владельцем почтового сервера, а одним из его системных администраторов, и сообщил, что на нём зарегистрировано несколько пользователей, которые тоже клиенты РЖД и испытывают аналогичные проблемы. Также я поблагодарил их за предложение проверить папку «Спам», но отметил, что оно является бессмысленным, поскольку мне доступны все логи соединений на сервере. И ещё я напомнил им про то, что письма не только не приходят, но и не отправляются.
В этот раз ответ пришёл быстрее, но ничего полезного в нём опять не было. Сотрудники РЖД просто попробовали соединиться с моим сервером, у них это сделать не получилось, и они сказали, что проблема на моей стороне:
Ответ на второе обращениеТакой вариант действительно не исключается — ровно до тех пор, пока не установлено, где именно происходит обрыв соединения. Но раз сотрудники РЖД решили не заниматься выяснением подробностей, мне пришлось делать это самостоятельно. Для этого я использовал утилиту `traceroute` в TCP-режиме, указав порт 25 (основной порт SMTP-соединений между почтовыми серверами) в качестве целевого. Результат трассировки можно видеть ниже — я скрыл IP-адреса некоторых узлов в начале маршрута, чтобы не выдавать информацию о провайдере:
```
$ traceroute -T -O info -p 25 gvc-cggw-cgfe-01.rzd.ru
traceroute to gvc-cggw-cgfe-01.rzd.ru (217.175.155.64), 30 hops max, 60 byte packets
1 0.184 ms 0.124 ms 0.111 ms
2 0.363 ms 0.352 ms 0.351 ms
3 0.458 ms 0.449 ms 0.439 ms
4 0.370 ms 0.354 ms 0.340 ms
5 13.133 ms 13.120 ms 13.092 ms
6 GW-TransTeleCom.retn.net (87.245.249.47) 23.123 ms 22.941 ms 22.923 ms
7 spb14ra.transtelecom.net (188.43.208.50) 21.852 ms spb14ra.transtelecom.net (188.43.208.82) 21.727 ms spb14ra.transtelecom.net (188.43.208.50) 21.761 ms
8 spb14ra.transtelecom.net (188.43.208.78) 23.299 ms spb14ra.transtelecom.net (188.43.208.86) 24.061 ms 23.582 ms
9 mskn17ra.transtelecom.net (188.43.235.34) 30.704 ms 30.695 ms 30.725 ms
10 CSS-gw.transtelecom.net (188.43.235.33) 29.512 ms 29.702 ms 30.975 ms
11 \* \* \*
...
30 \* \* \*
```
Здесь видно, что трафик доходит до узла `CSS-gw.transtelecom.net (188.43.235.33)` и дальше попадает в чёрную дыру. Чтобы понять, что происходит, я попробовал провести аналогичную трассировку, но уже с сервера, расположенного на территории РФ. Результаты для сравнения ниже — всё ещё не хочу рекламировать провайдеров, поэтому скрываю начальные адреса и в этот раз:
```
$ traceroute -T -O info -p 25 gvc-cggw-cgfe-01.rzd.ru
traceroute to gvc-cggw-cgfe-01.rzd.ru (217.175.155.64), 30 hops max, 60 byte packets
1 0.274 ms 21.345 ms 0.324 ms
2 0.303 ms 0.578 ms 0.643 ms
3 0.654 ms 0.605 ms 1.602 ms
4 1.344 ms \* \*
5 \* mskn17ra.transtelecom.net (188.43.235.34) 1.360 ms 1.330 ms
6 mskn17ra.transtelecom.net (188.43.235.34) 1.464 ms 1.363 ms CSS-gw.transtelecom.net (188.43.235.33) 1.772 ms
7 CSS-gw.transtelecom.net (188.43.235.33) 1.693 ms \* \*
8 \* \* \*
9 gvc-cggw-cgfe-01.rzd.ru (217.175.155.64) 2.190 ms \* \*
```
Здесь с соединением всё в порядке, и более того — видно, что после `CSS-gw.transtelecom.net (188.43.235.33)` трафик почти сразу попадает на почтовый сервер РЖД. Между ними есть ещё один узел, который нам не ответил, но можно предположить, что это какой-то межсетевой экран. В любом случае, если сравнить эти результаты с предыдущими, то становится ясно, что источник проблемы находится гораздо ближе к РЖД, чем к моему провайдеру.
Результаты обеих проверок (которые, вообще говоря, должны были делать сотрудники РЖД) я отправил в очередном обращении, попросив также по возможности провести обратную трассировку, чтобы получить ещё одно свидетельство о том, на чьей стороне проблема. Очередной ответ был получен в течение нескольких дней. В этот раз без комментариев, просто читайте:
Ответ на третье обращение (в логе указаны IPv4 и IPv6 адреса моего сервера)На этом шаге мне надоело вести переписку с РЖД, хотя, в теории, её можно было продолжать и дальше, например, таким образом: США — недружественная страна, а сервера Gmail находятся в ней, так почему же тогда доступ к серверам Gmail не закрыт? Лично мне было бы интересно посмотреть, что они ответят на это, но у меня больше нет желания тратить своё время. И вне зависимости от их ответа, мы и так знаем, в чём причина: если перестанут приходить письма от РЖД на Gmail, то жалобы посыпятся уже тысячами. Поэтому заблокировать Gmail они не могут, а вот личный независимый почтовый сервер — вполне. Конечно, я не думаю, что они блокируют конкретные сервера по IP-адресам: скорее всего, такая блокировка осуществляется по подсетям или даже по страновой принадлежности из WHOIS-данных, а подсеть Gmail просто внесена в белый список.
Выводы
------
Какой вывод можно сделать из всей этой истории? Если вы можете обойти проблемы с оплатой и продолжаете использовать сервера за границей, нужно быть готовым к появлению аналогичных ситуаций в будущем. И речь здесь идёт не только об электронной почте, так как эти блокировки вряд ли затрагивают лишь один протокол. В частности, это может касаться, например, того же DNS — на моём сервере в последние два месяца такое тоже происходило (помните про проблему с резолвингом MX?).
Чтобы обойти блокировку, мне пришлось арендовать дополнительный виртуальный сервер на территории РФ и добавить его с низким приоритетом в список MX-хостов для своих почтовых доменов. На этом сервере никакая почта не хранится — он соединён с основным через VPN-туннель, в который перенаправляются все входящие SMTP-соединения. Пришлось повозиться с настройками, чтобы при подключении через VPN был виден реальный IP-адрес удалённой стороны, а не локальный адрес сервера в туннеле (это важно для антиспам-проверок), но в конце концов таким способом мне всё-таки удалось получить письмо от РЖД. В теории, через этот же сервер можно также и отправлять письма в РЖД, но, как я уже говорил, вести с ними дальнейшую переписку я не планирую.
Техническое отступлениеПолноценная реализация MTA должна проверять все MX-записи в DNS для домена получателя в порядке их приоритета. При любой временной ошибке (таковой является, в частности, отсутствие соединения), возникшей при попытке доставить почту через основной сервер, MTA должен совершить попытку доставки через сервера, указанные в MX с более низким приоритетом. В штатной ситуации, когда связь с основным сервером имеется, более низкоприоритетные MX использоваться не должны.
Кто-то скажет, что описанной здесь проблемы можно было бы избежать, изначально выбрав сервер на территории РФ. На первый взгляд это действительно так, да и проблем с оплатой такого сервера сейчас бы не было. Но даже если не рассматривать вопросы, связанные с безопасностью хранения личной переписки на сервере в РФ, остаётся ещё такой момент: **а вы точно уверены, что подобные блокировки могут осуществляться только со стороны российских сервисов**? К примеру, ограничение веб-трафика по географическому признаку всегда являлось весьма распространённой практикой — это я говорю по своему опыту, так как нередко наблюдал сообщение «Access Denied» или просто таймауты при попытке зайти на какой-либо иностранный веб-сайт, и началось это задолго до 24 февраля 2022 года. А уж после этой даты я не вижу никаких препятствий к расширению подобных ограничений и на другие виды интернет-трафика — и затронуть они могут не только электронную почту. | https://habr.com/ru/post/662555/ | null | ru | null |
# Быстрый консольный ввод на .NET
Во времена, когда .NET был закрытой технологией только для Windows, за ним и языком C# закрепилась репутация платформы, которая отлично подходит для решения бизнес-задач, но непригодна для соревновательного программирования и написания высокопроизводительного кода.
Часто приходится слышать, что "шарпы медленные", особенно в контексте алгоритмических задач, например с [timus.online](http://timus.online) и [codeforces.com](https://codeforces.com). И, увы, не только слышать, но и сталкиваться с реальными проблемами, связанными с особенностями платформы, получая *Wrong Answer, Runtime Error, Memory Limit, Time Limit* при корректном алгоритме.
Большинство этих проблем кроется в особенностях консольного ввода и вывода. Да и часто куда проще написать `cin >> n`или `sc.nextInt()`, чем `int.Parse(Console.ReadLine())` или `Console.ReadLine().Split().Select(int.Parse).ToArray()`, из-за чего выбор падает на другой язык.
Далее я расскажу о распространённых проблемах с консольным вводом-выводом в .NET, и о том, как сделать ввод быстрым и удобным.
Плавающая запятая
-----------------
Иногда требуется считать или вывести число с плавающей точкой. Но легко забыть, что плавающие точки в .NET бывают запятыми, в зависимости от локали. Об этом особенно легко забыть, если пользоваться английской локалью в своей операционной системе.
Варианта решения два:
* задать локаль потока: `Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;`
* передавать `CultureInfo.InvariantCulture` явно в такие методы, как `(Try)Parse` и `ToString`
Также в современном .NET есть [параметр рантайма](https://learn.microsoft.com/en-us/dotnet/core/runtime-config/globalization) `InvariantGlobalization`, позволяющий избежать подобных проблем.
Ввод и вывод
------------
Представим, что нам дана простая задача: нужно считать  строк по 4 числа `int` в каждой , числа разделены пробелами. Требуется вывести сумму чисел для каждой строки.
```
int n = int.Parse(Console.ReadLine());
for (int i = 0; i < n; ++i)
{
var result = Console.ReadLine().Split().Select(int.Parse).Sum();
Console.WriteLine(result);
}
```
Может ли в этом коде что-то привести к вердикту, отличному от Accepted? Запросто.
### Особенности форматирования
В условии ничего не сказано про количество пробелов, которыми разделены числа. И в итоге, если где-то пробелов больше одного, `Console.ReadLine().Split()` вернёт массив, содержащий пустые строки. А `int.Parse` упадёт с исключением, что приведёт к вердикту **Runtime Error**. Может показаться, что такого не бывает на контестах, но увы, случай вполне реальный.
Исправляем код:
```
int n = int.Parse(Console.ReadLine());
for (int i = 0; i < n; ++i)
{
var result = Console.ReadLine()
.Split(' ', StringSplitOptions.RemoveEmptyEntries)
.Select(int.Parse)
.Sum();
Console.WriteLine(result);
}
```
Неприятный нюанс, о котором надо помнить. Кстати, если раньше код обрабатывал все пробельные символы как разделители, то теперь только пробелы. Исправить можно, но будет чуть длиннее.
Проблема возникает только при построчном чтении ввода. В языках, где есть готовые способы для считывания с консоли чисел (например `int n; cin >> n`), проблемы не возникает вообще.
### Console Flush
Потоки ввода и вывода stdin/stdout/stderr устроены на основе буфера в памяти, в который один процесс может записать данные, а другой — прочитать. Обращаться к этому буферу ради нескольких байт — дорого, поэтому для эффективности каждый процесс может дополнительно буферизовать ввод/вывод. Продвижение данных в буфер потока происходит либо при заполнении локального, либо при вызове `.Flush()`.
Вызов `.Flush()` имеет большой смысл для интерактивных консольных приложений — пользователю нужно показать вывод в терминале сразу, а не копить его в памяти. Большинство платформ изначально адаптированы под этот сценарий и вызывают `.Flush()` автоматически после каждой записи.
> Обратите внимание, что бывают и задачи, в которых требуется интерактивный ввод-вывод (request-response семантика). Например задачи, в которых требуется вычислить ответ, задавая "вопросы" проверяющей системе (простейший пример — программа, угадывающее слово в условном "Поле чудес", "общающаяся" с программой-ведущим)
Чтобы сэкономить на Flush, в C++ iostreams пишут:
```
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
```
А в C# можно использовать `StreamWriter` для `stdout` вместо `Console`:
```
const int bufferSize = 16384;
using var input = new StreamReader(
Console.OpenStandardInput(), bufferSize: bufferSize);
using var output = new StreamWriter(
Console.OpenStandardOutput(), bufferSize: bufferSize);
int n = int.Parse(input.ReadLine());
for (int i = 0; i < n; ++i)
{
var result = input.ReadLine()
.Split(' ', StringSplitOptions.RemoveEmptyEntries)
.Select(int.Parse)
.Sum();
output.WriteLine(result);
}
```
Проверим, оказывает ли `.Flush()` влияние на производительность замерами. Версия с `Console.WriteLine` отрабатывает на моём компьютере за **~490ms**, а с использованием `StreamWriter` — за **105ms**. Т.е. причина плохой производительности оказалась вовсе не в LINQ. В проверяющей системе c более медленным железом можно запросто получить *Time Limit Exceed*, если не учитывать автоматический `.Flush()`. Кстати, на заметку, в энтерпрайз приложениях проблема тоже встречается — в логировании.
Замерял на Linux, рантайм .NET 7 NativeAOT — так достигается минимальный оверхед на старте программы, порядка 1.5 ms. На Windows как минимум старт процесса был бы порядка 10 ms, даже для C++.
Для чтения также можно использовать `StreamReader` вместо `Console`. Это позволяет сэкономить на проверке, не переопределён ли `Console.In` при каждом чтении и использовать увеличенный буфер, но выигрыш куда менее впечатляющий — единицы миллисекунд
Обратите внимание, что задавать размер буфера консольному стриму нет смысла — параметр попросту игнорируется
Задача на ввод: аллокации
-------------------------
Задача [1510](https://timus.online/problem.aspx?space=1&num=1510&locale=ru) с Тимуса. Для этой задачи есть два решения — за линию и с сортировкой. Её все сдают легко на том же C++, но на C# даже с умным алгоритмом из-за особенностей стандартного ввода будет *Memory Limit Exceed*. Почему?
В задаче установлен Memory Limit в 16 MB. Зачем? Не знаю, сохранить все числа в памяти и отсортировать он никак не мешает, ведь 500000 чисел по 4 байта — всего лишь 2 MB. Но в C# чтение ввода через `Console.ReadLine` приводит к аллокации строк. А *строка* с числом из 10 цифр, это не 4 байта, а, как минимум:
* 16 байт на заголовок объекта и указатель на Method Table
* 4 байта на хранение длины
* 20 байт на 10 символов в UTF-16
* 2 байта на null terminator для совместимости с нативным кодом, его ожидающим
Т.е. уже 42 байта на 10 символов. А 500000 раз по 42 байта — это уже 21 MB.
Но они же короткоживущие?! Читаем строку, сразу парсим, GC как-нибудь соберёт. Но срабатывание GC — не гарантированно, освобождение памяти обратно в ОС — тоже, а принудительный вызов через `GC.Collect()` может привести уже к *Time Limit Exceed*.
Как же быть? Писать ввод самостоятельно
Кастомный ввод
--------------
### Дедовское решение
По [C++](https://habr.com/ru/post/246257/) вспоминается решение с [посимвольным](https://codeforces.com/blog/entry/8080?#comment-138179) [чтением](https://www.google.com/search?q=c%252B%252B+fastscan+getchar_unlocked) чисел.
Перепишем его на C# с использованием `Console.Read()`, а лучше — `StreamReader.Read()`. В этом случае использовать `StreamReader` оправдано, потому что обращаться к `Console` на каждый символ гораздо дороже, чем на каждую строку при использовании `ReadLine`.
После этого задача не представляет никакой сложности. На моём компьютере посимвольное чтение отрабатывает в 3 раза быстрее, чем с `Console.ReadLine()`.
**fastscan**
```
StreamReader reader = new StreamReader(Console.OpenStandardInput(), bufferSize: 32768);
int fastscan()
{
bool negative = false;
bool read_start = false;
int number = 0;
while (true)
{
int c = reader.Read();
if (c=='-')
{
negative = true;
read_start = true;
continue;
}
if (c>47 && c<58)
{
number = number * 10 + (c - 48);
read_start = true;
continue;
}
if (read_start)
break;
}
if (negative)
number *= -1;
return number;
}
```
Решение, однако, не идеально. Этот метод подходит для целых чисел, а сделать корректный парсинг чисел с плавающей точкой нетривиально, легко попасть на граничные случаи и ошибиться с точностью. Чтобы это понять, достаточно посмотреть [Pull Request](https://github.com/dotnet/runtime/pull/62301).
### [Тиктокерское](https://dotnext.ru/talks/9bdd39ee9a554ce2b76272ac303ae227/) решение
В современном .NET есть перегрузки методов `Parse` и `TryParse` принимающие `ReadOnlySpan` вместо строки. Вместо ручного парсинга чисел, можно записать фрагмент символов с числом в буфер и вызвать стандартный метод для парсинга.
Это решит проблему с парсингом чисел с плавающей точкой "дедовского" решения, а также сделает ввод кода удобнее, избавив от необходимости писать конструкции вида `Console.ReadLine().Split().Select(int.Parse).ToArray()`. Сам код настолько прост, что может быть легко написан прямо во время контеста (но не учитывает, например, переполнение буфера, если вам это важно):
**SpanScanner**
```
class Scanner
{
StreamReader input = new(Console.OpenStandardInput(), bufferSize: 16384);
char[] buffer = new char[4096];
public int ReadInt()
{
var length = PrepareToken();
return int.Parse(buffer.AsSpan(0, length));
}
private int PrepareToken()
{
int length = 0;
bool readStart = false;
while (true)
{
int ch = input.Read();
if (ch == -1)
break;
if (char.IsWhiteSpace((char)ch))
{
if (readStart) break;
continue;
}
readStart = true;
buffer[length++] = (char)ch;
}
return length;
}
}
```
| Program | Lang | Compiler | Mean (Int) | Mean (Double) |
| --- | --- | --- | --- | --- |
| fastscan | C++ | g++64 | 14 ms | - |
| fastscan | C# | NativeAOT | 22 ms | - |
| Span | C# | NativeAOT | 38 ms | 85 ms |
| cin | C++ | g++64 | 38 ms | 101 ms |
| scanf | C++ | g++64 | 44 ms | 70 ms |
| Console.ReadLine | C# | NativeAOT | 64 ms | 117 ms |
Да, работает медленнее "дедовского" варианта, но на уровне с общепринятыми способами ввода, не аллоцирует memory traffic, и уж точно не станет причиной попадания в *Time* или *Memory* Limit.
> На C++ и других языках можно написать и [более эффективные](https://habr.com/ru/post/246257/) варианты консольного ввода. `scanf` и `cin` взяты только для того, чтобы ориентироваться на способы чтения ввода, которые обычно укладываются в пределы Time Limit
Для .NET 7 и C# 11 можно сделать generic версию на основе статического метода интерфейса `ISpanParsable`. Правда, в проверяющих системах C# 11 ещё не поддерживается.
**SpanParsableScanner**
```
class Scanner
{
StreamReader input = new(Console.OpenStandardInput(), bufferSize: 16384);
char[] buffer = new char[4096];
public T Read() where T : ISpanParsable
{
var length = PrepareToken();
return T.Parse(buffer.AsSpan(0, length), CultureInfo.InvariantCulture);
}
private int PrepareToken()
{
int length = 0;
bool readStart = false;
while (true)
{
int ch = input.Read();
if (ch == -1)
break;
if (char.IsWhiteSpace((char)ch))
{
if (readStart) break;
continue;
}
readStart = true;
buffer[length++] = (char)ch;
}
return length;
}
}
```
Также я подготовил более эффективный вариант кода на основе `TryParse(ReadOnlySpan)`, но он [слишком длинный](https://github.com/epeshk/epeshk.text/blob/master/Epeshk.Text/TextScanner%601.cs), чтобы поместиться здесь. Он разгоняется в моём тесте до 24 мс за счёт чтения данных блоками.
### Отказываемся от StreamReader
`StreamReader` — прослойка между Console Stream, в который обычно попадают ASCII-символы и .NET-строками в кодировке UTF-16. Переделаем код для работы со `Stream` напрямую.
Метод для парсинга, принимающий `ReadOnlySpan` уже не подойдёт. К счастью, в .NET есть класс под названием `Utf8Parser`— наследие разработки библиотеки `System.Text.Json`, решающее ту же задачу для спана байтов. Не обманывайтесь тем, что в названии есть `Utf8` — парсить все [100500 цифр](https://en.wikipedia.org/wiki/Numerals_in_Unicode), которые есть в Unicode он не умеет. Зато с обычными ASCII-цифрами справляется на ура!
Достоинство `Utf8Parser.TryParse` в сравнении с `T.TryParse`— возможность парсить значение с префикса, без заранее подготовленного токена. Сравните:
```
bool TryParse(ReadOnlySpan span, out int value, IFormatProvider provider);
bool TryParse(ReadOnlySpan span, out int value, out int bytesConsumed, char format='\0')
```
Первый метод заставляет заранее заглянуть вперёд и найти разделитель. Затем данные читаются снова для парсинга.
Второй же умеет останавливаться при парсинге токена сам, позволяя распарсить данные за один проход по буферу.
Т.к. `Utf8Parser` — достаточно узкоспециализированный класс, он не поддерживает `IFormatProvider` и локали. Но нам это только в радость — десятичная запятая нам здесь никак не помешает.
При использовании `Utf8Parser` нужно учитывать, что если данных в буфере осталось мало — результат может оказаться неверным. Если какой-то из текстовых токенов разобьётся на два разных чтения из потока данных, например `[.........12][34...........]`, то `Utf8Parser` прочитает этот токен как два разных числа — 12 и 34. Или же для `[........1e][7.......]` вернётся `false` для `1e`, и придётся делать дополнительную проверку: или это невалидный `double` или же просто не хватило данных.
Для упрощения реализации, буду требовать наличия в буфере некоторого минимального количества данных или признака окончания потока данных. Сам код тоже довольно прост и занимается только загрузкой данных из потока и пропуском разделителей, которыми здесь считаются все символы по пробел включительно. По желанию можно также пропускать символы, например, с кодами `>= 128`, на случай если в поток данных попадёт мусор.
Но во время контеста я бы лучше использовал предыдущий вариант на основе `StreamReader` и `Span` — он всё же гораздо проще
**AsciiScanner**
```
class Scanner
{
private const int MaxTokenLength = 1200;
Stream? input = Console.OpenStandardInput();
byte[] buffer = new byte[32768];
Span Fragment => buffer.AsSpan(offset, length - offset);
int offset;
int length;
public int ReadInt()
{
while (input != null && length - offset < MaxTokenLength)
{
if (offset != 0)
{
var remaining = Fragment.Length;
Fragment.CopyTo(buffer);
offset = 0;
length = remaining;
}
var count = input.Read(buffer, length, buffer.Length - length);
if (count <= 0)
{
input = null;
break;
}
length += count;
while (offset < length && buffer[offset] <= ' ') offset++;
}
while (offset < length && buffer[offset] <= ' ') offset++;
var parsed = Utf8Parser.TryParse(Fragment, out int value, out int bytesConsumed);
if (!parsed)
Throw();
offset += bytesConsumed;
return value;
}
void Throw() => throw new Exception();
}
```
Замеры
------
| Program | Lang | Compiler | Mean (Int) | Mean (Double) |
| --- | --- | --- | --- | --- |
| Utf8Parser | C# | NativeAOT | 10 ms | 40 ms |
| fastscan | C++ | g++64 | 14 ms | - |
| fastscan | C# | NativeAOT | 22 ms | - |
| SpanBlock | C# | NativeAOT | 24 ms | 72 ms |
| Span | C# | NativeAOT | 38 ms | 85 ms |
| cin | C++ | g++64 | 38 ms | 101 ms |
| scanf | C++ | g++64 | 44 ms | 70 ms |
| Console.ReadLine | C# | NativeAOT | 64 ms | 117 ms |
В качестве тестовых данных использовался файл с 200000 строками шестизначных чисел по 4 числа в каждой (~5MB). Каждая программа считала XOR каждой из колонок и выводила ответ в конце. Таким образом, тестировалась только производительность ввода рассмотренными способами, с возможностью проверить корректность при тестировании. Входные данные предварительно загружались в память программы, производящей запуск тестируемых программ и подавались на stdin.
В качестве рантайма использовался .NET 7 NativeAOT на Linux. Этот вариант даёт меньше всего оверхеда на старте программы. C JIT на Windows оверхед составил ~36 мс, на Linux — ~70. Очерёдность по скорости для .NET-программ на Windows не отличается.
Тест не претендует на максимальную корректность, ставилась лишь цель оценить порядок разницы между способами чтения ввода.
Выводы
------
* На .NET можно писать программы с интенсивным консольным IO.
* Для достижения максимальной производительности рекомендуется:
+ не использовать статические методы `Console.Write/WriteLine`, а писать в `stdout` через `StreamWriter`
+ для чтения большого количества чисел с консоли (или просто для удобства написания кода) использовать описанные способы: например с дополнительным буфером и неаллоцирующим `TryParse(ReadOnlySpan)`
+ правильно оценивать задачу и не переусложнять код без необходимости
Ссылки
------
* [API Proposal](https://github.com/dotnet/runtime/issues/64621) о новом консольном вводе | https://habr.com/ru/post/705834/ | null | ru | null |
# Пользовательские литералы в C++11
Более полугода прошло с момента принятия стандарта C++11. В сети можно найти много материалов посвященных новому стандарту, однако большинство из них касаются самых простых возможностей, самых сладких. Я говорю о лямбда-функциях, системе автоматического выведения типов, новых спецификаторах, умных указателях и т.д. Да, это действительно интересные вещи и, можно смело сказать, они одни из самых полезных и часто используемых. Но на них свет клином не сошелся, и новенький C++11 предлагает нам не только их.
Ниже я хочу рассказать о пользовательских литералах — весьма полезном средстве, хоть и не в повседневных целях.
#### Что такое литерал?
**Литерал** — это некоторое выражение, создающее объект. Литералы появились не только в C++11, они были и в C++03. Например, есть литералы для создания символа, строки, вещественных чисел, и т.д.
```
'x'; // character
"some"; // c-style string
7.2f; // float
74u; // unsigned int
74l; // long
0xF8; // hexadecimal number
```
Все это литералы. С понятием литералов, думаю, мы разобрались. Самое время вернуться к C++11.
#### Пользовательские литералы в C++11
Как уже было отмечено выше, новый стандарт предлагает средства для создания пользовательских литералов. Существует две категории пользовательских литералов: *сырые литералы (raw)* и *литералы для встроенных типов (cooked)*.
Стоит, однако, заметить, что C++ позволяет создавать только литералы-суфиксы. Иными словами, создать литералы префиксы (как, например, **0x**), или префиксо-суфиксные (как **""**) — не получится.
##### Литералы для численных типов
Начнем с литералов для встроенных типов. Чтобы создать литерал для численных типов необходимо воспользоваться одной из двух сигнатур:
```
// сигнатура литерала для целочисленных типов
OutputType operator "" _suffix(unsigned long long);
// сигнатура литерала для вещественных типов
OutputType operator "" _suffix(long double);
```
Использование литерала будет осуществляется следующим образом:
```
42_suffix; // OutputType operator "" _suffix(unsigned long long);
42.24_suffix; // OutputType operator "" _suffix(long double);
```
Обратите внимание на сигнатуры:
* литерал для целых чисел в качестве аргумента принимает `unsigned long long`
* литерал для вещественных чисел в качестве аргумента принимает `long double`
Данные типы взяты неспроста и их нельзя заменить на другие. Они являются **обязательными** и утверждены стандартом языка.
Ниже приведен пример литерала, преобразовывающего минуты в секунды.
```
unsigned long long operator "" _min(unsigned long long minutes)
{
return minutes * 60;
}
// ...
std::cout << 5_min << std::endl; // на экран выведится 300
```
##### Литералы для строковых типов
Для создания литерала этого типа, необходимо воспользоваться одной из следующих сигнатур:
```
OutputType operator "" _suffix(const char* str, size_t size);
OutputType operator "" _suffix(const wchar_t* str, size_t size);
OutputType operator "" _suffix(const char16_t* str, size_t size);
OutputType operator "" _suffix(const char32_t* str, size_t size);
```
Сигнатура выбирается в зависимости от типа строки:
```
"1234"_suffix; // operator "" _suffix(const char* str, size_t size);
u8"1234"_suffix; // operator "" _suffix(const char* str, size_t size);
L"1234"_suffix; // operator "" _suffix(const wchar_t* str, size_t size);
u"1234"_suffix; // operator "" _suffix(const char16_t* str, size_t size);
U"1234"_suffix; // operator "" _suffix(const char32_t* str, size_t size);
```
Пример литерала преобразующего C-style строку в `std::string` приведен ниже.
```
std::string operator "" s(const char* str, size_t size)
{
return std::string(str, size);
}
// ...
std::cout << "some string"s.length() << std::endl;
```
##### Сырые литералы
Ну и наконец настало время сырого литерала. Сигнатура сырого литерала выглядит следующим образом:
```
OutputType operator "" _suffix(const char* literalString);
```
Этот тип литералов приходит на помощь тогда, когда входное число надо разобрать посимвольно. Т.e. в этом случае число передается в оператор как строка. Если не совсем понятно, взгляните на приведенный ниже код:
```
OutputType operator "" _x(unsigned long long);
OutputType operator "" _y(const char*);
1234_x; // call: operator "" _x(1234);
1234_y; // call: operator "" _y("1234");
```
Используя данный тип литералов, можно написать литерал преобразующий двоичное число в десятичное. Например вот так:
```
unsigned long long operator "" _b(const char* str)
{
unsigned long long result = 0;
size_t size = strlen(str);
for (size_t i = 0; i < size; ++i)
{
assert(str[i] == '1' || str[i] == '0');
result |= (str[i] - '0') << (size - i - 1);
}
return result;
}
// ...
std::cout << 101100_b << std::endl; // выведет 44
```
Существует еще одна сигнатура для сырых литералов. Основана она на применении Variadic Template:
```
template
OutputType operator "" \_b();
```
Преимущества литералов на базе Variadic Template заключается в том, что они могут вычисляться на этапе компиляции. Тот же литерал преобразования двоичного числа в десятичное может быть переписан так:
```
template
struct to\_binary;
template
struct to\_binary
{
static\_assert(high\_bit == '0' || high\_bit == '1', "Not a binary value!");
static const unsigned long long value =
(high\_bit - '0') << (sizeof...(bits)) | to\_binary::value;
};
template
struct to\_binary
{
static\_assert(high\_bit == '0' || high\_bit == '1', "Not a binary value!");
static const unsigned long long value = (high\_bit - '0');
};
template
constexpr unsigned long long operator "" \_b()
{
return to\_binary::value;
}
// ...
int arr[1010\_b]; // значение вычисляется во время компиляции
std::cout << 101100\_b << std::endl; // выведет 44
```
У внимательно читателя мог возникнуть вопрос: *«А что если создать и сырой литерал, и литерал для числа с одним и тем же именем? Какой литерал компилятор применит?»*. Стандарт по этому поводу дает точный ответ и говорит о попытке компилятора применить литералы в следующем порядке:
* `operator "" _x (unsigned long long)` или `operator "" _x (long double)``
* `operator "" _x (const char* raw)`
* `operator "" _x <'c1', 'c2', ... 'cn'>`
Полезно знать, что если определенный пользователем литерал совпадает с системным (например **f**), то выполнится системный.
```
long operator "" f(long double value)
{
return long(value);
}
// ...
std::cout << 42.7f << std::endl; // выведет 42.7
```
#### Выводы
**Бьёрн Страуструп** на конференции *Going Native 2012* приводил полезный пример использования литералов. Мне кажется, он наглядно демонстрирует факт повышения читаемости кода, а также снижает вероятность ошибиться.
```
Speed sp1 = 100m / 9.8s; // very fast for a human
Speed sp2 = 100m / 9.8s2; // error (m/s2 is acceleration)
Speed sp3 = 100 / 9.8s; // error (speed is m/s and 100 has no unit)
```
Механизм пользовательских литералов — это полезный **в некоторых** случаях инструмент. Использовать его где попало не стоит. Подумайте дважды, прежде чем их использовать, ведь литералы коварны: они могут…
* как повысить читаемость кода, так и понизить;
* как сыграть вам на руку, так и против вас.
**p.s:**
Пользовательские литералы поддерживаются компиляторами *gcc 4.7* и *clang 3.1*. | https://habr.com/ru/post/140357/ | null | ru | null |
# Извлечение аппаратного ключа полнодисковой защиты в телефонах Android на процессорах Qualcomm
### Эксплоит [опубликован на Github](https://github.com/laginimaineb/ExtractKeyMaster)
Компания Google начала внедрять полное шифрование диска (Full Disk Encryption, FDE) по умолчанию с версии Android 5.0 Lollipop. В первое время, когда шифрование реализовали в устройствах Nexus 6, многие пользователи жаловались на снижение производительности при чтении и записи данных на накопитель, но с версии Android 6.0 эту проблему вроде бы решили.
Полное шифрование диска защищает всю информацию на телефоне даже в том случае, если устройство попало в руки правоохранительных органов или ~~других~~ злоумышленников.
При включенном шифровании любая информация на телефоне автоматически на лету шифруется ключом AES перед записью на носитель. И наоборот, при считывании информации она автоматически расшифровываются этим ключом.
На устройствах iOS 9 этот ключ является производной функцией от пользовательского пароля и уникального 256-битного аппаратного ключа, зашитого в смартфон на заводе. Взломать шифрование такого уровня с помощью брутфорса не может даже ФБР, как известно из недавней истории со смартфоном стрелка из Сан-Бернардино, из-за которого ФБР и Apple [дошли до суда](https://geektimes.ru/post/271238/). В итоге ФБР всё-таки сумело взломать телефон с помощью неизвестной 0day-уязвимости. Как можно понять из слов главы госструктуры, за обход защиты ФБР [пришлось заплатить](https://geektimes.ru/post/274739/) хакерам более миллиона долларов.
*Полное шифрование диска в iOS*
Таким образом, брутфорс FDE возможен только с использованием конкретного аппаратного устройства. Это значительно затрудняет проведение атаки. В обычном случае можно было бы создать миллион копий и распараллелить брутфорс в облачном сервисе, что позволяет очень быстро подобрать 99% реальных паролей. Но в данном случае приходится ограничиваться единственным устройством, на котором Apple добавляет ещё и дополнительные помехи — задержки между попытками ввода пароля, ограничение на максимальное количество попыток и т.д. Вот почему для спецслужб исключительно важно найти способ извлечения аппаратного UID, тогда брутфорс пароля становится банальной технической задачей.
Полное шифрование диска в Android 5.0+ реализовано несколько иначе, чем в iOS 9, и подробно описано в [блоге Николая Еленкова](https://nelenkov.blogspot.com/2014/10/revisiting-android-disk-encryption.html) и в [официальной документации Android](https://source.android.com/security/encryption/index.html).
Здесь ключ шифрования тоже является производной функцией от обычно слабого пользовательского пароля, но также от случайным образом сгенерированного 128-битного мастер-ключа (Device Encryption Key — DEK) и случайно сгенерированной 128-битной соли. Поле генерации DEK защищается с помощью тщательно продуманной схемы, в которой используются введённые пользователем значения — пинкод/пароль/паттерн (графический ключ) для входа. Затем зашифрованный DEK помещается в специальное зашифрованное хранилище под названием *crypto footer*. Все эти уровни шифрования нужно преодолеть, прежде чем расшифровать DEK, а затем любую информацию, записанную на накопителе.
Как и в случае с iOS 9, в операционной системе Android реализована привязка схемы шифрования к конкретному аппаратному обеспечению, чтобы не допустить брутфорса на копиях операционной системы. Функцию аппаратной привязки выполняет специальное [аппаратное хранилище](https://source.android.com/security/keystore/) — KeyMaster, которое работает в особом окружении Trusted Execution Environment (TEE), полностью независимом от операционной системы Android. Защищённость ключей в окружении KeyMaster имеет важнейшее значение. Только это защищает систему полного шифрования диска от проведения эффективного брутфорса в параллельных потоках на копиях ОС.
В устройствах Android изолированное окружение никогда не выдаёт свой собственный ключ наружу в «небезопасную» среду. Наоборот, модуль KeyMaster получает из небезопасной среды «блоб ключа» (key blob), расшифровывает хранящийся там ключ — и отдаёт его обратно. Другими словами, работа системы шифрования возможна только непосредственно на аппаратном устройстве, но не в виртуальной среде на другом компьютере.
В общем весь процесс схематично можно изобразить на такой диаграмме, которую [приводит Николай Еленков](https://nelenkov.blogspot.com/2014/10/revisiting-android-disk-encryption.html).
Защиту окружения KeyMaster и выполнение команд на выделенном безопасном процессоре обеспечивает защищённая среда, предоставленная производителем оборудования. В Случае с Qualcomm это среда QSEE (Qualcomm Secure Execution Environment). Она допускает к исполнению на выделенном процессоре только отдельные маленькие приложения, которые называются «трастлеты» (trustlets). Один из таких трастлетов — KeyMaster. В исходном коде Android [есть инструкции](http://androidxref.com/5.1.1_r6/xref/hardware/qcom/keymaster/keymaster_qcom.h#70) для обращения к приложению KeyMaster. На самом деле трастлет поддерживает всего четыре инструкции:
```
* Commands supported
*/
enum keymaster_cmd_t {
/*
* List the commands supportedin by the hardware.
*/
KEYMASTER_GENERATE_KEYPAIR = 0x00000001,
KEYMASTER_IMPORT_KEYPAIR = 0x00000002,
KEYMASTER_SIGN_DATA = 0x00000003,
KEYMASTER_VERIFY_DATA = 0x00000004,
};
```
KeyMaster работает в точности как описано выше: он получает блоб ключа, вычисляет подпись и помещает её в буфер.
И вот теперь мы подошли именно к тому этапу, на котором действует новый эксплоит, который появился в открытом доступе 30 июня ([репозиторий на Github](https://github.com/laginimaineb/ExtractKeyMaster)). Эксплоит использует недавно найденные уязвимости [CVE-2015-6639](http://www.cvedetails.com/cve/CVE-2015-6639/) и [CVE-2016-2431](http://www.cvedetails.com/cve/CVE-2016-2431/).
Автор эксплоита, специалист по безопасности Гал Беньямини (Gal Beniamini) написал поддельную версию приложения QSEE и с помощью вышеупомянутых уязвимостей сумел загрузить её в защищённое окружение, тем самым осуществив повышение полномочий и взломав защиту окружения QSEE, которое участвует в процессе генерации ключа для шифрования диска.
Таким образом, гипотетический злоумышленник может «подделать» аппаратную составляющую ключа шифрования и осуществить брутфорс остальных компонентов, обойдя защиту Android на количество повторных попыток. Остаётся только подобрать перебором пользовательский пинкод/пароль.
Кстати говоря, для того редкого случая, когда пользователь установил для шифрования по-настоящему сложный пароль с высокой энтропией и его не удаётся подобрать брутфорсом за приемлемое время, есть запасной план. Если взломать шифрование действительно крайне необходимо, то можно найти точно такой же телефон, той же модели, с такими же царапинами и защитным корпусом — и запрограммировать его на отправку пароля, как только жертва введёт его. Этот поддельный аппарат подкладывается жертве вместо оригинального. Чтобы избежать раскрытия и одновременно устранить риск введения жертвой неправильного пароля с первой попытки, телефон должен быть запрограммирован на то, что никакой введённый пароль он не принимает как правильный.
Но это уже крайний случай, конечно. Обычные пинкоды и пароли на самом деле подобрать довольно просто, если нет аппаратных ограничений на брутфорс.
Есть интересный момент. Защищённую среду на мобильных устройствах устанавливает не сама компания Qualcomm, а OEM-производители. Они могут сотрудничать с правоохранительными органами той страны, в юрисдикции которой находятся, и выполнять требования судебных запросов. Соответственно, если подобная криптографическая схема будет реализована российским производителем, то информация на смартфоне будет рассекречена по запросу российского суда.
И ещё один интересный момент. Несмотря на то, что Гал Беньямини несколько месяцев обсуждал данные уязвимости с Qualcomm и Google, исправить их не так просто — здесь недостаточно программного апгрейда (для двух уязвимостей патчи для Android вышли в [январе](https://source.android.com/security/bulletin/2016-01-01.html) и [мае](https://source.android.com/security/bulletin/2016-05-01.html)), а может понадобиться аппаратный апгрейд. Дело в том, что если злоумышленник получит устройство, то теоретически может откатить программный апгрейд, вернуть аппарат на уязвимую версию и провести атаку.
Как уже говорилось выше, код эксплоита [опубликован на Github](https://github.com/laginimaineb/ExtractKeyMaster). Вот схема его работы.
Гал Беньямини написал [несколько скриптов на Python](https://github.com/laginimaineb/android_fde_bruteforce), которые упрощают брутфорс после срабатывания эксплоита. В комментариях к его блогозаписи коллеги [выразили желание](http://bits-please.blogspot.com/2016/06/extracting-qualcomms-keymaster-keys.html?showComment=1467290026217#c7428272354616706188) помочь в портировании скрипта на мощнейшую платформу для брутфорса [hashcat](https://hashcat.net/hashcat/)/[oclHashcat](https://hashcat.net/oclhashcat/).
Беньямини предполагает, что компания Google вместе с OEM-сборщиками выработают новую абсолютно надёжную схему аппаратно-программного шифрования, которую даже теоретически невозможно будет взломать.
Будем надеется, что такую схему реализуют на новом поколении Android-устройств. | https://habr.com/ru/post/395643/ | null | ru | null |
# Простой Web-доступ к VI приложениям LabVIEW в PHP через ActiveX Server
В LabVIEW уже много лет существует возможность «прикрутить» Web к VI приборам без каких-либо сложных настроек публикации и серверов со стороны LabVIEW, используя только втроенный сервер ActiveX. Не является исключением и LabVIEW 2020 Community edition.
Для LabVIEW на данный момент момент существует несколько способов публикации виртуальных приборов в Web, требующих разного уровня знаний и предоставляющих разные возможности. В этой статье я не собираюсь их описывать, но хочу познакомить вас с нестандартным использованием встроенного в LabVIEW сервера ActiveX/COM для организации Web доступа к VI, а также управления самой средой LabVIEW. Хотя ActiveX/COM уже старая, но еще продолжающая жить в Windows технология, но именно через встроенный ActiveX сервер можно легко организовать управление LabVIEW и VI приборами, в том числе через Web.
Первое что нужно сделать, это включить в LabVIEW этот самый ActiveX сервер, делается это в настройках среды: Tools->Options->VI Server, флажок ActiveX.
Проверить, что сервер включен и к нему есть доступ, можно простым скриптом на VBScript. Нужно создать на рабочем столе текстовой файл labview\_test.vbs и наполнить его следующим содержимым:
```
Dim obj
Set obj = CreateObject("LabVIEW.Application")
'Dim vi
'Set vi = obj.GetVIReference("C:\Users\Dell\Desktop\LabVIEW Web ActiveX\ActiveX Server Executable _LV2012_NI Verified\Executable as ActiveX Server\ActiveX Server.vi")
WScript.Echo(obj.AppName & " ver: " & obj.Version)
'WScript.Echo(vi.GetControlValue("Count"))
'Set vi = Nothing
Set obj = Nothing
```
Перед выполнением скрипта запустите среду LabVIEW. Впрочем, будет работать и без предварительного запуска среды. На время выполнения скрипта будет запущен экземпляр LabVIEW как ActiveX/COM сервер, а по завершении скрипта экземпляр будет закрыт, так что придется подождать, пока все это «загрузится и выгрузится». В выводе labview\_test.vbs будет имя корневого приложения и его версия.
Далее я создал простой VI прибор «ActiveX Server.vi». В нем содержится несколько контролов и вспомогательных функций. Этот VI мы будем загружать и управлять им.
От LabVIEW нам больше ничего не потребуется. Теперь можно приступать к слоям Web.
### Тернистый путь
Сначала я немного поэкспериментировал с штатным Windows Web-сервером Microsoft IIS. Пробовал создавать страницы ASP на VBScript приблизительно следующего содержания:
```
<% @language = "vbscript" %>
ASP can output HTML tags as well as plain text
<%
Dim obj
Set obj = CreateObject("LabVIEW.Application")
response.write(obj.AppName & " ver: " & obj.Version & "
" & vbCr)
Dim vi
Set vi = obj.GetVIReference("C:\Users\Dell\Desktop\LabVIEW Web ActiveX\ActiveX Server Executable \_LV2012\_NI Verified\Executable as ActiveX Server\ActiveX Server.vi")
response.write(vi.GetControlValue("Count") & vbCr)
set vi = Nothing
set obj = Nothing
%>
``` | https://habr.com/ru/post/502496/ | null | ru | null |
# Причины массового обжорства SSD на Macbook с процессорами M1
Мир сошел с ума. Где только не писали о проблеме повышенного аппетита на ресурс SSD-накопителей у новых моделей Macbook Air и Macbook Pro с процессорами M1. Тема обсуждалась на всех популярных технических форумах. И несмотря на массовость проблемы, все обсуждения сводились к тому, что Apple не считает это проблемой. А значит и проблемы нет. И в какую дичь люди готовы поверить для самоуспокоения вместо того, чтобы взглянуть в лицо фактам и выяснить причины стремительной выработки ресурса несъёмного SSD-накопителя.
Одни уважаемые люди говорили (писали), что протокол SMART слишком сложный, чтобы система просто взяла и спросила у контроллера SSD: "а сколько жить тебе осталось, диск?". Дескать, накопители производства Apple - штука не популярная. Где-то накосячили в драйвере. Вот он и выдаёт записанные на диск гигабайты за терабайты. А создатели софта для проверки статуса SMART люди недостаточно грамотные. Да и разные производители железа тоже за 20 лет не могут договориться о единых единицах измерения в параметрах состояния диска.
Любители заговоров выдвинули свою версию - "это всё козни проклятого Intel, уж мы то знаем откуда эти ноги растут". "Им не статус дисков проверять, а их самих проверять надо, этих продажных авторов мошеннических программ."
При всей массовости проявления обжорства SSD, простое как 2 копейки решение (полное отключение Spotlight) как будто скрывается от простых пользователей. Каждый пытается меня убедить, что расход ресурса SSD со скоростью записи 180Гб/час - это нормальное явление.
Кто-то думает, что если правда жизни настолько суровая, то Apple должна отозвать все компьютеры с данным диагнозом. Давайте смотреть фактам в глаза. Я не могу судить о том, как такие события могут происходить за бугром. Но, например, в Москве затраты на массовую смену единственной платы ноутбука будут просто колоссальными. У нас тут не завод Foxconn со 100000 китайцев. Здесь специалисты сервисных центров получают нормальную зарплату, далеко не 30000 руб. Плюс еще заплатить аренду помещения, налоги и прочие сборы. А сколько компьютеров сможет обслужить один специалист в день? в месяц? - Делайте выводы сами.
Мне кажется, Apple всё же тихо мирно пофиксит софтверный баг. А те пользователи, что уже израсходовали ресурс SSD так и останутся с тем же накопителем, который у них стоит. Может быть, в отдельных случаях плату поменяют по гарантии. Но, факт есть факт. Apple поставила новые рекорды продаж ноутбуков. И отзывать все ноутбуки просто не рационально.
Почему я решил, что проблема носит массовый характер? Во-первых, в нашей организации уже три ноутбука с процессором M1. Ноутбуки куплены (заказаны) в разное время с периодичностью в месяц. На всех трех ноутбуках диагноз положительный. Во-вторых, я переустановил разные версии MacOS минимум раз 10. Диагноз был положительным с настройками "по-умолчанию" вплоть до последней на момент публикации версии MacOS 11.2.3.
Рецепт лечения обжорства ресурса SSD
------------------------------------
Как я и говорил, проблему можно купировать временным отключением индексирования Spotlight. Я использовал команду в терминале:
```
sudo mdutil -i off -a
```
Но эта команда решает проблему не полностью. В моём случае мне помогла команда:
```
sudo launchctl unload -w /System/Library/LaunchDaemons/com.apple.metadata.mds.plist
```
Но выполнять вторую команду стоит только с отключенной защитой CSR. Решение подойдёт далеко не всем. Обязательно найдутся и активные пользователи Spotlight и Siri. Отключать или не отключать - индивидуальный выбор каждого пользователя. Лично для меня целостность SSD важнее рабочего поиска по мета-данным.
Вместо заключения. Прошу прощения, что статья написана на скорую руку. Если нужны ссылки на разные обсуждения проблемы, по запросу я вставлю их публикацию. Заранее вангую тонны негодования маководов и технических асов в мою сторону. Все коллеги отговаривали меня писать о проблеме здесь. И я не знаю зачем я пишу эту публикацию сюда. Да и зачем вообще помогать людям? Ведь всем так нравится смотреть на мир через розовые очки.
UPD
Написал текст два месяца назад. Уже и забыл про него. Опубликовали только сейчас. Отвечаю на вопросы.
На момент написания статьи ноутбук у меня был чуть больше двух недель. За две недели система записала 10Тб данных. Стоит заметить, что я на тот момент работал за другими компьютерами. А этот макбук записывал по 1Тб в день в простое. Прошло еще два месяца. Теперь работаю за этим ноутбуком постоянно. Сейчас`smartctl` показывает, что записано 16Тб данных.
Скорость расхода ресурса я проверял командой:
`iostat -w1 disk0`
В третьем столбике будет отображаться показания "запись+чтение".
До исправления было так:
После исправления так:
Запись и чтение по-отдельности можно наблюдать утилитой `top.`
 | https://habr.com/ru/post/558680/ | null | ru | null |
# Qmmp: продолжение. Альтернативные интерфейсы
Этот топик — продолжение [предыдущего](http://habrahabr.ru/blogs/linux/95931/) про замечательный музыкальный плеер Qmmp. Исходя из комментариев, многим не нравится его winamp-подобный GUI, но немногие знают, что он поддерживает альтернативные интерфейсы ( спасибо [dexon](https://habrahabr.ru/users/dexon/) ). В этом топике я рассмотрю два альтернативных интерфейса: [qsmmp](http://gitorious.org/qsmmp) ( на родном qt ) и [qmmp fooUi](http://gitorious.org/qmmp-fooui)( как видно из названия, foobar подобный ).
Использовалась система Ubuntu 10.04, Gnome с стандартной темой Human.
Осторожно, много картинок.
#### Qsmmp
###### Установка
Для установки нужно скачать с репозитория и скомпилировать исходники. Для этого делаем:
`git clone git://gitorious.org/qsmmp/qsmmp.git
cd qsmmp
qmake
make`
Для установки нужны файлы заголовков от qmmp и qmmpui, и соответственные библиотеки ( для Ubuntu нужно установить `libqmmp-dev` и `libqmmpui-dev` пакеты ).
###### Обзор
Запускаем, смотрим. Что есть? Стандартные строка меню, toolbar для управления проигрыванием, два окошечка для коллекции и плейлиста и statusbar. Все, что необходимо.
Toolbar содержит стандартные кнопки проигрывания, регулятор громкости ( квадратик между кнопками и
ползунком. Меняется прокруткой колеса мышки ), ползунок для прокрутки песни, и информацию о длине песни.
Окно коллекций имеет две вкладки: список плейлистов и файловый менеджер.
Файловый менеджер позволяет просто и быстро добавить нужные песни в текущий плейлист. Поскольку, у меня музыка на диске упорядочена, файловый менеджер может служить заменой библиотеки.
Кстати, окно коллекций можно перетаскивать. Можно менять его положение, относительно плейлиста, или же вовсе удалить. Восстановить удаленное окно можно кликнув правой кнопкой мышки по тулбару.
Плейлист отображает список песен таблицей. Работают клавиши *Ctrl + A*, *Del*. Одна неприятная особенность, что если песня без тегов, то в поле Title пишется ее полный путь.
Работает drag'n'drop из стандартного файлового менеджера ( в моем случае, `nautilus` ).
Строку меню сложно назвать функциональной. Наиболее важные пункты меню: *Настройки* и *Эквалайзер*. Настройки стандартные, почти ничем не отличаются от настроек в оригинальном интерфейсе.
Эквалайзер вызывается в отдельном окне.
###### Выводы
Легкий, простой и не перегруженный интерфейс. Свою основную задачу, проигрывание музыки, выполняет отлично. В разработке ( последние изменения были внесены 9 июня ). Поддерживает мультиязычность.
#### Qmmp fooUI
###### Установка
Установка похожа к Qsmmp, т.е. нужно скачать с репозитория и собрать.
`git clone git://gitorious.org/qmmp-fooui/qmmp-fooui.git
cd qmmp-fooui
qmake
make`
Запускаем, смотрим. Строка меню, toolbar, и плейлисты с вкладками. Согласитесь, ничего лишнего. Интерфейс русифицирован.
###### Обзор
Toolbar, в отличии от предыдущего, уже содержит в себе регулятор громкости. Все элементы ( кнопки воспроизведения, регулятор громкости, ползунок прокрутки ) перемещаемые. Можно настроить как душа пожелает.
Объеденить плейлисты в вкладки, я считаю, было отличным решением. Плейлист отображает песни списком. Неудобно, но клавиши *Ctrl + A* и *Del* не поддерживаются. Это делается из пункта меню *Правка*.
Поддерживается drag'n'drop с файловых менеджеров.
Песни без тегов отображаются прочерками.
Все операции с плейлистом осуществляются из пунктов меню *Файл* и *Правка*.
.
Также, из пункта *Файл* можно выбрать настройки программы. Настройки, как и в предыдущем случае, мало чем отличаются от стандартных.
.
Из остальных пунктов меню можно поставить *Всегда сверху* и вызвать настройки эквалайзера, которые появятся в новом окне.
###### Выводы
Еще более легкий и простой интерфейс. Наличие регулятора громкости, объединение плейлистов в вкладки можно считать преимуществами перед qsmmp. Но есть и недостатки: нет поддержки клавиш *Выделить все (Ctrl + A)* и *Удалить (Del)*, нет встроенного файлового менеджера.
#### Общие выводы
Как видите, эти интерфейсы могут быть вполне пригодными для использования, хотя они и несовершенны. Но работа над ними идет, и в ближайшем времени вы сможете насладится новыми плюшками. Хочу сказать, что все вышесказанное — это чисто мое мнение, которое может не совпадать с вашим. Выбор за вами!
P.S. Скриншоты получились немного размытые. Не знаю, из-за чего такой эффект. Извините. | https://habr.com/ru/post/96108/ | null | ru | null |
# Ещё раз о том, как не надо делать розыгрыши призов
Ещё недавно отгремели скандалы про [МТС и Nestea](http://www.siliconrus.com/2013/12/mts-vs-nestea/) и [Ebay и Biglion](http://habrahabr.ru/company/boxowerview/blog/201308/), а разработчики всё не учатся на чужих ошибках. На этот раз у нас отличилась компания FRIMA с их сухими сливками.
Сегодня вечером, я открыл пачку сливок, и заметил там маленький круглешок с кодом. Вообще в подобных мероприятиях я обычно не участвую, но мой взгляд привлекла маленькая мелочь, а именно: «код выигрыша» выглядел подобным образом: FRIMA1234123. Как заметили многие читатели, код состоит по сути из семи десятичных цифр, то есть всего у нас 10 000 000 комбинаций.
Первое же, что мне пришло в голову — это залезть на сайт для ввода кода — [frima.biz/lottery](http://frima.biz/lottery), где обнаружилось, что для проверки кода не используется никакая капча. Беглый осмотр проходящего AJAX-запроса для проверки показал, что в ответ приходит JSON-объект, в котором есть поле code, которое равно 0 если код существует.
Следом за этим я открыл консоль браузера, и накидал следующий код:
```
t = [];
i = 1111111;
q = function() {
jQuery.post('/lottery?task=ajax&action=checkTicketNumber',
{ spoof_id: 1, frmname: '', frmemail: '', 'extra_field[1]': '', 'extra_field[2]': '', ticket_number: 'FRIMA'+i },
function(res) {
if(JSON.parse(res).code == 0) {
t.push(i);
};
if(i < 1112222) { // не будем же мы ждать все 10 000 000 запросов
i += 1;
q();
}
});
};
q();
```
После этого мы можем в любой момент получить накопившийся список кодов, сделав
```
console.log(t);
```
Из кода несложно догадаться, что мы просто проверяем прямым перебором все возможные коды начиная с 1111111. Получив за минуту с десяток кодов, я удовлетворил своё эго и решил написать сюда.
В качестве итога я с осуждением смотрю на компанию TopWebDesign, которая с гордостью подписалась в футере рассмотренного сайта как разработчик этой халтуры. | https://habr.com/ru/post/212373/ | null | ru | null |
# Компиляция iOS приложений для Windows Store
В апреле этого года на конференции //Build был сделан очень интересный анонс, который показал возможность [компиляции и сборки ObjectiveC](https://channel9.msdn.com/Events/Build/2015/3-610) кода для Windows Store. С радостью хочу сообщить что теперь эта технология и инструменты стали публичными, вы можете уже сейчас [загрузить](https://github.com/Microsoft/WinObjC) компоненты сборки ObjC/iOS приложений для Visual Studio 2015 и собрать приложение для Windows Store.
#### C чего начать
По адресу <https://github.com/Microsoft/WinObjC/releases> опубликован SDK который содержит компоненты для сборки приложения iOS для Windows Store. Для того чтобы попробовать их в деле вам понадобится Windows 10 и [Visual Studio Community 2015](https://www.visualstudio.com/ru-ru/downloads/download-visual-studio-vs.aspx). Распакуйте содержимое winobjc.zip и откройте файл samples\HelloUI\HelloUI-WinStore10.sln. Далее делаем активным проект Hello-UI-Winstore (в Solution Explorer вызвать контекстное меню, «Set as StartUP Project») и нажимаем F5.
#### Добро пожаловать в мир кросс-компиляции ObjectiveC для Windows.
Пакет, который подготовила команда Microsoft содержит компилятор ObjectiveC, компоненты интеграции с Visual Studio 2015, основные части SDK iOS и дополнительные инструменты конвертации приложений.
C основными возможностями SDK вы можете ознакомиться из примера samples\WOCCatalog\WOCCatalog-WinStore10.sln.
В этом примере показаны основные варианты использования интерфейсных компонент:
Взаимодействие с OpenGL:
Кстати говоря, этот SDK также может собирать приложения для Windows 8.1 и Windows Phone 8.1.
Несколько необычно видеть стандартные интерфейсные элементы iOS на Windows Phone.
#### Конвертация проектов iOS
Для того чтобы превратить проект iOS в проект Visual Studio можно воспользоваться специальной утилитой **\****bin****\vsimporter.exe**.
Например, сделаем git clone <https://github.com/ericjohnson/canabalt-ios.git> и запустим в каталоге исходного кода этого проекта vsimporter. В результате у вас появится файл Canabalt-WinStore10.sln, открываем его в Visual Studio 2015 и собираем проект:
Почему-то он работает повернутый на 90 градусов.
Или например:
```
git clone https://github.com/haqu/tweejump.git
cd tweejump
winobjc_sdk_path\bin\vsimporter.exe
```
Результат компиляции для Windows 10:
#### Что пока в активной разработке?
Проект WinobjC находится в активной разработке и некоторые возможности не работают:
1. Нет поддержки ARM, только x86.
2. Оптимизации компилятора не работают. Скорее всего они приведут к крашу clang, пока можно использовать только debug сборки.
3. Autolayout
4. Storyboard support
5. MapKit
6. AssetsLibrary
7. AddressBook
8. Ads
9. Objective-C annotations
10. Media Capture
Если у вас есть вопросы и вы хотели бы узнать больше об этом проекте, обращайтесь на форумы <http://stackoverflow.com/>, маркируйте свои вопросы тегом **WinObjC** и почитайте вики <https://github.com/Microsoft/WinObjC/wiki>. | https://habr.com/ru/post/264321/ | null | ru | null |
# Вконтакте представили SDK для Android
 #### На днях ВКонтакте в разделе для разработчиков выложили SDK для Android.
Популярная социальная сеть ВКонтакте пополнила свой набор инструментариев для разработки приложений, в котором уже имеются Flash и Javascript SDK, а также SDK для iOS, еще одним — SDK для Android.
Эта библиотека включает в себя инструменты для авторизации, как при наличии на девайсе пользователя официального клиента, так и при его отсутствии, а также инструменты для облегчения составления/выполнения запросов и обработки ответов.
Не забыли ребята и о владельцах девайсов с неактуальными версиями Android на борту — тестовое приложение, поставляемое вместе с SDK, имеет требования Android 2.2+
Также не оставлен без внимания вопрос защиты.
Подробности под катом.
##### Где взять?
VK Android SDK доступен для скачивания на [GitHub](https://github.com/VKCOM/vk-android-sdk).
##### Как подключить?
###### SDK к проекту
В Eclipse, которым, к слову, я пользуюсь, а также в Android Studio, с использованием сборщика Gradle, VK SDK подключается также, как и любая другая библиотека, поэтому не стану на этом останавливаться. Скажу только, что для удобства я изменил структуру папок:
 => 
Если же вы не используете Gradle в Android Studio, то следует переименовать подключаемый модуль из «main» в «vksdk».
В манифесте необходимо прописать activity com.vk.sdk.VKOpenAuthActivity.
###### Проект к ВКонтакте
 Разработчики создали систему безопасности, благодаря которой другое приложение не сможет выдать себя за ваше.
* Во-первых, после создания standalone-приложения, в его настройках вы должны указать название пакета.
* Во-вторых, вы должны указать в настройках имя главной activity вашего приложения.
* В-третьих (это самое главное), вы должны указать отпечаток ключа вашего приложения, предварительно удалив двоеточия. Можно несколько, например, debug и release. Утилита keytool выдала мне три отпечатка — MD5, SHA1 и SHA256. ВКонтакт интересует SHA1.
##### Как использовать?
###### Авторизация
При запуске приложения нужно инициализировать SDK:
`VKSdk.initialize(VKSdkListener listener, String appId, VKAccessToken token);`
Авторизацию рекомендуется производить одним из следующих способов:
`VKSdk.authorize(String... scope);`
`VKSdk.authorize(String[] scope, boolean revoke, boolean forceOAuth);`
По умолчанию авторизация происходит через вконтакте клиент. Если оный на девайсе пользователя не установлен или forceOAuth == true, то страница авторизации открывается в отдельной activity.
Поскольку библиотека включает элементы интерфейса, то ей необходимо отслеживать происходящее на дисплее. Для этого используется класс VKUIHelper. Поэтому во всех activity нужно переопределить методы примерно так:
```
@Override
protected void onResume() {
super.onResume();
VKUIHelper.onResume(this);
}
@Override
protected void onDestroy() {
super.onDestroy();
VKUIHelper.onDestroy(this);
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
VKUIHelper.onActivityResult(requestCode, resultCode, data);
}
```
Пример activity:
```
public class LoginActivity extends Activity {
private static String sTokenKey = "VK_ACCESS_TOKEN";
private static String[] sMyScope = new String[]{VKScope.FRIENDS, VKScope.WALL, VKScope.PHOTOS, VKScope.NOHTTPS};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
VKSdk.initialize(sdkListener, "id_приложения", VKAccessToken.tokenFromSharedPreferences(this, sTokenKey));
setContentView(R.layout.activity_login);
VKSdk.authorize(sMyScope, true, false);
}
@Override
protected void onResume() {
super.onResume();
VKUIHelper.onResume(this);
}
@Override
protected void onDestroy() {
super.onDestroy();
VKUIHelper.onDestroy(this);
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
VKUIHelper.onActivityResult(requestCode, resultCode, data);
}
private VKSdkListener sdkListener = new VKSdkListener() {
@Override
public void onCaptchaError(VKError captchaError) {
new VKCaptchaDialog(captchaError).show();
}
@Override
public void onTokenExpired(VKAccessToken expiredToken) {
VKSdk.authorize(sMyScope);
}
@Override
public void onAccessDenied(VKError authorizationError) {
new AlertDialog.Builder(LoginActivity.this)
.setMessage(authorizationError.errorMessage)
.show();
}
@Override
public void onReceiveNewToken(VKAccessToken newToken) {
newToken.saveTokenToSharedPreferences(LoginActivity.this, sTokenKey);
Intent i = new Intent(LoginActivity.this, MainActivity.class);
startActivity(i);
}
@Override
public void onAcceptUserToken(VKAccessToken token) {
Intent i = new Intent(LoginActivity.this, MainActivity.class);
startActivity(i);
}
};
}
```
###### Выполнение запросов
Можно составить запрос, используя имеющуюся в SDK модель:
`VKRequest request = VKApi.users().get();`
Или непосредственно указать имя вызываемого метода:
`VKRequest request = new VKRequest("status.get");`
То же самое с параметрами:
`VKRequest request = VKApi.users().get(VKParameters.from(VKApiConst.USER_IDS, "1,2"));`
`VKRequest request = new VKRequest("friends.get", VKParameters.from(VKApiConst.FIELDS, "sex,bdate,city"));`
Для загрузки фотографий предусмотрены специальные типы запроса — VKUploadAlbumPhotoRequest для загрузки в альбом и VKUploadWallPhotoRequest для загрузки на стену. Оба имеют по два конструктора:
```
VKRequest request = VKApi.uploadWallPhotoRequest(VKUploadImage image, int user_id, int group_id);
VKRequest request = VKApi.uploadAlbumPhotoRequest(VKUploadImage image, int album_id, int group_id);
VKRequest request = VKApi.uploadWallPhotoRequest(File image, int user_id, int group_id);
VKRequest request = VKApi.uploadAlbumPhotoRequest(File image, int album_id, int group_id);
```
При загрузке фото на свою стену или стену группы user\_id == 0, иначе — id пользователя, на стену которого будем ~~гадить~~ загружать фото.
При загрузке фото на стену/в альбом группы group\_id == id целевой группы, иначе group\_id == 0 (например, загрузка фото в свой альбом).
В album\_id, соответственно, идентификатор фотоальбома.
Что касается объекта VKUploadImage, то в его конструктор необходимо передать изображение в виде объекта Bitmap и объект VKImageParameters, представляющий тип изображения (png, jpg) и значение quality (для jpg).
Аналоги для аудиозаписей, видеозаписей и документов пока не реализованы, но я не вижу проблем с тем, чтобы сделать это самостоятельно. :-)
Перед выполнением запроса можно изменить некоторые его параметры:
```
// Количество попыток выполение запроса. В случае успешного результата или API Error оставшиеся попытки сбрасываются.
// Дефолтное значение: 1. Значение 0 соответствует infinity.
request.attempts = 0;
// Использование защищенного соединения (HTTPS).
// Значение false можно использовать только при наличии соответствующего scope (nohttps).
// Дефолтное значение: true.
request.secure = false;
// Язык интерфейса вконтакте (при авторизации).
// Если установлено значение false или системный язык не поддерживается - будет использован английский язык.
// Дефолтное значение: true.
useSystemLanguage = false;
// Значение false отключает автоматический парсинг ответа сервера с использованием модели, имеющейся в SDK.
// Дефолтное значение: true.
request.parseModel = false;
```
Выполняется запрос методом `request.executeWithListener(VKRequestListener listener);`
Ответ сервера (VKResponse) приходит в listener.
Пример оправки запроса:
```
request.executeWithListener(new VKRequestListener() {
@Override
public void onComplete(VKResponse response) {
// Здесь обрабатываем полученный response.
}
@Override
public void onError(VKError error) {
// Ошибка. Сообщаем пользователю об error.
}
@Override
public void attemptFailed(VKRequest request, int attemptNumber, int totalAttempts) {
// Неудачная попытка. В аргументах имеется номер попытки и общее их количество.
}
});
```
Можно выполнить несколько запросов одним пакетом. Для этого создаем, так сказать, мультизапрос:
`VKBatchRequest batch_req = new VKBatchRequest(VKRequest... requests);`
Как видите, в одном пакете может быть любое количество запросов.
Выполняется мультизапрос также, как и единичный, только с другим слушателем:
```
batch_req.executeWithListener(new VKBatchRequestListener() {
@Override
public void onComplete(VKResponse[] responses) {
// Здесь обрабатываем responses (они в том же порядке, в котором были указаны запросы)
}
@Override
public void onError(VKError error) {
// Ошибка. Сообщаем пользователю об error.
}
});
```
###### Обработка ответов
Если в ответе ожидается объект, Java-представления которого пока нет в модели SDK, имеет смысл установить `parseModel = false;` и самостоятельно обрабатывать полученный JSON. Иначе достаточно привести полученный объект к необходимому типу.
##### Заключение
SDK Вконтакте для Android — довольно удобный и элегантный инструмент. Однако, конечно, ещё сырой. Файл-менеджмент пока представляет собой только загрузку фото. Аудио-, видеозаписи и документы пока в пролёте. Модель пока включает только Java-представления пользователя и фотографии. Однако уже имеются средства обработки капчи и ошибки валидации.
Библиотеке есть куда развиваться — а это значит, что можно в этом поучаствовать и вписаться в историю ВКонтакте.
Официальную документацию по SDK для Android можно почитать [здесь](http://vk.com/dev/android_sdk).
Спасибо за внимание. | https://habr.com/ru/post/209974/ | null | ru | null |
# Vespa лучше Elasticsearch для поиска пар среди миллионов мужчин и женщин
Неотъемлемой частью сайта для знакомств OkCupid являются рекомендации потенциальных партнёров. Они основаны на совпадении множества предпочтений, которые указали вы и ваши потенциальные партнёры. Как вы можете себе представить, существует множество вариантов оптимизации этой задачи.
Однако ваши предпочтения — не единственный фактор, влияющий на то, кого мы вам рекомендуем в качестве потенциального партнёра (или рекомендуем вас самого в качестве потенциального партнёра для других). Если бы мы просто показали всех пользователей, которые соответствуют вашим критериям, без какого-либо ранжирования, то список был бы совсем неоптимальным. Например, если не учитывать недавнюю активность пользователя, то вы можете потратить намного больше времени на общение с человеком, который не заходит на сайт. Кроме указанных вами предпочтений, мы используем многочисленные алгоритмы и факторы, чтобы рекомендовать вам тех людей, которых, по нашему мнению, вы должны увидеть.
Мы должны выдавать наилучшие результаты и практически бесконечный список рекомендаций. В других приложениях, где контент меняется не так часто, это можно сделать периодически обновляя рекомендации. Например, при использовании функции Spotify “Discover Weekly” вы наслаждаетесь набором рекомендуемых треков, этот набор не меняется до следующей недели. На OkCupid пользователи бесконечно просматривают свои рекомендации в режиме реального времени. Рекомендуемый «контент» очень динамичен по своей природе (например, пользователь может изменить свои предпочтения, данные профиля, местоположение, деактивироваться в любое время и т. д.). Пользователь может изменить, кому и как его можно рекомендовать, поэтому мы хотим убедиться, что потенциальные совпадения — лучшие на данный момент времени.
Чтобы воспользоваться различными алгоритмами ранжирования и подавать рекомендации в режиме реального времени, необходимо использовать поисковую систему, которая постоянно обновляется с пользовательскими данными и предоставляет возможность фильтровать и ранжировать потенциальных кандидатов.
Какие проблемы у существующей системы поиска совпадений
=======================================================
OkCupid уже много лет использует собственную внутреннюю систему поиска совпадений. Не будем вдаваться в детали, но на высоком уровне абстракции она представляет собой фреймворк map-reduce над шардами пользовательского пространства, где каждый шард содержит в памяти некоторую часть релевантных пользовательских данных, которые используются при включении различных фильтров и сортировок на лету. Поисковые запросы расходятся на все шарды, и в конечном счете результаты объединяются, чтобы вернуть k лучших кандидатов. Эта написанная нами система поиска пар работала хорошо, так почему сейчас мы решили изменить её?
Мы знали, что нужно обновить систему для поддержки в ближайшие годы различных проектов, основанных на рекомендациях. Мы знали, что наша команда будет расти, и количество проектов тоже. Одна из самых больших проблем заключалась в обновлении схемы. Например, добавление нового фрагмента данных о пользователе (скажем, гендерных тегов в предпочтениях) требовало сотен или тысяч строк кода в шаблонах, а развёртывание требовало тщательной координации, чтобы все части системы развёртывались в правильном порядке. Простая попытка добавить новый способ фильтрации пользовательского набора данных или ранжирования результатов требовала полдня времени инженера. Он должен был вручную развернуть каждый сегмент в продакшне и следить за возможными проблемами. Что ещё более важно, стало трудно управлять и масштабировать систему, поскольку шарды и реплики вручную распределялись по парку машин, на которых не было установлено никакого программного обеспечения.
В начале 2019 года возросла нагрузка на систему поиска пар, поэтому мы добавили ещё один набор реплик, вручную разместив экземпляры службы на нескольких машинах. Работа заняла много недель на бэкэнде и для девопсов. В это время мы также начали замечать узкие места производительности во встроенной системе обнаружения служб, очереди сообщений и т. д. В то время как эти компоненты ранее хорошо работали, мы достигли той точки, на которой стали сомневаться в возможности этих систем масштабироваться. У нас была задача переместить большую часть нашей рабочей нагрузки в облачную среду. Перенос этой системы поиска пар сам по себе является трудоёмкой задачей, но также задействует и другие подсистемы.
Сегодня в OkCupid многие из этих подсистем обслуживаются более надёжными и дружественными к облакам опциями OSS, и команда за последние два года с большим успехом внедрила различные технологии. Не будем здесь рассказывать об этих проектах, а вместо этого сосредоточимся на действиях, которые мы предприняли для решения вышеуказанных проблем, перейдя к более удобной для разработчиков и масштабируемой поисковой системе для наших рекомендаций: [Vespa](https://vespa.ai/).
Это совпадение! Почему OkCupid подружился с Vespa
=================================================
Исторически наша команда была небольшой. Мы с самого начала поняли, что выбрать ядро поисковой системы будет чрезвычайно сложно, поэтому рассмотрели варианты с открытым исходным кодом, которые нам подходили. Двумя главными претендентами были Elasticsearch и Vespa.
### Elasticsearch
Это популярная технология с большим сообществом, хорошей документацией и поддержкой. Есть множество функций, и она даже используется в [Tinder](https://medium.com/tinder-engineering/tagged/elasticsearch). Можно добавлять новые поля схемы с помощью PUT-мэппинга, запросы можно выполнять с помощью структурированных вызовов REST, есть некоторая поддержка ранжирования по времени запросов, возможность писать пользовательские плагины и т. д. Когда дело доходит до масштабирования и обслуживания, нужно только определить количество шардов, и система сама обрабатывает распределение реплик. Масштабирование требует перестройки другого индекса с бóльшим количеством шардов.
Одной из главных причин, по которой мы отказались от Elasticsearch, было отсутствие истинных частичных обновлений в памяти. Это очень важно для нашего варианта использования, потому что документы, которые мы собираемся индексировать, должны очень часто обновляться из-за лайков, обмена сообщениями и т. д. Эти документы очень динамичны по своей природе, по сравнению с контентом, таким как реклама или картинки, которые в основном являются статическими объектами с постоянными атрибутами. Поэтому неэффективные циклы чтения-записи при обновлении были главной проблемой производительности для нас.
### Vespa
Исходные коды открыты всего несколько лет назад. Разработчики [заявили](https://vespa.ai/#featurematrix) поддержку хранения, поиска, ранжирования и организации Big Data в реальном времени. Функции, которые поддерживает Vespa:
* высокая производительность выдачи благодаря реальным частичным обновлениям в памяти без необходимости переиндексировать весь документ (как [сообщается](https://developer.yahoo.com/blogs/189367412801/?guccounter=1&guce_referrer=aHR0cHM6Ly93d3cuZ29vZ2xlLmNvbS8&guce_referrer_sig=AQAAAIbKmtALASgbGmhsxKRRrCvJX9J52P3pd_52NaFyQXU5cQBtCXzTgqr8_ra1RgoIs10Ja-RIsDeDEImyYLz1ExKEG5nWJZJAOrwG2h9y7W2mK6td5Lt1Tmdh_LTd_CUzgRlgmDrplgD3uCwpJDiF3JtFI1Mkn7VWOde8OCU7QiuE), до 40-50 тыс. обновлений в секунду на узел)
* обеспечивает гибкую структуру ранжирования, позволяющую обрабатывать данные во время запроса
* непосредственно поддерживает в ранжировании интеграцию с моделями машинного обучения (например, TensorFlow)
* запросы можно выполнять с помощью выразительного YQL (Yahoo Query Language) в вызовах REST
* возможность настройки логики с помощью Java-компонентов
Когда дело доходит до масштабирования и обслуживания, вы больше не думаете о *шардах* — вы настраиваете макет для узлов с контентом, и Vespa автоматически обрабатывает, как распределить документы на шарды, делает репликацию и распределение данных. Кроме того, данные автоматически восстанавливаются и перераспределяются из реплик всякий раз, когда вы добавляете или удаляете узлы. Масштабирование означает просто обновление конфигурации для добавления узлов и позволяет Vespa автоматически перераспределять эти данные в реальном времени.
В целом Vespa, видимо, лучше всего подходила для наших вариантов использования. OkCupid включает в себя множество различной информации о пользователях, чтобы помочь им найти лучшие пары — с точки зрения просто фильтров и сортировок там более сотни параметров! Мы всегда будем добавлять фильтры и сортировки, поэтому очень важно поддерживать этот рабочий процесс. Что касается записей и запросов, Vespa больше всего похожа на нашу существующую систему; то есть наша система также требовала обработки быстрых частичных обновлений в памяти и обработки в реальном времени во время запроса на поиск совпадений. У Vespa также гораздо более гибкая и простая структура ранжирования. Ещё одним приятным бонусом стала возможность выражать запросы в YQL, в отличие от неудобной структуры для запросов в Elasticsearch. Что касается масштабирования и обслуживания, то возможности автоматического распределения данных в Vespa оказались очень привлекательны для нашей относительно небольшой команды. В целом выяснилось, что Vespa лучшие поддерживает наши варианты использования и требования к производительности, будучи при этом проще в обслуживании по сравнению с Elasticsearch.
Elasticsearch — более известный движок, и мы могли бы воспользоваться опытом его использования в Tinder, но любой вариант потребует тонны предварительных исследований. В то же время Vespa обслуживает множество систем в продакшне, таких как [Zedge](https://developer.yahoo.com/blogs/177690706666/), Flickr с миллиардами картинок, рекламная платформа [Yahoo Gemini Ads](https://gemini.yahoo.com/advertiser/home) с более чем ста тысячами запросов в секунду для выдачи рекламы миллиарду активных пользователей в месяц. Это дало нам уверенность в том, что это проверенный в боях, эффективный и надёжный вариант — на самом деле Vespa [появилась даже раньше](https://dbdb.io/db/vespa), чем Elasticsearch.
Кроме того, разработчики Vespa оказались очень общительными и полезными. Vespa изначально создана для рекламы и контента. Насколько нам известно, она ещё не использовалась на сайтах знакомств. Поначалу было трудно интегрировать движок, потому что у нас был уникальный вариант использования, но команда Vespa оказалась очень отзывчивой и быстро оптимизировала систему, чтобы помочь нам справиться с несколькими возникшими проблемами.
Как работает Vespa и как выглядит поиск в OkCupid
=================================================
Прежде чем погрузиться в наш пример использования Vespa, вот краткий обзор того, как она работает. Vespa — это набор многочисленных служб, но каждый контейнер Docker можно сконфигурировать на роль узла admin/config, узла контейнера Java, не зависящего от состояния (stateless) и/или узла контента C++, зависящего от состояния (stateful). Пакет приложения с конфигурацией, компонентами, моделью ML и т. д. может быть развернут через [State API](https://docs.vespa.ai/documentation/content/api-state-rest-api.html) в конфигурационном кластере, который обрабатывает применение изменений к контейнеру и кластеру содержимого. Запросы фида и остальные запросы проходят через stateless-контейнер Java (который позволяет настроить обработку) по HTTP, прежде чем обновления фида поступают в кластер контента или запросы разветвляются на уровень контента, где происходит распределённое выполнение запросов. По большей части развёртывание нового пакета приложений занимает всего несколько секунд, и Vespa обрабатывает эти изменения в реальном времени в контейнере и кластере контента, так что вам редко приходится что-либо перезапускать.
### Как выглядит поиск?
Документы в кластере Vespa содержат множество атрибутов, относящихся к данному пользователю. **Определение схемы** определяет поля типа документа, а также **профили ранжирования**, содержащие набор применимых выражений ранжирования. Предположим, у нас есть **определение схемы**, представляющее пользователя следующим образом:
```
search user {
document user {
field userId type long {
indexing: summary | attribute
attribute: fast-search
rank: filter
}
field latLong type position {
indexing: attribute
}
# UNIX timestamp
field lastOnline type long {
indexing: attribute
attribute: fast-search
}
# Contains the users that this user document has liked
# and the corresponding weights are UNIX timestamps when that like happened
field likedUserSet type weightedset {
indexing: attribute
attribute: fast-search
}
}
rank-profile myRankProfile inherits default {
rank-properties {
query(lastOnlineWeight): 0
query(incomingLikeWeight): 0
}
function lastOnlineScore() {
expression: query(lastOnlineWeight) \* freshness(lastOnline)
}
function incomingLikeTimestamp() {
expression: rawScore(likedUserSet)
}
function hasLikedMe() {
expression: if (incomingLikeTimestamp > 0, 1, 0)
}
function incomingLikeScore() {
expression: query(incomingLikeWeight) \* hasLikedMe
}
first-phase {
expression {
lastOnlineScore + incomingLikeScore
}
}
summary-features {
lastOnlineScore incomingLikeScore
}
}
}
```
Обозначение `indexing: attribute` указывает на то, что эти поля должны храниться в памяти, чтобы обеспечить наилучшую производительность записи и чтения этих полей.
Предположим, мы заполнили кластер такими пользовательскими документами. Затем мы могли бы выполнить фильтрацию и ранжирование по любому из вышеперечисленных полей. Например, сделать POST-запрос к обработчику поиска по умолчанию `http://localhost:8080/search/`, чтобы найти пользователей, за исключением нашего собственного пользователя `777`, в пределах 50 миль от нашего местоположения, которые были онлайн с момента отметки времени `1592486978`, с ранжированием по последней активности и сохраняя двух лучших кандидатов. Давайте также выберем **summaryfeatures**, чтобы увидеть вклад каждого выражения ранжирования в нашем профиле ранжирования:
```
{
"yql": "select userId, summaryfeatures from user where lastOnline > 1592486978 and !(userId contains \"777\") limit 2;",
"ranking": {
"profile": "myRankProfile",
"features": {
"query(lastOnlineWeight)": "50"
}
},
"pos": {
"radius": "50mi",
"ll": "N40o44'22;W74o0'2",
"attribute": "latLong"
},
"presentation": {
"summary": "default"
}
}
```
Мы могли бы получить такой результат:
```
{
"root": {
"id": "toplevel",
"relevance": 1.0,
"fields": {
"totalCount": 317
},
"coverage": {
"coverage": 100,
"documents": 958,
"full": true,
"nodes": 1,
"results": 1,
"resultsFull": 1
},
"children": [
{
"id": "index:user/0/bde9bd654f1d5ae17fd9abc3",
"relevance": 48.99315843621399,
"source": "user",
"fields": {
"userId": -5800469520557156329,
"summaryfeatures": {
"rankingExpression(incomingLikeScore)": 0.0,
"rankingExpression(lastOnlineScore)": 48.99315843621399,
"vespa.summaryFeatures.cached": 0.0
}
}
},
{
"id": "index:user/0/e8aa37df0832905c3fa1dbbd",
"relevance": 48.99041280864198,
"source": "user",
"fields": {
"userId": 6888497210242094612,
"summaryfeatures": {
"rankingExpression(incomingLikeScore)": 0.0,
"rankingExpression(lastOnlineScore)": 48.99041280864198,
"vespa.summaryFeatures.cached": 0.0
}
}
}
]
}
}
```
После фильтрации по совпадающим попаданиям вычисляются выражения ранжирования **первой фазы** (first-phase) для ранжирования попаданий. Возвращаемая релевантность (relevance) — это общая оценка как результат выполнения всех функций ранжирования первой фазы в **профиле ранжирования** (rank-profile), который мы указали в нашем запросе, то есть `ranking.profile` `myRankProfile`. В списке `ranking.features` мы определили `query(lastOnlineWeight)` как 50, на неё затем ссылается единственное используемое нами выражение ранжирования `lastOnlineScore`. Оно использует встроенную [функцию ранжирования](https://docs.vespa.ai/documentation/reference/rank-features.html) `freshness`, которая представляет собой число, близкое к 1, если временная метка в атрибуте является недавней по сравнению с текущей временной меткой. Пока всё идет хорошо, здесь ничего сложного.
В отличие от статического контента, этот контент может влиять на то, показывать его пользователю или нет. Например, они могут вас лайкнуть! Мы могли бы индексировать [взвешенное поле](https://docs.vespa.ai/documentation/reference/schema-reference.html#type:weightedset) `likedUserSet` для каждого пользовательского документа, который содержит в качестве ключей идентификаторы пользователей, которых они лайкнули, и в качестве значений метку времени, когда подобное произошло. Тогда было бы просто отфильтровать тех, кто вас лайкнул (например, добавлениес выражения `likedUserSet contains \”777\”` в YQL), но как включить эту информацию во время ранжирования? Как повысить в результатах тогр пользователя, который лайкнул нашего человека?
В предыдущих результатах выражение ранжирования `incomingLikeScore` было равно 0 для обоих этих попаданий. Пользователь `6888497210242094612` на самом деле лайкнул пользователя `777`, но в настоящее время он недоступен в рейтинге, даже если бы мы поставили `"query(incomingLikeWeight)": 50`. Мы можем использовать функцию [rank](https://docs.vespa.ai/documentation/reference/query-language-reference.html#rank) в YQL (первый и только первый аргумент функции `rank()` определяет, является ли документ совпадением, но все аргументы используются для вычисления оценки ранжирования), а затем использовать [dotProduct](https://docs.vespa.ai/documentation/multivalue-query-operators.html#dotproduct-example) в нашем выражении ранжирования YQL для хранения и извлечения необработанных оценок (в данном случае метки времени, когда пользователь нас лайкнул), например, таким образом:
```
{
"yql": "select userId,summaryfeatures from user where !(userId contains \"777\") and rank(lastOnline > 1592486978, dotProduct(likedUserSet, {\"777\":1})) limit 2;",
"ranking": {
"profile": "myRankProfile",
"features": {
"query(lastOnlineWeight)": "50",
"query(incomingLikeWeight)": "50"
}
},
"pos": {
"radius": "50mi",
"ll": "N40o44'22;W74o0'2",
"attribute": "latLong"
},
"presentation": {
"summary": "default"
}
}
```
```
{
"root": {
"id": "toplevel",
"relevance": 1.0,
"fields": {
"totalCount": 317
},
"coverage": {
"coverage": 100,
"documents": 958,
"full": true,
"nodes": 1,
"results": 1,
"resultsFull": 1
},
"children": [
{
"id": "index:user/0/e8aa37df0832905c3fa1dbbd",
"relevance": 98.97595807613169,
"source": "user",
"fields": {
"userId": 6888497210242094612,
"summaryfeatures": {
"rankingExpression(incomingLikeScore)": 50.0,
"rankingExpression(lastOnlineScore)": 48.97595807613169,
"vespa.summaryFeatures.cached": 0.0
}
}
},
{
"id": "index:user/0/bde9bd654f1d5ae17fd9abc3",
"relevance": 48.9787037037037,
"source": "user",
"fields": {
"userId": -5800469520557156329,
"summaryfeatures": {
"rankingExpression(incomingLikeScore)": 0.0,
"rankingExpression(lastOnlineScore)": 48.9787037037037,
"vespa.summaryFeatures.cached": 0.0
}
}
}
]
}
}
```
Теперь пользователь `68888497210242094612` поднят наверх, так как он лайкнул нашего пользователя и его `incomingLikeScore` имеет полное значение. Конечно, у нас на самом деле есть метка времени, когда он лайкнул нас, чтобы мы могли использовать её в более сложных выражениях, но пока оставим всё в простом виде.
Это демонстрирует механику фильтрации и ранжирования результатов с помощью системы ранжирования. Структура ранжирования обеспечивает гибкий способ применения выражений (которые в основном являются просто математическими) к совпадениям во время запроса.
### Настройка промежуточного уровня middleware в Java
Что, если бы мы хотели пойти другим путём и сделать это выражение dotProduct неявно частью каждого запроса? Вот где появляется настраиваемый уровень контейнера Java — мы можем написать пользовательский компонент **[Searcher](https://docs.vespa.ai/documentation/searcher-development.html)**. Это позволяет обрабатывать произвольные параметры, переписывать запрос и обрабатывать результаты определённым образом. Вот пример на Kotlin:
```
@After(PhaseNames.TRANSFORMED_QUERY)
class MatchSearcher : Searcher() {
companion object {
// HTTP query parameter
val USERID_QUERY_PARAM = "userid"
val ATTRIBUTE_FIELD_LIKED_USER_SET = “likedUserSet”
}
override fun search(query: Query, execution: Execution): Result {
val userId = query.properties().getString(USERID_QUERY_PARAM)?.toLong()
// Add the dotProduct clause
If (userId != null) {
val rankItem = query.model.queryTree.getRankItem()
val likedUserSetClause = DotProductItem(ATTRIBUTE_FIELD_LIKED_USER_SET)
likedUserSetClause.addToken(userId, 1)
rankItem.addItem(likedUserSetClause)
}
// Execute the query
query.trace("YQL after is: ${query.yqlRepresentation()}", 2)
return execution.search(query)
}
}
```
Потом в нашем файле **services.xml** мы можем настроить этот компонент следующим образом:
```
...
http://\*:8080/match
...
```
Затем мы просто создаём и развёртываем пакет приложения и делаем запрос к пользовательскому обработчику `http://localhost:8080/match-что?userid=777`:
```
{
"yql": "select userId,summaryfeatures from user where !(userId contains \"777\") and rank(lastOnline > 1592486978) limit 2;",
"ranking": {
"profile": "myRankProfile",
"features": {
"query(lastOnlineWeight)": "50",
"query(incomingLikeWeight)": "50"
}
},
"pos": {
"radius": "50mi",
"ll": "N40o44'22;W74o0'2",
"attribute": "latLong"
},
"presentation": {
"summary": "default"
}
}
```
Мы получаем те же результаты, что и раньше! Обратите внимание, что в коде Kotlin мы добавили трассировку для выдачи представления YQL после изменения, поэтому, если установить `tracelevel=2` в параметрах URL, ответ также будет показан:
```
...
{
"message": "YQL after is: select userId, summaryfeatures from user where ((rank(lastOnline > 1592486978, dotProduct(likedUserSet, {\"777\": 1})) AND !(userId contains \"777\") limit 2;"
},
...
```
Контейнер промежуточного слоя Java является мощным средством, чтобы добавить пользовательскую логику обработки через **Searcher** или собственную генерацию результатов с помощью **Renderer**. Мы настраиваем наши компоненты **Searcher** для обработки случаев, подобных приведённым выше, и других аспектов, которые мы хотим сделать неявными в наших поисках. Например, одной из концепций продукта, которую мы поддерживаем, является идея «взаимной подгонки» — вы можете искать пользователей с определёнными критериями (например, возрастной диапазон и расстояние), но вы также должны соответствовать критериям поиска кандидатов. Чтобы поддержать такой вариант в нашем компоненте Searcher, мы могли бы извлечь документ пользователя, который выполняет поиск, чтобы предоставить некоторые из его атрибутов в последующем разветвлённом запросе для фильтрации и ранжирования. Структура ранжирования и кастомный промежуточный слой вместе обеспечивают гибкий способ поддержки многочисленных вариантов использования. В этих примерах мы рассмотрели только несколько аспектов, но [здесь](https://docs.vespa.ai/documentation/ranking.html) вы можете найти подробную документацию.
Как мы построили кластер Vespa и запустили его в продакшн
=========================================================
Весной 2019 года мы приступили к планированию новой системы. В это время мы также связались с командой Vespa и регулярно консультировались с ними по поводу наших вариантов использования. Наша оперативная группа оценила и построила первоначальную настройку кластера, а бэкенд-команда начала документировать, проектировать и прототипировать различные варианты использования Vespa.
### Первые этапы прототипирования
Системы бэкенда OkCupid написаны на Golang и C++. Чтобы написать кастомные логические компоненты Vespa, а также обеспечить высокую скорость подачи фида с помощью [Java Vespa HTTP feed client API](https://docs.vespa.ai/documentation/vespa-http-client.html), нам пришлось немного познакомиться со средой JVM — мы в конечном итоге использовали Kotlin при настройке компонентов Vespa и в наших конвейерах подачи.
Несколько лет занял портирование прикладной логики и раскрытие функций Vespa, консультации с командой Vespa по мере необходимости. Большая часть системной логики движка поиска соответствий написано в C++, поэтому мы также добавили логику для перевода нашей текущей модели данных фильтров и сортировок в эквивалентные запросы YQL, которые мы выдаем через REST кластеру Vespa. На раннем этапе мы также позаботились о создании хорошего конвейера для повторного заполнения кластера полной пользовательской базой документов; прототипирование должно включать в себя множество изменений для определения правильных типов полей для использования, а также непреднамеренно требует повторной подачи фида с документами.
### Мониторинг и нагрузочное тестирование
Когда мы создавали поисковый кластер Vespa, нужно было убедиться в двух вещах: что он может обрабатывать ожидаемый объём поисковых запросов и записей и что рекомендации, которые выдаёт система, сопоставимы по качеству с существующей системой поиска пар.
Перед нагрузочными тестами мы везде добавили метрики Prometheus. [Vespa-exporter](https://github.com/vespa-engine/vespa_exporter) предоставляет массу статистических данных, а сама Vespa также предоставляет небольшой набор дополнительных [метрик](https://docs.vespa.ai/documentation/reference/metrics.html). Исходя из этого, мы создали различные информационные панели Grafana по запросам в секунду, задержкам, использованию ресурсов процессами Vespa и т. д. Мы также запустили [vespa-fbench](https://docs.vespa.ai/documentation/performance/vespa-benchmarking.html) для тестирования производительности запросов. С помощью разработчиков Vespa мы определили, что из-за относительно высокой [стоимости статических запросов](https://docs.vespa.ai/documentation/performance/sizing-search.html) наш [сгруппированный готовый макет](https://docs.vespa.ai/documentation/performance/sizing-examples.html) обеспечит более скоростную выдачу. В плоском макете добавление большего количества узлов в основном только сокращает стоимость динамического запроса (то есть той части запроса, которая зависит от количества проиндексированных документов). Сгруппированный макет означает, что каждая настроенная группа узлов будет содержать полный набор документов, и поэтому одна группа может обслужить запрос. Из-за высокой стоимости статических запросов, сохраняя количество узлов одинаковым, мы значительно увеличили пропускную способность, увеличив количество с одной группы с плоской компоновкой до трёх. Наконец, мы также провели тестирование неучтённого «теневого трафика» в реальном времени, когда стали уверены в надёжности статических бенчмарков.
### Оптимизация производительности
Производительность выдачи стала одним из самых больших препятствий, с которым мы столкнулись на ранней стадии. В самом начале у нас появились проблемы с обработкой обновлений даже на 1000 QPS (запросов в секунду). Мы активно использовали поля из взвешенного множества (weighted set fields), но поначалу они не были эффективными. К счастью, разработчики Vespa быстро помогли решить эти проблемы, а также другие, связанные с распространением данных. Позже они также добавили обширную документацию по [калибровке фидов](https://docs.vespa.ai/documentation/performance/sizing-feeding.html), которую мы в какой-то степени используем: целочисленные поля в больших взвешенных множествах, когда это возможно, позволяют дозировать, устанавливая `visibility-delay`, используя несколько условных обновлений и полагаясь на поля атрибутов (то есть в памяти), а также сокращая количество пакетов туда-обратно от клиентов за счёт уплотнения и слияния операций в наших конвейерах фмдов. Теперь конвейеры спокойно обрабатывают 3000 QPS в устойчивом состоянии, и наш скромный кластер обрабатывает обновления на 11 тыс. QPS, когда такой всплеск возникает по какой-то причине.
### Качество рекомендаций
После того, как мы убедились, что кластер справляется с нагрузкой, нужно было проверить, что качество рекомендаций не хуже, чем в существующей системе. Любое незначительное отклонение в реализации рейтинга оказывает огромное влияние на общее качество рекомендаций и общую экосистему в целом. Мы применили [экспериментальную систему](https://tech.okcupid.com/the-pitfalls-of-a-b-testing-in-social-networks/) Vespa в некоторых тестовых группах, в то время как контрольная группа продолжала использовать существующую систему. Затем проанализировали несколько бизнес-показателей, повторяя и фиксируя проблемы до тех пор, пока результаты группы Vespa не оказались такими же хорошими, если не лучше, чем в контрольной группе. Как только мы были уверены в результатах Vespa, оставалось просто направить запросы на поиск совпадений в кластер Vespa. Мы смогли запустить весь поисковый трафик в кластер Vespa без сучка и задоринки!
### Схема системы
В упрощённом виде итоговая схема архитектуры новой системы выглядит так:
Как Vespa работает сейчас и что будет дальше
============================================
Давайте сравним состояние системы поиска пар Vespa, с прошлой системой:
* Обновления схемы
+ Раньше: неделя с сотнями новых строк кода, тщательно скоординированное развёртывание с несколькими подсистемами
+ Теперь: за пару часов добавляете простое поле в определение схемы и развёртываете пакет приложения
* Добавление новой сортировки/ранжирования
+ Раньше: полдня на развёртывание
+ Теперь: выражения ранжирования сами по себе являются обновлением определения схемы и могут быть развёрнуты в рабочей системе. Таким образом, их включение занимает всего несколько секунд!
* Масштабирование и поддержка
+ Раньше: многонедельные усилия по ручному распределению шардов и размещению файлов обслуживания продакшна, чтобы добиться высокой доступности
+ Теперь: просто добавляем новый узел в конфигурационный файл, и Vespa автоматически распределит данные для желаемых уровней избыточности. Основная часть операций не требует ручного вмешательства или перезапуска каких-либо узлов с отслеживанием состояния
В целом аспект разработки и технического обслуживания кластера Vespa помог развитию всех продуктов OkCupid. В конца января 2020 года мы запустили в продакшн наш кластер Vespa и он обслуживает все выдачи рекомендаций в поиске пар. Мы также добавили десятки новых полей, выражений ранжирования и вариантов использования с поддержкой всех новых функций в этом году, таких как [Stacks](https://help.okcupid.com/article/229-whats-new-july-2020). И в отличие от нашей предыдущей системы поиска пар, теперь мы используем модели машинного обучения в реальном времени во время запроса.
### Что дальше?
Для нас одним из главных преимуществ Vespa является прямая поддержка ранжирования с помощью тензоров и интеграция с моделями, обученными с помощью таких фреймворков, как [TensorFlow](https://docs.vespa.ai/documentation/tensorflow.html). Это одна из главных функций, которые мы будем развивать в ближайшие месяцы. Мы уже используем тензоры для некоторых вариантов использования, а в ближайшее время рассмотрим возможность интеграции разных моделей машинного обучения, которые, как мы надеемся, будут лучше предсказывать результаты и совпадения для наших пользователей.
Кроме того, Vespa недавно объявила о поддержке многомерных приближённых индексов ближайших соседей (nearest neighbor index), которые работают полностью в реальном времени, одновременно доступны для поиска и динамически обновляются. Нам очень интересно изучить другие варианты использования поиска с [индексом ближайших соседей](https://docs.vespa.ai/documentation/nearest-neighbor-search.html) в режиме реального времени.
OkCupid и Vespa. Поехали!
=========================
Многие слышали или работали с Elasticsearch, но вокруг Vespa нет такого большого сообщества. Мы считаем, что много других приложений на Elasticsearch лучше бы работали на Vespa. Она отлично подходит для OkCupid, и мы рады, что перешли на неё. Эта новая архитектура позволила нам гораздо быстрее развиваться и разрабатывать новые функции. Мы — относительно небольшая компания, так что это здорово — особо не беспокоиться о сложностях обслуживания. Теперь мы гораздо лучше готовы к горизонтальному масштабированию нашего поисковика. Без Vespa мы, конечно, не смогли бы добиться того прогресса, которого достигли за последний год. Для получения дополнительной информации о технических возможностях Vespa обязательно ознакомьтесь с [рекомендациями по Vespa AI в электронной коммерции](https://medium.com/vespa/e-commerce-search-and-recommendation-with-vespa-ai-a49c98f97e68) от [@jobergum](https://github.com/jobergum).
Мы сделали первый шаг и лайкнули разработчиков Vespa. Они послали нам ответное сообщение, и это оказалось совпадение! Мы не смогли бы сделать это без помощи команды Vespa. Особая благодарность [@jobergum](https://github.com/jobergum) и [@geirst](https://github.com/geirst) за рекомендации по ранжированию и обработке запросов, а также [@kkraune](https://github.com/kkraune) и [@vekterli](https://github.com/vekterli) за их поддержку. Уровень поддержки и усилий, которые оказала нам команда Vespa, был поистине потрясающим — от глубокого изучения нашего варианта использования до диагностики проблем производительности и мгновенного внесения улучшений в движок Vespa. Товарищ [@vekterli](https://github.com/vekterli) даже прилетел в наш офис в Нью-Йорке и в течение недели работал непосредственно с нами, чтобы помочь в интеграции движка. Большое спасибо команде Vespa!
В заключение скажем, что мы затронули лишь несколько аспектов использования Vespa, но всё это было бы невозможно без огромной работы наших бэкенд- и операционных групп в течение последнего года. Мы столкнулись с большим количеством уникальных проблем, чтобы преодолеть разрыв между существующими системами и более современным технологическим стеком, но это уже темы для других статей. | https://habr.com/ru/post/521364/ | null | ru | null |
# Изучаем календарь
 Эта статья получилась из вопроса, который я сам себе задал вчера.
> «Существует ли год, в котором ни один месяц не начинается в понедельник?»
На первый взгляд — да. Год может начинаться с любого дня недели, месяцы тоже каждый раз начинаются в разные дни недели. Вариантов множество, скорее всего, найдётся и не один такой год.
Так я подумал в первую минуту после того, как задался вопросом. Это следовало бы доказать. Перебрать все года, например. Простой и быстрый способ, но не интересный. Доказать математически было намного более заманчивой идеей, но как к этому подступиться я совершенно не понимал. Поэтому просто начал выписывать продолжительность каждого месяца на бумагу.
Тут стоит оговорить, что речь дальше пойдёт про [григорианский календарь](https://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B8%D0%B3%D0%BE%D1%80%D0%B8%D0%B0%D0%BD%D1%81%D0%BA%D0%B8%D0%B9_%D0%BA%D0%B0%D0%BB%D0%B5%D0%BD%D0%B4%D0%B0%D1%80%D1%8C), по которому мы живём с 1918 года. Однако часть рассуждений будет верна и для [юлианского](https://ru.wikipedia.org/wiki/%D0%AE%D0%BB%D0%B8%D0%B0%D0%BD%D1%81%D0%BA%D0%B8%D0%B9_%D0%BA%D0%B0%D0%BB%D0%B5%D0%BD%D0%B4%D0%B0%D1%80%D1%8C).
На самом деле такого года не существует. Давайте разбираться почему.
Часть 1. Месяцы
---------------
Сначала вспомним, сколько дней в каждом месяце:
| | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Янв | Фев | Март | Апр | Май | Июнь | Июль | Авг | Сен | Окт | Нояб | Дек |
| 31 | 28 / 29 | 31 | 30 | 31 | 30 | 31 | 31 | 30 | 31 | 30 | 31 |
Теперь посмотрим, на сколько дней в каждом месяце больше, чем в четырёх неделях.
| | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Янв | Фев | Март | Апр | Май | Июнь | Июль | Авг | Сен | Окт | Нояб | Дек |
| 3 | 0 / 1 | 3 | 2 | 3 | 2 | 3 | 3 | 2 | 3 | 2 | 3 |
В этом месте возникает следующая идея. Если к дате прибавить 7 дней, то день недели не изменится. Работает модульная арифметика. Отсюда легко понять, что если дней в месяце на два больше, чем в четырёх неделях, то первое число следующего месяца сдвинется на два дня недели относительно первого числа текущего месяца. Да и вообще,
> если в месяце (28 + N) дней, то первое число следующего месяца сдвинется на N дней относительно дня недели первого числа текущего месяца.
Например, в этом году январь начался во вторник, поэтому февраль начался в пятницу. Вт + 3 = Пт.
Насколько же сдвинут день недели первого числа некоторого месяца? Чтобы найти это, надо просуммировать «излишки» дней над четырьмя неделями во всех предыдущих месяцах. В таблице представлены сдвиги относительно дня недели на первое января. Первая строка для невисокосного года, вторая для високосного.
| | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Янв | Фев | Март | Апр | Май | Июнь | Июль | Авг | Сен | Окт | Нояб | Дек |
| 0 | 3 | 3 | 6 | 8 | 11 | 13 | 16 | 19 | 21 | 24 | 26 |
| 0 | 3 | 4 | 7 | 9 | 12 | 14 | 17 | 20 | 22 | 25 | 27 |
Но это выглядит не очень показательно, да и мы знаем, что сдвиг на семь дней не меняет день недели. Поэтому запишем теперь в таблицу остатки от деления суммарных сдвигов на 7.
| | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Янв | Фев | Март | Апр | Май | Июнь | Июль | Авг | Сен | Окт | Нояб | Дек |
| 0 | 3 | 3 | 6 | 1 | 4 | 6 | 2 | 5 | 0 | 3 | 5 |
| 0 | 3 | 4 | 0 | 2 | 5 | 0 | 3 | 6 | 1 | 4 | 6 |
Вот теперь другое дело! Ясно видно, как определить день недели на первое число любого месяца, если известен день недели на первое января. Надо просто прибавить сдвиг для интересующего месяца. Закономерность февраль-март-ноябрь я знаю ещё со школы, а другие не замечал.
Мы получили ответ на вопрос в начале статьи.
> Так как для обоих вариантов года в таблице присутствуют все сдвиги от 0 до 6, то в любом году есть месяц, который начинается в какой-то определённый день недели.
Но теперь можно задавать другие вопросы. Например, «в каких годах такой месяц только один?» или «в какие года таких месяцев максимально много?». Для этого надо уметь определять день недели на первое января любого года.
Часть 2. Годы
-------------
Когда я учился программировать, а это было в 10 классе школы на PascalABC, одним из первых серьёзных заданий было реализовать процедуру, распечатывающую календарь на год, который передавался как аргумент. У нас были подсказки, какие функции для этого надо реализовать. В целом всё сводилось к подсчёту дней между двумя датами: эталонной и текущей, чтобы определить день недели на первое января нужного года.
Такой подход работал, но скорость зависела от того, насколько близко необходимый год к эталонному. Меня это расстраивало, но придумать что-то лучше я тогда не смог. Теперь же настал идеальный момент, чтобы до конца разобраться в этом.
Високосные года в григорианском календаре назначаются следующим образом:
> * год, номер которого кратен 400, — високосный
> * остальные года, номер которых кратен 100, — невисокосные
> * остальные года, номер которых кратен 4, — високосные
> * остальные года — невисокосные
>
Из этого описания видно, что цикл високосности имеет период в 400 лет. Но не ясно, будут ли такие четырёхсотлетние циклы начинаться в один и тот же день недели.
Заметим, что первое января от года к году смещается на один или два дня недели, и напишем
**немного кода.**
```
bool is_leap_year(int year)
{
if ((year % 400) == 0) return true;
if ((year % 100) == 0) return false;
if ((year % 4) == 0) return true;
return false;
}
void first_weekdays_table()
{
ofstream file("weekdays.txt", ios_base::out);
int weekday = 3;
for (int i = 1801; i <= 3000; ++i)
{
file << weekday;
if ((i % 100) != 0)
{
file << " ";
}
else
{
file << endl;
}
weekday += is_leap_year(i) ? 2 : 1;
weekday %= 7;
}
file.close();
}
```
Выводятся дни недели на первое января каждого года, с 1801 до 3000. Понедельник обозначается как «0», вторник как «1», и т. д. Представим всё в виде таблицы из двух полных четырёхсотлетних циклов и двух половинок. По горизонтали идут столетия, по вертикали года в этих столетиях. В ячейки на пересечении столетия и года написан день недели, в который этот год начался. Например, день недели, в который начался 1997 год, стоит на пересечении столбца «1900» и строки «97». Это среда. Полная версия таблицы: [часть 1](https://habrastorage.org/webt/ok/wt/mb/okwtmbrzsaz63uvsh7rzidlv_ug.png), [часть 2](https://habrastorage.org/webt/vp/st/tu/vpsttuiccm0abt3dlbc_j-bgbdu.png).
---
В таблице сразу можно заметить две вещи: четырёхсотлетние циклы действительно начинаются в один день недели (2001, 2401 и 2801 года; понедельник), а вместо 2000 года есть «тысяча девятьсот сотый». Последнее сделано нарочно, для дальнейшего удобства. Первый же факт позволяет нам без препятствий двигаться дальше.
> В григорианском календаре все четырёхсотлетние циклы начинаются в понедельник.
Но самое интересное кроется в полной версии таблицы. Можно обнаружить, что каждое столетие внутри четырёхсотлетнего цикла состоит из повторяющегося двадцативосьмилетнего цикла:
| | | | | | | | | | | | | | | | | | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 1 | 2 | 3 | 5 | 6 | 0 | 1 | 3 | 4 | 5 | 6 | 1 | 2 | 3 | 4 | 6 | 0 | 1 | 2 | 4 | 5 | 6 | 0 | 2 | 3 | 4 | 5 |
Первое столетие начинается со смещением по циклу, равным 0, второе со смещением 4, третье со смещением 8 и четвёртое со смещением 12. Именно для этого таблица представлена в виде, где в столетии есть «сотые» года и нет нулевых. Стоит сказать, что всего существует 14 различных вариантов года. В двадцативосьмилетнем цикле по одному разу на каждый день недели приходится начало високосного года и по три раза начало не високосного.
Теперь мы можем определить день недели для любой даты, не используя опорных дат. Для этого нам надо понять, в каком столетии внутри четырёхсотлетнего цикла находится год и какой он по счёту в этом столетии. По таблице определим день недели на первое января года, а с помощью первой части статьи — день недели в конкретное число нужного месяца. Вместо тысячи слов
**напишем ещё немного кода.**
```
int get_weekday(int year, int month, int day)
{
int weekdays[] = {0, 1, 2, 3, 5, 6,
0, 1, 3, 4, 5, 6,
1, 2, 3, 4, 6,
0, 1, 2, 4, 5, 6,
0, 2, 3, 4, 5};
int shift_not_leap[] = {0, 3, 3, 6, 1, 4, 6, 2, 5, 0, 3, 5};
int shift_leap[] = {0, 3, 4, 0, 2, 5, 0, 3, 6, 1, 4, 6};
bool is_leap = is_leap_year(year);
year -= 1;
year %= 400;
int century = year / 100;
year %= 100;
int index = (year + (4 * century)) % 28;
int weekday = weekdays[index];
weekday += is_leap ? shift_leap[month - 1]
: shift_not_leap[month - 1];
weekday += (day - 1);
weekday %= 7;
return weekday;
}
```
Часть 3. Итоги
--------------
> С помощью всего двух таблиц можно определить день недели для любой даты, не используя при этом опорных дат.
Последовательность дней недели на первое января в двадцативосьмилетнем цикле:
| | | | | | | | | | | | | | | | | | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 1 | 2 | 3 | 5 | 6 | 0 | 1 | 3 | 4 | 5 | 6 | 1 | 2 | 3 | 4 | 6 | 0 | 1 | 2 | 4 | 5 | 6 | 0 | 2 | 3 | 4 | 5 |
И таблица смещений дней недели на первое число каждого месяца для невисокосного и високосного годов:
| | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Янв | Фев | Март | Апр | Май | Июнь | Июль | Авг | Сен | Окт | Нояб | Дек |
| 0 | 3 | 3 | 6 | 1 | 4 | 6 | 2 | 5 | 0 | 3 | 5 |
| 0 | 3 | 4 | 0 | 2 | 5 | 0 | 3 | 6 | 1 | 4 | 6 |
Во время написания статьи, я нашёл на Хабре две схожие по тематике: [раз](https://habr.com/ru/post/217389/) и [два](https://habr.com/ru/post/440270/). Автор первой с помощью специальной таблицы показывает, как найти в уме день недели для дат в XX и XXI веках. Представленная им таблица содержит 56 чисел. Предложенный в статье алгоритм использует таблицу дней недели и две таблицы смещений, содержащие (28 + 2\*12) = 52 числа, которые необходимо запомнить. Весь исходный код лежит на [GitHub'е](https://gist.github.com/yeswell/397d0030d66d961a5fe2cef76ed522b1).
Интересный факт: с 1 по 13 февраля 1918 года в Советской России не родился ни один человек.
Задавайте себе вопросы с утра по воскресеньям =)
Обновление от 03.07.2019 (среда)
--------------------------------
Если представить двадцативосьмилетний цикл в виде таблицы,
```
0, 1, 2, 3, 5, 6,
0, 1, 3, 4, 5, 6,
1, 2, 3, 4, 6,
0, 1, 2, 4, 5, 6,
0, 2, 3, 4, 5
```
то становится понятно, как можно вычислить смещение дня недели на первое января:
```
weekday = (index + (index / 4)) % 7;
```
С учётом этого, а также того, что смещения для месяцев в високосном году можно вычислить через смещения в невисокосном, напишем
**следующую функцию**
```
int get_weekday_c(int year, int month, int day)
{
int shifts[] = {0, 3, 3, 6, 1, 4, 6, 2, 5, 0, 3, 5};
int shift = shifts[month - 1];
if (is_leap_year(year) and (month > 2))
{
shift += 1;
};
year = (year - 1) % 400;
int century = year / 100;
int index = ((4 * century) + (year % 100)) % 28;
int weekday = (index + (index / 4)) + shift + (day - 1);
return (weekday % 7);
}
```
> Таким образом, можно вычислить день недели для любой даты, зная всего лишь 12 чисел: смещения дней недели на первое число каждого месяца. | https://habr.com/ru/post/458356/ | null | ru | null |
# Интеграция с ЕСИА на базе oauth2-client (PHP)
Представляем yet another PHP-пакет интеграции с ЕСИА — [`ekapusta/oauth2-esia`](https://packagist.org/packages/ekapusta/oauth2-esia). Реализован как адаптер к популярному [`league/oauth2-client`](https://packagist.org/packages/league/oauth2-client).
Оргмоменты
----------
Интеграция с ЕСИА затрагивает госорганы, финансовые и страховые компании, кредитные организации (банки, микрофинансы), организации с публичным wi-fi'ем и прочих, кому в будущем правительство даст добро. Основные оргмоменты описаны на Хабре по запросу "[ЕСИА](https://habr.com/search/?q=%D0%95%D0%A1%D0%98%D0%90)", актуальные версии документов доступны на [оф. сайте](http://minsvyaz.ru/ru/documents/?directions=13), а поддержку можно получить в относительно разумные сроки через [esia@minsvyaz.ru](mailto:esia@minsvyaz.ru).
Почему этот пакет?
------------------
[](https://travis-ci.org/ekapusta/oauth2-esia) [](https://coveralls.io/github/ekapusta/oauth2-esia?branch=develop) [](https://github.com/ekapusta/oauth2-esia/blob/develop/LICENSE.md) [](https://esia.gosuslugi.ru/)
* Получение основных и вложенных данных гражданина делается в один запрос, используя доступные в ЕСИА `embeds`. Т.е. для получения контактов/адресов не надо будет делать ещё N отдельных запросов.
* Два варианта подписи запроса: через CLI и через встроенные PHP-функции. Что позволяет работать по RSA и по GOST'у. CLI подписывателю не нужна временная директория.
* Подпись токена доступа проверяется публичными ключами ЕСИА.
* Основан на покрытом тестами [`league/oauth2-client`](https://packagist.org/packages/league/oauth2-client), к которому является адаптером, не изобретая велосипеды и сам покрыт тестами на 100%.
* В тестах есть элементы интеграции — аутентификационный бот, который ходит в реальный тестовый стенд. Спасибо headless-chrome'у.
* Генерация стейта и разбор JWT токена использует пакеты, специально для этого написанные: [`ramsey/uuid`](https://packagist.org/packages/ramsey/uuid) и [`lcobucci/jwt`](https://packagist.org/packages/lcobucci/jwt).
* Совместим с PHP `^ 5.6 || ^ 7.0`.
Покажите код!
-------------
### Конфигурируем
```
use Ekapusta\OAuth2Esia\Provider\EsiaProvider;
use Ekapusta\OAuth2Esia\Security\Signer\OpensslPkcs7;
$provider = new EsiaProvider([
'clientId' => 'XXXXXX', // "Мненомика" в терминах ЕСИА
'redirectUri' => 'https://your-system.domain/auth/finish/',
'defaultScopes' => ['openid', 'fullname', '...'], // Скоупы описаны в методичке
// Для работы с тестовой версией портала
// 'remoteUrl' => 'https://esia-portal1.test.gosuslugi.ru',
// 'remoteCertificatePath' => EsiaProvider::RESOURCES.'esia.test.cer',
], [
'signer' => new OpensslPkcs7('/path/to/public/certificate.cer', '/path/to/private.key')
]);
```
### Какой подписыватель использовать?
* Если вы используете ключи RSA, достаточно `OpensslPkcs7`.
* Если вы используете ключи GOST и скомпилировали PHP с шифрами ГОСТ, то достаточно `OpensslPkcs7`.
* Если вы используете ключи GOST и имеете инструмент, совместимый с openssl, используйте `OpensslCli`. Он имеет параметр «toolpath».
* Если вы используете ключи GOST и фанат докера, вы можете использовать `OpensslCli` с параметром `'toolpath' => 'docker run --rm -i -v $(pwd):$(pwd) -w $(pwd) rnix/openssl-gost openssl'`.
### Редиректим посетителя на ЕСИА
Одновременно сохраняя стейт для последующей проверки.
```
// Где-то страничке https://your-system.domain/auth/start/
$authUrl = $provider->getAuthorizationUrl();
$_SESSION['oauth2.esia.state'] = $provider->getState();
header('Location: '.$authUrl);
exit;
```
### Получаем данные пользователя
Проверяя стейт и меняя код на аутентификационный токен.
```
// Где-то страничке https://your-system.domain/auth/finish/?state=...&code=...
if ($_SESSION['oauth2.esia.state'] !== $_GET['state']) {
exit('The guard unravels the crossword.');
}
$token = $provider->getAccessToken('authorization_code', ['code' => $_GET['code']]);
$esiaPersonData = $provider->getResourceOwner($accessToken);
var_export($esiaPersonData->toArray());
```
### Как обновить токен?
Стандартно, как описано в [документации к oauth2-client](https://github.com/thephpleague/oauth2-client#refreshing-a-token)
Благодарим за внимание
----------------------
Пакет заоперсорсен финтех-компанией в которой я работаю. Не тестировалось на животных.
UPD1
----
Бонусом идёт symfony-бандл [`ekapusta/oauth2-esia-bundle`](https://packagist.org/packages/ekapusta/oauth2-esia-bundle):
* php: `^5.6 || ^7.0`
* symfony: `^2.8 || ^3 || ^4`. | https://habr.com/ru/post/358834/ | null | ru | null |
# Пишем программы для микроконтроллеров AVR в среде Code::Blocks 10.5
Привет, Хабр!
В этом небольшом топике будет показано как использовать популярную IDE Code::Blocks 10.5 для написания программ для микроконтроллеров семейства AVR фирмы ATMEL.
И так, начинается все со скачивания свободного GCC — компилятора C для AVR, который под Windows соответственно называется WinAVR.
Сейчас самой новой версией является версия WinAVR-20100110.
Этот файл скачиваем с SourceForge.
#### Установка WinAVR
Пакет просто устанавливается куда удобно, но, естественно, русских букв не должно быть в пути. После установки, путь к компилятору нужно добавить в PATH, чтобы все программы знали, что мы теперь гордые обладатели WinAVR.
На этом все.
#### Code::Blocks
Code::Blocks установлена,
Запускаем, создаем новый проект, выбираем AVR Project.
Как видно, здесь много целевых платформ, и это является положительным качеством Code::Blocks.
Выбираем тип процессора, который нас интересует, устанавливаем частоту тактирования,
отмечаем галочками типы файлов, которые нам нужны для отладки.
#### Пишем простую программу
Красиво мигаем светодиодами, подключенными к PORTD.
`#include
#include
int main (void)
{
int i=0;
// set PORTD for output
DDRD = 0xFF;
while(1){
for(i = 1; i <= 128; i = i\*2)
{
PORTD = i;
\_delay\_loop\_2(30000);
}
for(i = 128; i > 1; i -= i/2)
{ PORTD = i;
\_delay\_loop\_2(30000);
}
}
return 1;
}`
нажимаем билд — без ошибок, 2 предупреждения.
В рабочей директории проекта в папке BIN находим hex-файл, это и есть программа для нашего микроконтроллера, которая может быть загружена в него и запущена.
Для работы с компилятором из консоли нужен специальный makefile файл, который содержит информацию о типе процессора, тактовой частоте и прочих важных вещах.
При работе с Code::Blocks необходимость заполнения вручную файла makefile отпадает. Потому как все можно настроить в окне настроек компиляции.
Здесь же редактируется оптимизация и прочее прочее.
Code::Blocks очень гибкая среда, которая подойдет многим.
Подошла и мне, теперь я постоянно пишу в ней код для AVR, это удобно.
Надеюсь информация была полезной. | https://habr.com/ru/post/120568/ | null | ru | null |
# Отладочные инструменты .NET разработчика
От переводчика: я наткнулся на эту статью случайно, когда искал информацию по управлению загрузкой символов во время отладки. И хотя по этому вопросу информации было не так много, я с удовольствием прочитал всю статью. Большая часть были мне известна и до этого, но не всё. Уверен, что многие найдут в ней для себя что-то полезное. Статья написана полтора года назад, однако не все переходят на новые версии студии и сопутствующих инструментов сразу после их появления, так что актуальности статья не потеряла.
Баги встречаются на двух этапах жизненного цикла кода: во время разработки и в продакшене. Часто ошибки, которые вылезают в течение 10-15 минут с момента написания кода, мы даже не считаем за баги – они просто часть процесса написания кода. А багами мы гораздо чаще называем проблемы, которые проявляются в продакшене или при тестировании кода, написанного несколько дней назад; вероятно потому, что их сложнее отловить (код уже успел подзабыться). В любом случае, если код не делает того, что должен, это баг и его нужно отловить и исправить.
#### 4 столпа эффективной отладки
* Правильные инструменты. Это то, чему посвящена статья. Но инструменты бесполезны без других трех.
* Использование практик построения архитектуры и кода, отдающих предпочтение слабо связанным объектам и написанию того, что я называю Совершенно Очевидный Код – СОК (Really Obvious Code – ROC rocks!). Эти практики помогают находить баги и избегать внесения изменений, лишь добавляющих новые. И никогда не поздно перечитать *Brian W. Kernighan and P. J. Plauger's «The Elements of Programming Style» (Computing Mcgraw-Hill, 1978)*.
* Использование TDD (разработки через тестирование). Если вы разрабатываете что-то кроме сильно связанного пользовательского интерфейса и не используете TDD – вы разработчик с одной рукой, связанной за спиной. Вы менее продуктивны, чем могли бы быть, и ваш код менее надежен, чем должен быть.
* Методика отладки. Многие разработчики сразу переходят к шагу «разработка решения», что в результате редко приводит к исправлению бага, зато часто создает новые.
**Методика отладки**1. Опишите баг. Соберите всю информацию для полного описания симптомов бага, акцентируя внимание на том, когда симптомы проявляются, а когда – нет.
2. Зафиксируйте баг. Опишите последовательность действий, которая всегда приводит к появлению бага. Так вы убедитесь, что правильно определили условия, приводящие к появлению симптомов бага. Проверьте, что симптомы не проявляются при других условиях.
3. Локализуйте баг. Убедитесь, что вы можете описать, в чем именно истинная причина появления бага и что описание соотносится с шагами 1 и 2.
4. Разработайте и примените решение. Определите, боретесь ли вы с истинной причиной бага или с его симптомами. Напишите код.
5. Проверьте решение. Проверьте, что симптомы больше не проявляются при выполнении действий, описанных в шаге 2.
6. Проведите регрессионное тестирование. Проверьте, что не появилось новых багов.
7. Примените изменения. Перенесите изменения в продакшен.
Если вы применяете TDD, баг означает одну из трех вещей: требования не были корректно переведены в тесты; один из имеющихся тестов неверный (не тестирует то что должен); какой-то тест отсутствует. Фиксация бага (шаг 2) представляет собой исследование этих трех проблем путем исправления или добавления тестов; проверка решения (шаг 5) означает написание новых тестов; регрессионное тестирование (шаг 6) означает запуск нужных наборов тестов; применение решения включает в себя каталогизацию новых тестов.
#### Использование точек останова
Многие разработчики не знают всех возможностей отладки в Visual Studio, потому что отладка «и так работает». Например, хотя каждый VS-разработчик знаком с точками останова, многие не знают, что можно сделать в окне Breakpoints.
Чтобы открыть окно Breakpoins, выберите Debug | Windows | Breakpoints; в окне отобразится список всех установленных вами точек останова. Если вы не уверены, какая точка какой строке кода соответствует, просто кликните по ней двойным кликом и в редакторе откроется связанный с ней код.
Определившись с нужной точкой, вы можете управлять тем, что происходит, когда она срабатывает. Я видел разработчиков, которые проверяют одни и те же переменные раз за разом, поставив точку останова в цикле. По правому клику на точке останова, выбрав When Hit (условие срабатывания), вы можете задать сообщение, которое выводится в окно Intermediate при каждом ее срабатывании. В сообщение можно включать некоторые константы: например, используя $Caller, можно вывести имя метода, вызвавшего код, содержащий точку останова. Также можно включить любые переменные, заключив их в фигурные скобки: например, {Me.NameTextBox.Text} в сообщении выведет значение поля Text.
Другая возможность диалога When Hit позволяет задавать, должно ли останавливаться выполнение программы на точке останова. Если выбрать остановку, то вы увидите каждое сообщение в момент его создания; в противном случае вы сможете просмотреть все сообщения после выполнения программы.
Если вы хотите остановить выполнение только при определенном условии, вы можете выбрать опции Condition или Hit Count. Опция Condition позволяет задать логическое условие, при котором произойдет остановка (например, Position > 30). Также можно выполнить остановку, если одна из переменных изменилась с момента последней остановки. Опция Hit Count прерывает выполнение только если точка останова сработала в n-й раз (или каждые n раз). Это особенно полезно, когда вам нужно остановиться где-то в конце цикла.
Между прочим, мой опыт говорит, что если в какой-то части приложения возникли проблемы, они продолжат там возникать. Если ваш опыт говорит о том же, вам понравятся дополнительные возможности Visual Studio 2010. Вы можете дать точкам останова названия, чтобы не забыть, для чего нужна каждая из них, и экспортировать их в XML-файл. В следующий раз, когда они вам понадобятся, вы можете импортировать их и начать отладку. Импорт/экспорт можно сделать с помощью тулбара вверху окна Breakpoints.
#### Показ и пропуск кода
Мне нравится генерирование кода (я написал книгу по тому, как это делать в .NET). Но хождение по коду, сгенерированному студией и фрэймворком, как правило не дает мне ничего полезного. А раз это не помогает найти проблему, значит делает процесс отладки менее продуктивным и лучше этого избежать.
В любой версии Visual Studio, в пункте Debug | General диалога настроек вы можете выбрать опцию Just My Code и перестать видеть код, который вы не писали. Если впоследствии вам понадобится это отключить (например, если где-то в сгенерированном коде возникает исключение), вы можете это сделать, выбрав Options and Settings в меню Debug (*этот пункт есть только в VS2010 – прим. перев*).
Если же вы устали ходить по какой-то части вашего кода, вы можете использовать один из двух атрибутов. Поставьте на метод атрибут `DebuggerHidden` и вы никогда не попадете в этот метод. Если же поставить атрибут `DebuggerNonUserCode`, вы не будете в него попадать при включенной опции Just My Code и будете при выключенной. Я рекомендую вам использовать второй способ.
С другой стороны, если ошибка возникает где-то в коде Microsoft .NET Framework, вам может понадобится пройти не только по сгенерированному коду, но и по коду классов фрэймворка. И вы можете это сделать! Во-первых, убедитесь, что отключена опция Just My Code. Затем в диалоге Options and Settings в разделе Symbols выберите Microsoft Symbol Server (в VS 2010) или задайте путь к символам как `referencesource.microsoft.com/symbols` (в VS2008). Это позволит вам загрузить символы, которые поддерживают хождение по коду классов .NET. Однако вам еще нужно их загрузить. В VS2010 вы можете кликнуть кнопку Load All Symbols, но нужно набраться терпения на время скачивания.
Чтобы выбрать конкретную сборку (или если вы используете VS2008), в режиме остановки процесса отладки откройте окно Modules и в списке DLL, загруженных вашим приложением, кликните правым кликом на нужной DLL и выберите Load Modules, чтобы загрузить символы для этой DLL. Конечно, подождать всё равно придется, но уже не так долго.
Я один из тех, кто пишет в свойствах полезный код и хочет иметь возможность пошагово их отладить. Начиная с VS2008SP1, появилась опция (Step over properties and operators), выключающая пошаговую отладку свойств и операторов. И в VS2010 она по умолчанию включена, так что вам может понадобиться ее выключить.
#### Визуализация данных
Как ни странно, множество разработчиков не знакомы с визуализаторами данных в Visual Studio. Если в режиме остановки навести мышку на переменную, всплывет подсказка со значением этой переменной. Также может появиться значок с лупой – клик по нему откроет значение переменной в визуализаторе по умолчанию. Если рядом с иконкой появляется стрелка выпадающего списка, клик по стрелке покажет другие визуализаторы для этого типа данных. Например, для строковой переменной будут показаны текстовый, XML и HTML визуализаторы. Если вы храните в строке HTML, HTML-визуализатор позволит понять, как это будет выглядеть в браузере.
Визуализаторы вы можете также использовать в окнах Watch, Autos и Locals, но если вы смотрите какую-то переменную очень часто, вы можете нажать на канцелярскую кнопку в конце всплывающей подсказки, чтобы «пригвоздить» ее на этом месте. Тогда в следующий раз, когда вы будете просматривать эту часть кода, подсказка всплывет автоматически.
Кстати о подсказках – вы можете с их помощью менять значение переменной. В VS2010 даже более того: подсказку можно заставить висеть в окне, существовать всё время сеанса отладки, и даже после его окончания она будет отображать значение переменной из последнего сеанса. Однако, самые крутые инструменты (Debugger Canvas и IntelliTrace) доступны только в VS2010 Ultimate Edition.
**Только в VS2010 Ultimate Edition**Редактор в студии позволяет смотреть только на один участок кода в один момент времени. Но множество багов возникает в результате взаимодействия между разными частями кода. Debugger Canvas позволяет вам увидеть весь ваш код разом, перемещаясь между модулями и приближая нужную часть.
Когда срабатывает точка останова, вам нужно понять, как вы здесь оказались. Можно использовать окно Call Stack, но вы не увидите, что происходило на более ранних этапах (как вариант, можно поставить кучу точек останова и проходить их последовательно, отслеживая переменные).
Если Debugger Canvas позволяет смотреть «через модули», то IntelliTrace – «через время», что дает понимание того, как вы попали в данную точку останова. IntelliTrace собирает и показывает отладочную информацию, которая была доступна в предыдущие моменты времени сеанса отладки.
Еще лучше Debugger Canvas и IntelliTrace работают в связке: в Debugger Canvas есть опция, позволяющая видеть логи IntelliTrace рядом с кодом.
#### Внешние инструменты
Visual Studio – не единственный инструмент отладки, есть сколько угодно внешних и сторонних инструментов, которые вы можете добавить в копилку. Я здесь остановлюсь только на некоторых бесплатных.
Не все внешние инструменты сделаны сторонними производителями. Если вы пишете службы Windows, то знаете, что отлаживать их непростое занятие. Хотя вы и можете подключиться к ним для отладки, к этому времени код OnStart и инициализация уже выполнится. Если баг не дает сервису запуститься, вам остается только гадать, что же пошло не так, вместо того чтобы собрать информацию для описания проблемы.
В подобной ситуации вы можете настроить Just-in-Time (JIT) отладку и автозапуск – сеанс отладки начнется, когда служба запустится или когда возникнет ошибка. Но чтобы это сделать, вам нужно воспользоваться внешними инструментами.
Так как настройка JIT-отладки выходит за рамки данной статьи, вы можете обратиться к соответствующей [статье в MSDN](http://bit.ly/1NtdQA). Эта статья советует использовать Global Flags Editor (gflags.exe); на случай, если вы не можете его найти, описывается, как подправить реестр, чтобы включить JIT-отладку. Однако вам придется научиться пользоваться WinDbg.
**WinDbg: за пределами отладчика Visual Studio**Если вам интересна отладка глубже исходного кода, Microsoft .NET Framework включает в себя несколько прекрасных инструментов.
Вот несколько из них:
* Windows Debugger (WinDbg.exe)
* SOS Debugging Extension (SOS.dll, которая может быть использована в консоли Visual Studio или с WinDbg.exe)
* Assemble Binding Log Viewer (Fuslogvw.exe, который я обсуждал в [блоге .NET Tips](http://bit.ly/p142Zi))
Если вы не использовали раньше WinDbg, это не так страшно, как может показаться – WinDbg имеет GUI (в отличие от консольных инструментов типа NTSD, KD и CBD) и может загружать PDB-файлы с отладочными символами для вашего приложения (просто убедитесь, что вы скомпилировали ваше приложение в Debug-режиме и файл символов гарантированно подходит). Вдобавок к SOS, есть еще несколько других расширений WinDbg для выполнения типичных отладочных задач.
Однако, самый полезный инструмент для использования с WinDbg – это книга M*ario Hewardt, Patrick Dussud «Advanced .NET Debugging» (Addison-Wesley Professional, 2009)*. Она не просто рассказывает, как использовать все эти инструменты, но делает это в контексте отлавливания типичных для .NET проблем.
#### Сторонние визуализаторы
Я уже говорил про визуализаторы Visual Studio, но есть еще множество сторонних. DotNetDan’s DataSet Visualizer – весьма чудесен, если вам нужно знать, что лежит в датасете (я упоминал его в [блоге](http://bit.ly/p8Ieeq))
С того времени я уже обнаружил RightHand DataSet Visualizer и стал использовать его. Это MDI-приложение, которое позволяет открыть окно для каждой таблицы датасета. Кроме того, окно Relations показывает таблицы, связанные с текущей просматриваемой.
Грид, отображающий таблицу, не простой – вы можете перетащить колонку в прямоугольник вверху окна, чтобы группировать вашу таблицу по этой колонке. Также можно изменять данные в датасете и менять фильтр RowState, чтобы отображались только строки с определенным RowState (например, только удаленные). Еще можно смотреть (и менять) некоторые свойства датасета. И даже можно выгрузить датасет в XML-файл или загрузить тестовые данные из сохраненного ранее.
Следует отметить, что DotNetDan’s DataSet Visualizer быстрее загружает данные, так что я оставил его на случай, когда не нужна вся мощь RightHand.
Еще есть Web Visualizer для приложений ASP.NET. Этот визуализатор доступен на всплывающей подсказке любого объекта страницы ASP.NET (включая Me и this в коде ASP.NET)
С помощью Web визуализатора можно смотреть любые данные коллекции Server Variables объекта Server и коллекции Forms объекта Request. Также можно посмотреть строку запроса браузера и содержимое объектов Session и Application. Однако, в случае Session и Application для любых объектов, кроме скалярных данных, вы увидите только название типа объекта.
Есть и другие визуализаторы, включая те, что позволяют смотреть Cache и LINQ-запросы к Entity Framework (EF), а также позволяющие увидеть SQL на выходе LINQ-запросов к EF. Печально только то, что нет единого каталога визуализаторов.
Не все, но многие можно найти через Visual Studio Extension Manager. В том числе, ASP.NET MVC Routing Visualizer. Если вы используете маршрутизацию в ASP.NET MVC или в простом ASP.NET, вам пригодится этот инструмент. Взаимодействие между правилами маршрутизации может выдавать неожиданные результаты («Почему я получаю эту страницу?»), и отладка этих правил может быть непростой. Визуализатор позволяет вам ввести URLы и посмотреть, как маршрутизатор их декодирует, включая информацию о том, какое правило используется для каждого URL. Чтобы использовать его в режиме останова, переключитесь на ваш файл global.asax и наведите курсор на RouteTable. Когдя появится всплывающая подсказка, промотайте до коллекции Routes и кликните на значок лупы.
#### Трассировка
Трассировка по определению непривлекательна. Однако когда в продакшене вы нарываетесь на один из неуловимых багов, которые сложно повторить (и которые появляются и исчезают сами по себе), трассировка – единственный путь получить нужную информацию. Для этого, во-первых, вам нужно организовать запись сообщений в лог, который даст вам информацию для поимки бага. Но чтобы эта информация стала полезной, нужен инструмент для анализа содержимого лога.
Хотя в мире .NET для трассировки существует множество пакетов, я использую log4net. Среди прочих возможностей, log4net позволяет мне встроить в код отладочные сообщения и затем включать или отключать их во время работы без необходимости пересборки приложения. Одно замечание: log4net – очень гибкий инструмент и возможно больше, чем это требуется вам.
Когда дело доходит до чтения полученных логов, я использую Log Parser Lizard от Lizard Labs. В бесплатной версии некоторые возможности ограничены (цена платной – около 25$), однако мне они ни разу не понадобились. Log Parser Lizard использует SQL-подобный синтаксис для построения запросов к логам (включая файлы формата CSV и XML) и прямо из коробки понимает форматы логов IIS, событий Windows и log4net. Результаты отображаются в таблице, что делает его похожим на Server Explorer, с которым мне очень нравится работать.
#### Заключение
Все эти инструменты полезны, но не забывайте, что самый важный – это правильная методика отладки. Инструменты могут помочь вам найти и зафиксировать баг, но именно методика отладки позволяет разработать и применить решение. | https://habr.com/ru/post/149125/ | null | ru | null |
# Теперь наш публичный синтез в супер-высоком качестве, в 10 раз быстрее и без детских болячек
В нашей прошлой [статье](https://habr.com/ru/post/584750/) про синтез речи мы дали много обещаний: убрать детские болячки, радикально ускорить синтез еще в 10 раз, добавить новые "фишечки", радикально улучшить качество.
Сейчас, вложив огромное количество работы, мы наконец готовы поделиться с сообществом своими успехами:
* Снизили размер модели в 2 раза;
* Научили наши модели делать паузы;
* Добавили один высококачественный голос (и бесконечное число случайных);
* Ускорили наши модели где-то примерно в 10 раз (!);
* Упаковали всех спикеров одного языка в одну модель;
* Наши модели теперь могут принимать на вход даже целые абзацы текста;
* Добавили функции контроля скорости и высоты речи через SSML;
* Наш синтез работает сразу в трех частотах дискретизации на выбор — 8, 24 и 48 килогерц;
* Решили детские проблемы наших моделей: нестабильность и пропуск слов, и добавили флаги для контроля ударения;
Это по-настоящему уникальное и прорывное достижение и мы не собираемся останавливаться. В ближайшее время мы добавим большое количество моделей на разных языках и напишем целый ряд публикаций на эту и смежные темы, а также продолжим делать наши модели лучше (например, еще в 2-5 раз быстрее).
Попробовать модель как обычно можно в нашем [репозитории](https://github.com/snakers4/silero-models#text-to-speech) и в [колабе](https://colab.research.google.com/github/snakers4/silero-models/blob/master/examples_tts.ipynb).
Как попробовать
---------------
Для самых нетерпеливых — вот основные примеры звучания:
**Update** — баг с резким прерыванием речи на паузе уже пофиксили
Как обычно, все инструкции можно найти:
* В нашем публичном репозитории по [ссылке](https://github.com/snakers4/silero-models#text-to-speech). Вам нужны модели для синтеза `V3`;
* Или можно прямо в [колабе](https://colab.research.google.com/github/snakers4/silero-models/blob/master/examples_tts.ipynb);
Вот самый минималистичный пример вызова модели:
```
import torch
device = torch.device('cpu')
torch.set_num_threads(4)
speaker = 'xenia' # 'aidar', 'baya', 'kseniya', 'xenia', 'random'
sample_rate = 48000 # 8000, 24000, 48000
model, example_text = torch.hub.load(repo_or_dir='snakers4/silero-models',
model='silero_tts',
language='ru',
speaker='ru_v3')
model.to(device)
audio = model.apply_tts(text=example_text,
speaker=speaker,
sample_rate=sample_rate)
```
Спикеров и принимаемые символы для каждой модели можно посмотреть в свойствах модели `model.speakers` и `model.symbols`.
**Или вот такой пример, если вы хотите скачать модель к себе более явно в кеш:**
```
import os
import torch
device = torch.device('cpu')
torch.set_num_threads(4)
local_file = 'model.pt'
speaker = 'xenia' # 'aidar', 'baya', 'kseniya', 'xenia', 'random'
sample_rate = 48000 # 8000, 24000, 48000
if not os.path.isfile(local_file):
torch.hub.download_url_to_file('https://models.silero.ai/models/tts/ru/ru_v3.pt',
local_file)
model = torch.package.PackageImporter(local_file).load_pickle("tts_models", "model")
model.to(device)
audio = model.apply_tts(text=example_text,
speaker=speaker,
sample_rate=sample_rate)
```
Как обычно, больше примеров вы можете найти по ссылкам в репозитории или в статье ниже. Все дальнешие примеры мы будем приводить без импортов для экономии места. С недавнего времени у моделей также появился своё `pip`-пакет, аналогичный по функционалу импорту через `torch.hub`.
Новые фишки и примеры аудио
---------------------------
Перечислим еще раз все нововведения вместе и более подробно пройдемся по каждому из них ниже с примерами:
* Снизили размер модели в 2 раза (ненарочно);
* Научили наши модели делать паузы;
* Добавили один высококачественный голос (и бесконечное число случайных);
* Ускорили наши модели где-то примерно в 10 раз (!);
* Упаковали всех спикеров одного языка в одну модель;
* Наши модели теперь могут принимать на вход даже целые абзацы текста;
* Добавили функции контроля скорости и высоты речи через SSML;
* Наш синтез работает сразу в трех частотах дискретизации на выбор — 8, 24 или 48 килогерц;
* Решили детские проблемы наших моделей: нестабильность и пропуск слов, и добавили флаги для контроля ударения;
### Ускорение моделей в 10 раз
Тут особо нечего сказать, наши модели просто стали в 10 раз быстрее.
Скорость мы измеряем в секундах сгенерированного аудио в секунду, ограничивая число потоков в PyTorch (1 ядро = 2 потока) на процессоре Intel.
Так например, скорость V3 модели для 8 kHz в 50 секунд аудио в секунду означает, что аудио длиной в 5 секунд будет сгенерировано примерно за 100 ms.
| | V1 модель | V1 модель | V3 модель | V3 модель |
| --- | --- | --- | --- | --- |
| | 1 поток | 4 потока | 1 поток | 4 потока |
| 8 kHz | 1.9 | 4.2 | 15 — 25 | 30 — 60 |
| 16 kHz | 1.4 | 3.1 | - | - |
| 24 kHz | - | - | 10 | 15 — 20 |
| 48 kHz | - | - | 5 | 10 |
Так как на CPU задержка и скорость напрямую зависят от длины генерируемого аудио, новые цифры указаны в виде интервалов. Скорость выходит на плато примерно на длительности аудио в 5 секунд. Задержка, понятно, линейно зависит от длины генерируемого аудио.
Тут интересно также посмотреть на задержку — её легко посчитать в уме, просто поделив нужную длину аудио на скорость. По ряду технических причин, наши модели теперь не принимают списки текстов и не работают с батчами.
В ближайшем будущем мы уже планируем (и самое главное — знаем как) ускорить модель еще в 2-5 раз. Также вышло снизить размер модели в 2 раза, но мы особо этим не занимались целенаправленно. Пока есть определенные проблемы с квантизацией и конвертацией в ONNX, но в теории минимальный возможный размер модели находится в районе 5-10 мегабайт. Вы всегда можете помочь нам профинансировать соответствующие исследования.
### Пробуем разные высококачественные голоса
Тут также важно обратить внимание, что теперь все спикеры на одном языке будут жить внутри одной модели.
В этот раз мы готовы представить 4 высококачественных голоса, послушать можно по ссылке:
Для добавления нового голоса `xenia` нам потребовалось записать всего лишь 2 часа аудио, и это не предел.
**Спикер явным образом указывается при вызове модели:**
```
...
speaker = 'xenia' # 'aidar', 'baya', 'kseniya', 'xenia', 'random'
...
audio = model.apply_tts(text=example_text,
speaker=speaker,
sample_rate=sample_rate)
```
### Синтезируем аудио разного качества
Мы можем синтезировать аудио с частотой дискретизации на выбор: 8, 24 или 48 килогерц. Предсказуемо, скорость работы моделей линейно меняется в зависимости от этого параметра.
**Частота дискретизации тоже явным образом указывается при вызове модели:**
```
...
sample_rate = 48000 # 8000, 24000, 48000
...
audio = model.apply_tts(text=example_text,
speaker=speaker,
sample_rate=sample_rate)
```
Небольшая ремарка — качество модели для 8 килогерц сейчас не максимально возможное, мы это поправим при ускорении моделей.
### Управляем речью и генерируем целые абзацы текста с помощью SSML
Раньше у моделей возникали проблемы при работе с текстами длиннее 140 символов — сейчас это ограничение снято. Также для удобства мы добавили поддержку самых важных SSML тегов:
| Тег | Пример тега | Возможные значения | Комментарий |
| --- | --- | --- | --- |
| Пауза | | `5s`, `500ms` | Целое число секунд или миллисекунд |
| Скорость речи | `…` | `x-slow`, `slow`, `medium`, `fast`, `x-fast` | rate и pitch можно комбинировать |
| Высота речи | `…` | `x-low`, `low`, `medium`, `high`, `x-high`, `robot` | rate и pitch можно комбинировать |
| Предложение | `~~…~~` | - | Эквивалентен точке |
| Абзац | `…` | - | Эквивалентен длинной паузе |
Более подробную документацию по тегам можно найти [тут](https://github.com/snakers4/silero-models/wiki/SSML).
Основные теги на примерах:
**Update** — баг с резким прерыванием речи на паузе уже пофиксили
**Пример работы с SSML тегами можно увидеть ниже:**
```
ssml_sample = """
Когда я просыпаюсь, я говорю довольно медленно.
Потом я начинаю говорить своим обычным голосом,
а могу говорить тоном выше ,
или наоборот, ниже.
Потом, если повезет – я могу говорить и довольно быстро.
А еще я умею делать паузы любой длины, например две секунды .
Также я умею делать паузы между параграфами.
~~И также я умею делать паузы между предложениями~~
~~Вот например как сейчас~~
"""
sample_rate = 48000
speaker = 'xenia'
audio = model.apply_tts(ssml_text=ssml_sample,
speaker=speaker,
sample_rate=sample_rate)
```
### Управляем ударением
Мы добавили возможность авторасстановки ударений ещё в прошлой версии, но в новом релизе стало доступно явно управлять флагами ударения и простановки буквы `ё`:
* `put_accent` — флаг автоматической простановки ударения;
* `put_yo` — флаг автоматической простановки буквы `ё`;
Вручную ударение, как и раньше, можно проставлять с помощью символа `+`.
Вот примеры — нет ударения вовсе, автоматическое ударение, автоматическое ударение + пара правок:
**Пример управления ударением:**
```
ssml_sample = """
В недрах тундры выдры в гетрах тырят в ведрах ядра к+едров!
Выдрав с выдры в тундре гетры, вытру выдрой ядра к+едра.
Вытру гетрой выдре морду, +ядра - в в+ёдра, выдру в тундру.
"""
sample_rate = 48000
speaker = 'aidar'
audio = model.apply_tts(ssml_text=ssml_sample,
speaker=speaker,
sample_rate=sample_rate,
put_accent=True,
put_yo=True)
display(Audio(audio, rate=sample_rate))
```
Единственная загвоздка состоит в том, что мы смогли добиться точности только в 80% в простановке ударения на омографах, и поэтому новая версия модели не вошла в этот релиз. Наша цель — точность на уровне 90-95%. Также в следующей версии мы увеличим словарь словоформ до 4 миллионов штук.
### Дополнительные прикольные возможности
Среди дополнительных фишечек есть:
* Возможность говорить "как робот" (с помощью тега `prosody` с `pitch="robot"`);
* Возможность генерации и сохранения бесконечного количества "случайных" спикеров;
* Возможность клонировать интонацию некой "модельной" фразы (в непубличной версии модели);
**Пример генерации, сохранения и загрузки случайного спикера:**
```
sample_rate = 48000
speaker = 'random'
audio = model.apply_tts(ssml_text=ssml_sample,
speaker=speaker,
sample_rate=sample_rate)
model.save_random_voice('test_voice.pt')
audio = model.apply_tts(ssml_text=ssml_sample,
speaker=speaker,
voice_path='test_voice.pt')
```
Также можно послушать как работает перенос интонаций на известных и неизвестных спикерах:
Понятно, что можно сделать генеральную модель, которая бы хорошо работала на всем, но мы пока не ставили такой задачи.
Типичные проблемы публичных решений и индустрии
-----------------------------------------------
Часто после какой-то очередной пиар акции очередного инвестиционного стартапа, мне пишут люди, мол смотрите какие классные вещи люди делают.
На практике оказывается, что кто-то просто скопировал код самой модной статьи, прикрутил к нему CLI и теперь люди могут по-настоящему делать качественные, быстрые и демократичные модели!
В реальности такие решения долго тренируются, спроектированы на работу на карточках по типу RTX 3090 — A100 — V100 (то есть, имеющих более 16 GB VRAM) и уступают уже существующим решениям.
Вот недавно мы сравнивали новую модную модель VITS:
* В статье авторы пишут про инференс только на картах по типу V100;
* На практике на инфересе нужно более 16 GB VRAM для фраз нетривиальной длины (я не понимал зачем на инференсе такие карты до этого теста);
* Скорость уступает более простым решениям;
Самое печальное, что зачастую такие статьи написаны таким образом, чтобы нельзя было понять, какие элементы моделей на самом деле "тащат". Отчасти поэтому новые релизы занимают столько времени.
| | Max VRAM, MB |
| --- | --- |
| VITS | 16,301 |
| Fast Pitch | 3,215 |
Мы не преследуем идеологию перепродажи чужих наработок и воздуха инвесторам и поэтому мы делаем максимально простые, быстрые и максимально публичные компактные решения.
Дальнейшие планы
----------------
Мы не будем останавливаться на достигнутом, паниковать и следовать токсичным и самоуничижительным трендам.
Мы гордимся нашей командой и тем, что мы сделали по-настоящему уникальный продукт.
Мы верим, что только так мы все вместе можем бороться с игом корпораций, особенно иностранных.
**Именно по синтезу, дальше мы планируем:**
* Ускорить наш синтез еще в 2-5 раз;
* Прикрутить квантизацию и ONNX и тем самым возможно ускорить синтез еще в 2-4 раза;
* Добавить возможность использовать фонемы напрямую для синтеза для произношения сложных слов и аббревиатур;
* Довести до конца работу по автоматической простановке ударения в предложениях с омографами и достичь точности в 90-95% на омографах;
* Обновить модели для имеющихся у нас языков СНГ (если вы хотите записать какие-то новые — добро пожаловать), включая украинский;
* Обновить модели для английского и основных европейских языков (мы пока не решили каких именно);
* Сделать модель для индийских языков;
* И есть еще пара секретных фановых мини проектов, о которых я не буду вам рассказывать =);
* Нам и так потребовалась буквально пара часов для добавления нового высококачественного голоса и мы уже можем генерировать бесконечные случайные голоса. Возможно мы снизим штатное количество аудио для добавления нового высококачественного голоса до нескольких минут вместе с возможностью использования фонем; | https://habr.com/ru/post/660565/ | null | ru | null |
# Простой интерпретатор с нуля на Python (часть 3)
**Содержание**[Простой интерпретатор с нуля на Python #1](http://habrahabr.ru/post/206320/)
[Простой интерпретатор с нуля на Python #2](http://habrahabr.ru/post/206454/)
**Простой интерпретатор с нуля на Python #3**
[Простой интерпретатор с нуля на Python #4](http://habrahabr.ru/post/207662/)
**Разъяснение к публикации**Пользователь @duse ранее выкладывал переводы двух предыдущих статей, явно намереваясь перевести всю серию. Так как тема меня очень интересует, а новых переводов нет, обратился к первоисточнику. С английским не очень силён, чтобы не терять суть, стал переводить на русский. Так и родился этот перевод. Прошу прощения у @duse в случае, если мне стоило ещё чуточку потерпеть. Но для сообщества в любом случае должна быть польза.
Таким образом, мы написали лексер библиотеку комбинатора парсеров для нашего интерпретатора. В этой части, мы создадим структурные данные абстрактного синтаксического дерева (AST), и напишем парсер, используя нашу библиотеку комбинаторов, которые переводят список токенов, возвращенных лексером, в абстрактное синтаксическое дерево (AST). После того, как мы распарсим AST, запустить программу будет очень просто.
#### Определяем AST
Прежде, чем мы начнём написание нашего парсера, нам нужно определить структуры данных, которые наш парсер будет возвращать. Определим их при помощи классов. Каждый синтаксический элемент IMP будет иметь соответствующий класс. Объекты этого класса будут отображать ноды в AST.
В нашем IMP всего три структуры: арифметические выражения (используемые для вычисления чисел), логические выражения (используемые для вычисления условий для if и while высказываний), и состояния. Начнём с арифметических выражений, так, как оставшиеся два зависят от него.
Арифметическое выражение может принимать одну из трёх форм:
* Буквенные числовые константы, такие как `42`
* Переменные, такие как `x`
* Бинарные операции, такие как `x + 42`. Они образованны из других арифметических выражений
Мы также можем группировать выражения вместе скобками (как `(x+2)*3`). Это не сколько иной тип выражения, сколько иной способ разбора выражения.
Определим три класса для этих форм, плюс базовый класс для основных арифметических выражений. Пока классы не делают ничего кроме хранения информации. Метод `__repr__` позволит выводить на печать `AST` во время отладки. Все `AST` классы будут наследовать `Equality`, поэтому мы сможем проверять одинаковость двух `AST` объектов, что тоже пригодиться при тестировании.
```
from equality import *
class Aexp(Equality):
pass
class IntAexp(Aexp):
def __init__(self, i):
self.i = i
def __repr__(self):
return 'IntAexp(%d)' % self.i
class VarAexp(Aexp):
def __init__(self, name):
self.name = name
def __repr__(self):
return 'VarAexp(%s)' % self.name
class BinopAexp(Aexp):
def __init__(self, op, left, right):
self.op = op
self.left = left
self.right = right
def __repr__(self):
return 'BinopAexp(%s, %s, %s)' % (self.op, self.left, self.right)
```
Логические выражения немного сложнее. Существует 4 типа логических выражений:
* Выражения отношений (такие как `x < 10`)
* `And` выражения (такие как `x < 10 and y > 20`)
* `Or` выражения
* `Not` выражения
Левые и правые части выражений отношений — это арифметические выражения. Левые и правые части `and`, `or`, или `not` выражений — логические выражения. Подобное разграничение типов помогает нам избегать бессмысленные выражения вроде `x < 10 and 30`.
```
class Bexp(Equality):
pass
class RelopBexp(Bexp):
def __init__(self, op, left, right):
...
class AndBexp(Bexp):
def __init__(self, left, right):
...
class OrBexp(Bexp):
def __init__(self, left, right):
...
class NotBexp(Bexp):
def __init__(self, exp):
...
```
Утверждения (statements) могут содержать арифметические и логические выражения одновременно. Существует 4 типа выражений: присвоение, соединение, условия и циклы.
```
class Statement(Equality):
pass
class AssignStatement(Statement):
def __init__(self, name, aexp):
...
class CompoundStatement(Statement):
def __init__(self, first, second):
...
class IfStatement(Statement):
def __init__(self, condition, true_stmt, false_stmt):
...
class WhileStatement(Statement):
def __init__(self, condition, body):
...
```
#### Примитивы
Теперь мы имеем наши `AST` классы и подходящий набор комбинаторов — самое время написать наш парсер. При написании парсера, легче начать с базовых структур языка, постепенно переходя к более сложным вещам.
Первый парсер, который мы рассмотрим, это парсер `keyword`. Им является всего лишь специальная версия `Reserved`-комбинатора с использованием тэга `RESERVED`, которым помечены все ключевые слова. Запомните, `Reserved` соответствует одиночному токену, у которого значение и тэг такие же, как у переданных.
```
def keyword(kw):
return Reserved(kw, RESERVED)
```
`keyword` является фактическим комбинатор, потому, что это функция, возвращающая парсер. Мы и будем его использовать напрямую в других парсерах.
Парсер `id` используется для сопоставления именам переменных. Он использует комбинатор `Tag`, который сопоставляет токен с указанным тэгом.
```
id = Tag(ID)
```
Парсер `num` используется для сопоставления целых чисел. Он работает почти как и `id`, за исключением того, что мы использует комбинатор `Process` (точнее `^` оператор, который вызывает `Process`) для преобразования токена в конкретное целое число.
```
num = Tag(INT) ^ (lambda i: int(i))
```
#### Разбор арифметических выражений
Разбор арифметических выражений не прост, но нам необходимо парсить арифметические выражения, для того, чтобы разобрать логические выражения или утверждения, поэтому мы должны начать именно с них.
Сперва мы определим парсер `aexp_value`, который будет конвертировать значения, возвращенные `num` и `id` в фактические выражения.
```
def aexp_value():
return (num ^ (lambda i: IntAexp(i))) | \
(id ^ (lambda v: VarAexp(v)))
```
Мы использовали оператор `|`, который является сокращением для комбинатора `Alternate`. Это позволит разбирать выражения целых чисел первыми. Если они провалятся, будет произведена попытка разбора выражения с переменной.
Отметим, что мы определили `aexp_value` как функцию без аргументов вместо глобального значения, так же, как мы поступили и с `id` и `num`. Так же поступим и со всеми оставшимися парсерами. И сделали мы это потому, не хотим, чтобы код каждого парсера был вычислен сразу. Если бы мы определили каждый парсер как глобальный, каждый парсер не смог бы сослаться на другие парсеры, которые следуют далее в том же исходном файле, потому, как они ещё не были бы объявлены. Это сделало бы невозможным определить рекурсивные парсеры, и исходный код стал бы менее читабелен.
Далее, мы хотели бы в наших арифметических выражениях реализовать группировку со скобками. Хотя группировка выражения не требуют собственного класса `AST`, им необходим другой парсер, обрабатывающий их.
```
def process_group(parsed):
((_, p), _) = parsed
return p
def aexp_group():
return keyword('(') + Lazy(aexp) + keyword(')') ^ process_group
```
Функция `process_group` используется с комбинатором `Process` (`^` оператор). Она просто отбрасывает токены скобок и возвращает выражение внутри. Фактически, `aexp_group` тоже является парсером. Запомните, оператор `+` это сокращение для комбинатора `Concat`. Так что она распарсит '(', следующую за арифметическим выражением (разобранным `aexp`, которое мы скоро определим), следующее за ')'. Необходимо избегать прямого вызова `aexp`, потому, как `aexp` вызывает `aexp_group`, что приведёт к бесконечной рекурсии. Используем комбинатор `Lazy`, который откладывает вызов aexp до тех пор, пока парсер не будет применён к каким-либо входным данным.
Далее, мы комбинируем `aexp_value` и `aexp_group` при помощи `aexp_term`. Выражение `aexp_term` — это любое простое самостоятельное выражение, в котором мы не должны заботиться о старшинстве операторов по отношению к другим выражениям.
```
def aexp_term():
return aexp_value() | aexp_group()
```
Сейчас мы подходим к каверзной части: операторы и старшинство. Будет проще определить другой парсер для `aexp` и выбрасывать его совместно с `aexp_term`. Это приведёт выражение:
```
1 + 2 * 3
```
к такому неверному разбору:
```
(1 + 2) * 3
```
Парсер должен знать о старшинстве операторов, и он должен группировать друг с другом операторы с более высоким старшинством.
Мы определим несколько вспомогательных функций для того, чтобы выполнить эту работу.
```
def process_binop(op):
return lambda l, r: BinopAexp(op, l, r)
```
Функция `process_binop` — это то, что создаёт объект `BinopAexp`. Эта функция принимает любой арифметический оператор и возвращает функцию, которая комбинирует пары выражений, используя этот оператор…
Функция `process_binop` должна использоваться с комбинатором `Exp` (`*` оператор). Комбинатор `Exp` разбирает список выражений с разделителем между каждой парой выражений. Левый оператор `Exp` — парсер, который сопоставляет индивидуальные элементы списка (в нашем случае, арифметических выражений). Правый оператор — это парсер, который сопоставит разделители (операторы). Неважно, какой разделитель сопоставлен, правый парсер вернёт функцию, которая, учитывая соответствие операторов, возвращает функцию объединения. Функция объединения принимает разобранные выражения слева и справа от разделителя, и возвращаете единое, объединённое выражение. Ещё не запутались? Мы быстренько пройдём использование `Exp`. Функция `process_binop` — это то, что возвратит правый парсер.
Далее, мы определим наши уровни старшинства и комбинатор, помогающий нам с ними справляться.
```
def any_operator_in_list(ops):
op_parsers = [keyword(op) for op in ops]
parser = reduce(lambda l, r: l | r, op_parsers)
return parser
aexp_precedence_levels = [
['*', '/'],
['+', '-'],
]
```
Функция `any_operator_in_list` принимает список строк ключевых слов и возвращает соответствующий им парсер. Определим `aexp_precedence_levels`, содержащий список операторов для каждого уровня старшинства (начиная с более высокого).
```
def precedence(value_parser, precedence_levels, combine):
def op_parser(precedence_level):
return any_operator_in_list(precedence_level) ^ combine
parser = value_parser * op_parser(precedence_levels[0])
for precedence_level in precedence_levels[1:]:
parser = parser * op_parser(precedence_level)
return parser
```
`precedence` — это фактическое содержание операции. Его первый аргумент, `value_parser`, это парсер, который может читать простые части выражения: числа, переменные и группы. Это будет `aexp_term`. Список `precedence_levels` содержит список операторов, по одному списку на каждый уровень. Для этого используем `aexp_precedence_levels`. `combine` будет принимать функцию, которая, переданная оператором, возвратит функцию для построения одного большого выражения из двух небольших. Это и будет `process_binop`
Внутри `precedence`, мы сначала определим `op_parser`, который, для данного уровня старшинства, читает только операторы с тем же уровнем и возвращает функцию, которая объединяет два выражения. `op_parser` может использоваться как правый аргумент `Exp`. Мы начинаем с вызова `Exp` с `op_parser` для наивысшего уровня старшинства, ибо эти операции должны группироваться первыми. Далее используем результирующий парсер как элемент парсера (левый аргумент `Exp`) на следующем уровне. После окончания цикла, результирующий парсер способен корректно разбирать арифметическое выражение.
Как это работает на практике? Давайте разберём.
```
E0 = value_parser
E1 = E0 * op_parser(precedence_levels[0])
E2 = E1 * op_parser(precedence_levels[1])
```
`E0` является тем же, что и `value_parser`. Он может парсить числа, переменные и группы, но не операторы. `E1` моет парсить выражения, содержащие всё, что может совпадать с `E0`, разделённые операторами из первого уровня старшинства. Так `E1` может сопоставлять `a * b / c`, но должен вызвать ошибку как только столкнётся с оператором `+`. `E2` может сопоставлять выражения, разделённые операторами следующего уровня старшинства. Так как мы имеем только 2 уровня старшинства, `E2` может сопоставлять любые арифметические выражения, которые мы поддерживаем.
Давайте выполним пример. Возьмём сложное арифметическое выражение, и понемногу заменим каждую часть её сопоставлением.
```
4 * a + b / 2 - (6 + c)
E0(4) * E0(a) + E0(b) / E0(2) - E0(6+c)
E1(4*a) + E1(b/2) - E1(6+c)
E2((4*a)+(b/2)-(6+c))
```
Мы используем старшинство непосредственно для определения `aexp`:
```
def aexp():
return precedence(aexp_term(),
aexp_precedence_levels,
process_binop)
```
Вероятно, мы можем определить старшинство менее абстрактно, но преимущество нашего подхода в том, что так мы применяем его в любой ситуации, имеющей проблему старшинства операторов. Мы повторно применим её для разбора логических выражений.
#### Разбор логических выражений
Мы уже можем перейти от арифметических выражений к логическим. Логические выражения обычно проще арифметических, так что нам не понадобятся новые инструменты для их разбора. Начнём с самых простых логических выражений:
```
def process_relop(parsed):
((left, op), right) = parsed
return RelopBexp(op, left, right)
def bexp_relop():
relops = ['<', '<=', '>', '>=', '=', '!=']
return aexp() + any_operator_in_list(relops) + aexp() ^ process_relop
```
Функцию `process_relop` мы используем с комбинатором `Process`. Он принимает три соединённых значения и создаёт из них `RelopBexp`. В `bexp_relop` мы разбираем два арифметических выражения (`aexp`), разделённых оператором отношения. И мы используем нашего старичка — функцию `any_operator_in_list`, так что нам не нужно писать случай для каждого оператора. Так же нет необходимости использовать комбинаторы вроде `Exp` или `precedence`, так как выражения отношений не могут соединяться друг с другом в IMP так, как они делается других языках.
Далее, определим выражение `not`. Выражение `not` является унарным оператором с высоким старшинством. Это делает его более простым для разбора чем `and` и `or` выражения.
```
def bexp_not():
return keyword('not') + Lazy(bexp_term) ^ (lambda parsed: NotBexp(parsed[1]))
```
Здесь мы соединили ключевое слово `not` с названием логического выражения (которое мы определим далее). Так как `bexp_not` будет использоваться для определения `bexp_term`, нам необходимо использовать комбинатор `Lazy` для избегания бесконечной рекурсии.
```
def bexp_group():
return keyword('(') + Lazy(bexp) + keyword(')') ^ process_group
def bexp_term():
return bexp_not() | \
bexp_relop() | \
bexp_group()
```
Определяем `bexp_group` и `bexp_term` таким же образом, как и для арифметических эквивалентов. В этом нет ничего нового.
Далее, нам нужно определить выражения, которые включают операторы `and` и `or`. Эти операторы на самом деле работают как и арифметические операторы; и те и другие выполняются с лева на право, и `and` имеет высший уровень старшинства.
```
bexp_precedence_levels = [
['and'],
['or'],
]
def process_logic(op):
if op == 'and':
return lambda l, r: AndBexp(l, r)
elif op == 'or':
return lambda l, r: OrBexp(l, r)
else:
raise RuntimeError('unknown logic operator: ' + op)
def bexp():
return precedence(bexp_term(),
bexp_precedence_levels,
process_logic)
```
Так же как и `process_binop`, `process_logic` предназначен для использования с комбинатором `Exp`. Он принимает оператор и возвращает функцию, которая комбинирует два подвыражения в одно выражение, используя этот оператор. Мы подставляем это в соответствии со старшинством так же, как и в `aexp`. Написание общего кода здесь окупается, так как мы не должны повторять сложный код выражение обработки выражения.
#### Разбор утверждений
С окончанием `aexp` и `bexp`, мы можем начать разбор IMP утверждений. Начнём со скромного утверждения присваивания:
```
def assign_stmt():
def process(parsed):
((name, _), exp) = parsed
return AssignStatement(name, exp)
return id + keyword(':=') + aexp() ^ process
```
Ничего особо интересного. Далее, мы посмотрим на `stmt_list`. Он будет разбирать серию утверждений, разделённых точкой с запятой.
```
def stmt_list():
separator = keyword(';') ^ (lambda x: lambda l, r: CompoundStatement(l, r))
return Exp(stmt(), separator)
```
Помните, нам нужно использовать комбинатор `EXP` здесь вместо чего-то более простого как `stmt() + keyword(';') + stmt()` для избегания левосторонней рекурсии.
Далее у нас утверждение `if`:
```
def if_stmt():
def process(parsed):
(((((_, condition), _), true_stmt), false_parsed), _) = parsed
if false_parsed:
(_, false_stmt) = false_parsed
else:
false_stmt = None
return IfStatement(condition, true_stmt, false_stmt)
return keyword('if') + bexp() + \
keyword('then') + Lazy(stmt_list) + \
Opt(keyword('else') + Lazy(stmt_list)) + \
keyword('end') ^ process
```
Здесь сложность лишь в том, что пункт `else` необязательный. Это делает выполнение функции немного сложнее.
Наконец, у нас цикл `while`:
```
def while_stmt():
def process(parsed):
((((_, condition), _), body), _) = parsed
return WhileStatement(condition, body)
return keyword('while') + bexp() + \
keyword('do') + Lazy(stmt_list) + \
keyword('end') ^ process
```
Мы обернём это при помощи `stmt`:
```
def stmt():
return assign_stmt() | \
if_stmt() | \
while_stmt()
```
Вы можете заметить, что в обоих утверждения `if` и `while` использование `stmt_list` в теле лучше чем `stmt`. `stmt_list` в действительности является нашим верхним уровнем определения. Мы не можем иметь `stmt`, напрямую зависимый от `stmt_list`, так как это приведёт к левосторонней рекурсии парсера, и так как мы хотим иметь необязательные утверждения в телах `if` и `while`, мы напрямую используем `stmt_list`.
#### Собираем всё вместе
Теперь у нас есть парсер для каждой части языка. Нам нужно лишь сделать немного высокоуровневых определений:
```
def parser():
return Phrase(stmt_list())
```
`parser` будет разбирать всю программу. Программа — это всего лишь список утверждений, но комбинатор `Phrase` гарантирует, что мы используем каждый токен в файле раньше преждевременного окончания из за мусорных (неверных) токенов в конце.
```
def imp_parse(tokens):
ast = parser()(tokens, 0)
return ast
```
Функцию `imp_parse` клиент будет вызывать для разбора программы. Она принимает весь список токенов, вызывает parser, начинает с первого токена и возвращает результирующее Абстрактное Синтаксическое Дерево (AST).
Вот простая управляющая программа для проверки наших парсеров (в добавок к юнитестам):
```
import sys
from imp_parser import *
if __name__ == '__main__':
if len(sys.argv) != 3:
sys.stderr.write('usage: %s filename parsername' % sys.argv[0])
sys.exit(1)
filename = sys.argv[1]
file = open(filename)
characters = file.read()
file.close()
tokens = imp_lex(characters)
parser = globals()[sys.argv[2]]()
result = parser(tokens, 0)
print result
```
Эта программа читает файл (первый аргумент) и разбирает его каким либо парсером из **imp\_parse.py** (второй аргумент). Пример:
```
$ echo '1 + 2 * 3' >foo.imp
$ python imp_parser_driver.py foo.imp aexp
Result(BinopAexp(+, IntAexp(1), BinopAexp(*, IntAexp(2), IntAexp(3))), 5)
```
Это должно предоставить хорошую песочницу для экспериментов.
#### Заключение
В этой статье мы написали библиотеку комбинатор с нуля и использовали его для написания парсера для **IMP**. В следующей и последней из этой серии статье мы напишем исполнитель (*Прим. перев.*: не смог подобрать лучший перевод слова *evaluator*) для нашего разобранного Абстрактного Синтаксического Дерева (**AST**).
Автор оригинальной статьи — [Jay Conrod](http://www.jayconrod.com/posts/39/a-simple-interpreter-from-scratch-in-python-part-3)
**P.S.** Вижу проблемы с тегом Sub. Есть предположение, что новичку ещё рано пользоваться таким тегом. Чем его заменить — не знаю. Оставлю до выяснения решения. | https://habr.com/ru/post/208872/ | null | ru | null |
# TWAPT — пентестим по-белому в домашних условиях
> Чтобы поймать преступника, ты должен думать, как преступник, ты должен чувствовать, как преступник!
>
> Статья носит информационный характер. Не нарушайте законодательство.
>
>
Подобную фразу можно встретить во многих детективных фильмах или триллерах, где защитники правопорядка пытаются поймать неуловимого злодея. В эпоху Интернета теми самыми неуловимыми злодеями можно назвать киберпреступников (хакеров), которым для совершения преступлений не требуется показывать своего лица, и даже не обязательно находиться в одной стране с жертвой атаки, а все их действия могут остаться анонимными. Чтобы понять, как действует злоумышленник, нужно самому стать им. Однако, у Уголовного Кодекса РФ на это другие взгляды. В частности, [28 глава УК РФ](http://www.consultant.ru/document/cons_doc_LAW_10699/4398865e2a04f4d3cd99e389c6c5d62e684676f1/) регулирует преступления в сфере компьютерной информации. Как быть в этом случае специалисту по информационной безопасности, если нарушать законодательство - плохая идея, а понять как мыслит злоумышленник все же необходимо? На помощь приходят бесплатные площадки тестирования на проникновение, где любой желающий может попробовать свои силы в пентесте, прокачать собственные навыки и использовать полученные знания для повышения уровня защищенности своей компании. Есть 2 типа площадок:
* онлайн;
* оффлайн.
К онлайн относят довольно популярные ресурсы: [Test lab от Pentestit](https://lab.pentestit.ru/), [hackthebox](https://www.hackthebox.eu/), [pentesterlab](https://pentesterlab.com/), [Root me](https://root-me.org/) и многие другие. Все эти площадки довольно популярные и останавливаться на них мы не будем. Сегодня мы поговорим про оффлайн площадку TWAPT.
TWAPT
-----
[Домашняя страница](https://github.com/MoisesTapia/TWAPT)
Сам по себе проект задумывался как сборник нескольких оффлайн платформ для тестирования на проникновение.
Весь набор представлен в виде Docker-контейнеров, которые можно просто скачать и запустить за "пару кликов". Но перед этим необходимо установить (на примере Debian 10):
Docker
```
# apt update
# apt install apt-transport-https ca-certificates curl gnupg lsb-release
# curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
# echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/debian $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null
# apt update
# apt install docker-ce docker-ce-cli containerd.io
```
Docker-composer
```
# apt update
# curl -L "https://github.com/docker/compose/releases/download/1.29.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
# chmod +x /usr/local/bin/docker-compose
# docker-compose --version
```
Скачивание и запуск контейнеров происходит командами:
```
# git clone https://github.com/MoisesTapia/TWAPT
# cd TWAPT
# docker-compose up -d
```
Чтобы узнать какой порт заняло то или иное веб-приложение нужно выполнить команду:
```
# docker-compose ps
```
Вероятно, предполагалось, что от пользователя кроме запуска контейнера больше нчиего не потребуется, но в реальности некоторые контейнеры после запуска требуют дополнительных манипуляций. Например, после запуска контейнера с bWAPP требуется перейти по адресу **localhost:8082/install.php** и произвести установку БД для корректной работы, после этого можно продолжать пользоваться. А в случае с VulnWordpress нужно скрипт **start.sh** запустить самостоятельно внутри контейнера. Для этого необходимо:
* Узнать ID контейнера:
```
# docker ps -a
```
* Запустить оболочку контейнера:
```
# docker exec -ti /ID контейнера/ bash -c "/bin/bash"
```
* Самостоятельно выполнить script.sh.
После этого можно произвести установку WordPress.
### Состав набора
#### Mutillidae
[Mutillidae](https://github.com/webpwnized/mutillidae) - уязвимое веб-приложение, поддерживаемое организацией [OWASP](https://owasp.org/), которое включает в себя порядка 40 различных веб-уязвимостей, которые актуальны для OWASP Top Ten 2007, 2010, 2013 и [2017](https://wiki.owasp.org/?title=Special:Redirect/file/OWASP%20Top%2010-2017-ru.pdf). На сайте присутствуют подсказки для прохождения заданий, а если приложение стало некорректно работать, то можно кнопкой "Reset DB" сбросить настройки БД и восстановить работоспособность веб-приложения. Такая же функция есть почти у всех ресурсов, которые представлены ниже.
#### bWAPP
[bWAPP](http://www.itsecgames.com/) (buggy web application) - это бесплатное, намеренно небезопасное веб-приложение с открытым исходным кодом. Тоже охватывает все уязвимости, присутствующие в OWASP Top Ten.
Для каждой задачи можно установить уровни сложности, которые можно повышать. Например, выберем задачу с перебором пароля:
* уровень **Low**;
На первом уровне для перебора требуется только ввести логин и пароль.
* уровень **Medium**;
Уже сложнее, для каждого запроса используется собственный salt, который обновляется.
* уровень **High**.
Самый сложный вариант, когда для входа необходимо пройти капчу.
#### WebGoat
[WebGoat](https://owasp.org/www-project-webgoat/) - это заведомо небезопасное приложение, которое позволяет тестировать уязвимости, обычно обнаруживаемые в приложениях, написанные на Java и использующих популярные компоненты с открытым исходным кодом.
#### DVWAP
[DVWAP](https://dvwa.co.uk/) - уязвимое веб-приложение, написанное на PHP и использующее MySQL в качестве базы данных. Среди уязвимостей, которые представлены в веб-приложении, собраны множество типов инъекций, XSS, LFI/RFI, уязвимости капчи и т.д. Также присутствует 3 уровня сложности, но в отличие от того же bWAPP есть четвертый уровень - impossible, где невозможно проэксплуатировать уязвимость и разработчики дают краткое пояснение почему. После первого запуска контейнера необходимо нажать кнопку "Setup/Reset DB" для установки базы данных.
#### Bricks
[Bricks](https://sechow.com/bricks/index.html) - еще одно веб-приложение, написанное на PHP. Из набора уязвимостей, которые используются в составе платформы: различные уязвимости страницы аутентификации, формы загрузки файлов, а также SQL-инъекции. Из плюсов можно назвать подсказку по команде, которую для наглядности формирует и отправляет веб-приложение к базе данных. Поэтому можно смотреть какой запрос был отправлен, корректен ли он и как его можно изменить. В целом, набор заложенных уязвимостей немного уступает тем же bWAPP или DVWAP.
#### Juice-Shop
[Juice-Shop](https://github.com/bkimminich/juice-shop) - уязвимое веб-приложение, написанное на Node.js, Express и Angular и представляет из себя типичный пример интернет-магазина с 1-2 присущими ему уязвимостями, перечисленными в OWASP Top Ten, такими как Injection, XSS, Broken Authentication, Broken Access Control, Sensitive Data Exposure и т.д.
#### NinjaWeb
[NinjaWeb](https://hub.docker.com/r/opendns/security-ninjas), как и на всех предыдущих платформах, использует уязвимости, находщиеся в OWASP Top Ten. Приятным бонусом для данной платформы также стало наличие подсказок и полноценное прохождение задания в случае затруднений, не требующее от пользователя искать прохождение на сторонних ресурсах.
#### VulnWordPress
[VulnWordPress](https://hub.docker.com/r/hackerjohn/vulnwordpress) - чистый CMS WordPress, где можно установить уязвимый компонент и проверить наличие уязвимости.
Тестирование WAF
----------------
Заведомо уязвимые веб-приложения хороши еще и тем, что на их примере можно оценить работу средств защиты, например, WAF. Достаточно на локальном сервере развернуть платформу, а в случае с Docker-контейнером это сделать достаточно просто, и настроить работу WAF на уязвимое веб-приложение. Теперь мы не просто изучаем как эксплуатируются веб-уязвимости, но и пробуем обойти средства защиты, чтобы еще больше приблизиться к реальным условиям, с которыми сталкивается злоумышленник при атаках.
Попробуем протестировать веб-приложение DVWAP, защитив его с помощью [Nemesida WAF Free](https://waf.pentestit.ru/about/2511) (бесплатная версия), который обеспечивает защиту на основе сигнатурного анализа. Для сегодняшнего тестирования этого будет достаточно. Но у сигнатурного анализа, несмотря на все его преимущества, есть недостатки, например, база сигнатур находится в открытом [доступе](https://rlinfo.nemesida-security.com/) и злоумышленник, используя ее, может составить запрос, который позволит обойти защиту. Тем не менее, если база сигнатур составлена качественно, то и уровень защиты веб-приложения будет высоким.
Итак, протестируем один из самых популярных классов уязвимостей согласно OWASP Top Ten - инъекции.
**Command injection**
Пробуем подставить команду в поле для проверки доступности сервера:
```
127.0.0.1; ls /
```
От данной атаки Nemesida WAF Free не смог защитить. Тогда попробуем прочитать файл **/etc/passwd**.
```
2021/04/13 10:57:23 [error] 6261#6261: *11 Nemesida WAF: the request 8c137c6199bfdb63851c0c7b15468897 blocked by rule ID 1559 in zone BODY, client: 192.168.0.135, server: dvwa.site.lan, request: "POST /vulnerabilities/exec/ HTTP/1.1", host: "dvwa.site.lan", referrer: "http://dvwa.site.lan/vulnerabilities/exec/"
```
В **error.log** видим блокировку по правилу 1559. Обращаемся к базе [сигнатур](https://rlinfo.nemesida-security.com/) и смотрим сигнатуру, по которой был заблокирован запрос:
В первом случае запрос не был заблокирован, но это сделано для того, чтобы веб-приложение могло нормально функционировать т.к. в противном случае любой URL будет блокироваться из-за знака "**/**". Во втором случае на основе сигнатур запрос был заблокирован.
Попробуем обойти блокировку, для этого воспользуемся инструментом [Commix](https://habr.com/ru/post/550252/).
```
# python commix.py -u http://dvwa.site.lan/vulnerabilities/exec/ -d "ip=127.0.0.1&Submit=Submit" -p "ip"
```
В результате все атаки были заблокированы.
**SQLi**
Теперь тестируем более известный вид инъекций, защитив уязвимое веб-приложение Nemesida WAF Free.
```
# sqlmap -u 'http://dvwa.site.lan/vulnerabilities/sqli/?id=1*&Submit=Submit' --dbs --random-agent
```
Все попытки эксплуатации уязвимости заблокированы:
Попробуем добавить скрипты для обфускации пейлоадов, доступные в SQLmap. Но это не принесло результатов:
**XSS**
Последними в списке будут не менее популярные XSS. Для тестирования воспользуемся инструментом [XSStrike](https://defcon.ru/web-security/12387/):
```
# python3 xsstrike.py -u 'http://dvwa.site.lan/vulnerabilities/xss_r/?name='
```
В стандартной конфигурации Nemesida WAF Free заблокировал все атаки:
Вывод
-----
TWAPT однозначно отличная площадка для проверки и оттачивания навыков в области практической информационной безопасности, которая позволяет специалисту тренироваться и развиваться не нарушая законодательство. К тому же, метод защиты заведомо уязвимых стендов для проверки работы WAF, пожалуй, один из лучших способов его тестирования и при грамотном составлении базы сигнатур вероятность эксплуатации уязвимостей заметно сокращается. Методы атак веб-приложений и обхода средств защиты с каждым днем развиваются. Так или иначе, когда-нибудь сигнатурный анализ уже будет не так эффективен как сейчас. Однако, в [Nemesida WAF](https://waf.pentestit.ru) используется модуль машинного обучения Nemesida AI, который за счет использования поведенческих моделей, построенных на основе запросов к конкретному веб-приложению, позволяет значительно повысить точность выявления атак с минимальным количеством ложных срабатываний. Также реализован механизм выявления ботов, смс-флуда, защиты от атак методом пебора паролей | https://habr.com/ru/post/551978/ | null | ru | null |
# Новый вид mozilla vlc plugin
При реализации одного из проектов столкнулся с небольшой задачей, а именно встраивание на страницу сайта vlc плеера при этом плеер должен поддерживать возможность стилизации и воспроизведение рекламного ролика перед проигрыванием основного медиафайла или потока.
Так как ранее уже доводилось встраивать vlc на страницу сайта (воспроизведение с камер), сразу же отправился на страницу вики проекта vlc. Детальное изучение, которой показало, что стандартными методами это реализуемо, но готовых решений не представлено. Помня, что «лень двигатель прогресса» отправился в google искать варианты встраивания плеера. Потратив несколько часов, пришёл к выводу, что существующих реализаций совсем не много и большинстве своем берут начало от разработанного Julien Bouquillon плагина «VLCcontrols». Одна проблема — данный плагин обновлялся последний раз в 2010 году.
Ну, раз нет готовых решений, значит, будем писать свою обертку для плагина. Произведя запасы бумаги для заметок, кофе и сигарет, засел за изучение найденного плагина и составления плана работ.
##### Что необходимо было сделать
* Разработать интерфейс плеера с возможность легко его изменить.
* Реализовать базовых функций плеера (воспроизведение, стоп, пауза, регулирование звука, полноэкранный режим).
* Написать функционал, позволяющий показать рекламу, которая не блокировалась бы AdBlock.
* Реализовать поддержку дополнительных методов, которые поддерживаются mozilla vlc plugin.
* Максимально упростить интеграцию на страницу.
* Поддержка различными браузерами.
Закончив с подготовительной работой, сперва решил все же переделать плагин «VLCcontrols». О том, что я глубоко ошибся в выборе, до меня дошло уже после переделки. Некоторые функции работали не так, как мне было нужно, ну а другие вообще переставали работать при вроде бы обычных действиях. Ну ладно, на ошибках учатся, буду писать все с нуля.
Сказано-сделано, первая версия была написана быстрее, чем переделывался плагин. Потом были еще версии, в которых добавлялись другие функции, но ломались уже реализованные. В конечном итоге появилась стабильная версия с поддержкой большинства функционала vlc plugina, заказчик принял работу, но добавил еще по реализации дополнительных функций.
##### Что же реализовано в данной обертке?
* Автоматическое воспроизведение сразу после загрузки плагина.
* Демонстрация рекламного ролика с возможностью настройки времени демонстрации(AdBlock не блокирует)
* Возможность менять вид плеера изменив css файл.
* Поддержка всех базовых функций плеера
* Изменение соотношения сторон, чересстрочности, аудиоканалов
* 2 вида полноэкранного режима (стандартный и через HTML5 Fullscreen API)
* Включение режима, при котором на плеер, возможно, накладывать различные эффекты css
* Воспроизведение видеофайла из куков или из указанного параметра
Работает все это очень просто.
Подключаем скрипт к сайту и просто вызываем плеер, передавая ему параметры:
```
hPlayer.init();
```
Приведу основной список параметров, которые воспринимает обертка:
```
wrapper — Принимает id DOM контейнера, в который необходимо загрузить плеер.
* ID элемента — Плеер будет загружен в указанный DOM контейнер.
* NULL(не задано значение) — Плеер будет загружен в контейнер по умолчанию(id=»hPlayer»).
mode — Указание какой из плагинов инициализировать для дальнейшего проигрывания контента.
* http — загрузка vlc плагина.
* NULL(не задано значение) — загрузка оболочки без инициализации плагина.
stream — Поток видео данных, который необходимо воспроизвести в плеере.
* ‘Поток данных’ — после загрузки всех настроек и инициализации плеера будет запущено проигрывание указанного потока.
* NULL(не задано значение) — загрузка оболочки и инициализация плагина.
windowless
* true — включение облегченного режима воспроизведения плагином. Активирует возможности манипуляций с плагином средствами CSS. Не стабильная функция. При использовании переключение в полноэкранный режим реализовано при помощи Fullscreen API.
* NULL(не задано значение) — наследование установленных ранее настроек (по умолчанию «false»).
ad_state
* true — активирует показ рекламного видеоролика перед воспроизведением основного медиафайла.
* NULL(не задано значение) — наследование установленных ранее настроек (по умолчанию «false»).
ad_link
* ‘http://site.com/adsvideo.avi’ — ссылка на медиафайл который будет транслироваться при активации ad_state.
* NULL(не задано значение) — наследование установленных ранее настроек (по умолчанию «пусто»).
ad_time
* ‘время в миллисекундах’ — указание длительности показа рекламного медиафайла.
* NULL(не задано значение) — наследование установленных ранее настроек (по умолчанию «10000 мс/10 секунд»).
```
##### Примеры
Обычный запуск с передачей параметров.
```
hPlayer.init({
wrapper: 'hPlayer',
autoplay: true,
loop: true,
windowless: true,
stream: 'http://site.com.ua/mainvideo.avi',
mode: 'http'
});
```
Воспроизведение рекламы перед проигрыванием основного файла.
```
hPlayer.init({
wrapper: 'hPlayer',
stream: 'http://site.com.ua/mainvideo.avi',
autoplay: true,
loop: true,
mode: 'http',
ad_state:true,
ad_link: 'http://site.com.ua/videofile.flv',
ad_time: 10000
});
```
Забрать и пользоваться можно на гитхабе: [github.com/zpvs/hplayer](https://github.com/zpvs/hplayer)
[Демо](http://hplayer.hmscript.net) || [Все ключи для запуска](http://hmscript.net/portfolio/hplayer/)
При разработке использованы материалы:
Плагин Julien Bouquillon [VLCcontrols](http://blog.revolunet.com/VLCcontrols/)
Документация с [wiki VideoLAN](http://wiki.videolan.org/Documentation:WebPlugin)
UPD
На форуме vlc, после размещения получил вот такое интересное сообщение от Jean-Baptiste Kempf
> OMG thanks a LOT.
>
>
>
> Can we use that as an official webplugin?
>
> | https://habr.com/ru/post/188232/ | null | ru | null |
# UI-пасьянс: делаем свой StackView в Android
В этой статье мы хотим поделиться опытом создания кастомного ViewGroup в Android, который мы разработали в рамках одного из проектов Программы «Единая фронтальная система». Перед нами стояла задача создать красивую галерею банковских карт. При этом обычный список, который предоставляет RecyclerView и LinearLayoutManager, не подходил. Была задумка показать нестандартную механику скролла карт, чтобы при переходе карты не уходили полностью за пределы экрана, а собирались в стопку. О том, как мы это сделали, читайте под катом.
В предыстории скажем, что наш первый вариант был тривиальным – использовать готовое решение. Например в Android уже давно есть похожий контрол [StackView](https://developer.android.com/reference/android/widget/StackView.html). Код приводить не будем, он достаточно простой, ищем в Activity StackView, сетим в него адаптер, который отдает View наших карт. Смотрим, что получается. Карты расположены по диагонали, плюс анимация какая-то странная. Совсем не то, что хотелось бы. В кастомизации этого класса разбираться долго, так что попробуем сами.
Механика списка
---------------
Методом проб и ошибок мы пришли к механике, где карты отображаются в похожем на список виде. При этом карты, которые не видны в обычном списке, когда уходят за его пределы, у нас складываются в стопку. Здесь важно ограничить использование памяти, точнее, держать в памяти не все дочерние View, а минимальное, желательно, постоянное количество.
Для простоты опишем механику стопки сверху при скролле вверх. Стопка снизу будет работать примерно так же — только карты будут подсовываться под нее, а не наезжать. Красная линия на рисунке показывает, где проходит граница начала стопки.
Для последующей работы введем обозначения:
* foldHeight — высота области для стопки;
* maxCardCountInFold — максимальное возможное количество карт в стопке, в нашем примере оно равно трем;
* cardFoldHeight = foldHeight / maxCardCountInFold — высота карты в стопке.
Состояния списка
----------------
1. На экране целые карты. Одна за другой. Все как в обычном списке.
2. Начинаем скроллить вверх. Синяя карта начинает наезжать на зеленую карту. Останавливается в положении, когда видимая часть зеленой карты становится равной cardFoldHeight. Сейчас есть одна карта в стопке.
3. Продолжаем скроллить вверх. Первые две карты не двигаются. Розовая карта надвигается на синюю. Останавливается в положении, когда видимая часть синей карты, лежащей под ней, становится равна cardFoldHeight. Теперь в стопке две карты.
4. Скроллим дальше. Только теперь видимая часть розовой карты становится равна cardFoldHeight. В этом состоянии в стопке три карты — максимально допустимое количество карт. Чтобы добавить в стопку новую карту, нужно вывести из нее первую добавленную карту. Строго говоря, стопка работает по принципу FIFO: первый вошел — первый пошел.
В какой момент начинать двигать всю стопку, чтобы выкинуть за борт первую карту? Рассмотрим возможные варианты:
а) начинаем двигать стопку в момент, когда бирюзовая карта соприкоснулась с желтой картой;
б) начинаем двигать стопку в момент, когда бирюзовая карта уже наехала на желтую, а желтая имеет размер cardFoldHeight, точка A.
В обоих случаях стопка двигается при перемещении желтой карты от точки A до точки B. Когда бирюзовая карта попадает в положение B, синяя карта становится полностью не видна. В этом состоянии наш StackView освобождает память, занятую синей картой.
В нашей реализации мы выбрали второй вариант, так как визуально перемещение карт в этом случае выглядит более плавным.
Внутреннее устройство StackView
-------------------------------
Опишем кратко, из каких основных компонентов состоит наш кастомный ViewGroup, и как они взаимодействуют.
### Вспомогательные классы
```
// хранит в себе индексы карт, которые сейчас видны
class Range {
private int mFrom;
private int mTo;
}
```
```
//класс который вычисляет видимый диапазон карт в зависимости от текущего
//смещения карт currentScroll.
public class RangeCalculator {
public Range getVisibleRange(int currentScroll);
}
```
```
// рассчитывает параметры стопки в зависимости от текущего смещения
// карт — currentScroll.
class Fold {
public int minTop();
public int maxTop();
public void update(int currentScroll, int fullCardHeight);
}
```
### Теперь сам StackView
StackView является наследником ViewGroup. В нашем StackView в методе dispatchTouchEvent(MotionEvent event) с помощью наследника GestureDetector.SimpleOnGestureListener мы определяем, когда пользователь скроллит список и смещение currentScroll. От параметра currentScroll будет зависеть позиция карт в списке.
Основные методы класса StackView, которые определяют размеры и позиции дочерних View, это onMeasure() и onLayout(). Ниже приведен псевдокод этих методов.
```
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
measureChildren(widthMeasureSpec, heightMeasureSpec);
mFold.update(mCurrentScroll, mFullCardHeight);
final Range newRange = mRangeCalculator.getVisibleRange(mCurrentScroll);
if (getChildCount() == 0) {
addCards(newRange);
} else {
removeCards(newRange);
addNewCards(newRange);
}
mVisibleCardsRange.set(newRange);
}
}
```
```
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
final int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
final View child = getChildAt(i);
final int childLeft = getPaddingLeft();
final int childRight = childLeft + child.getMeasuredWidth();
final int childHeight = child.getMeasuredHeight();
final int childTop = getChildTop(childCount, i, childHeight);
final int childBottom = childTop + childHeight;
child.layout(childLeft, childTop, childRight, childBottom);
}
}
```
```
// вычисление childTop текущей карты
private int getChildTop(final int childCount, final int childIndex, int childHeight) {
int childTop = -mCurrentScroll + (childIndex + mVisibleCardsRange.from()) * childHeight + getPaddingTop();
int minTopForCurrentChild = (int) (childIndex * mFold.getCardSizeInFold()) - mFold.minTop();
minTopForCurrentChild = Math.max(0, minTopForCurrentChild);
int maxTopForCurrentChild = (int) (getMeasuredHeight() - (childCount - childIndex) * mFold.getCardSizeInFold()) + mFold.maxTop();
maxTopForCurrentChild = Math.min(maxTopForCurrentChild, getMeasuredHeight());
if (childTop < minTopForCurrentChild) childTop = minTopForCurrentChild;
if (childTop > maxTopForCurrentChild) childTop = maxTopForCurrentChild;
return childTop;
}
```
Что получилось и какие мы сделали выводы
----------------------------------------
Мы начинали создание этого кастомного ViewGroup компонента не с нуля, взяли за основу реализацию похожего списка. Но пришлось потратить время на изучение чужого кода и допиливание его до нужного нам состояния. В процессе мы сделали несколько вариантов реализации механики списка и в итоге выбрали тот, который выглядит красиво и за счет некоторых упрощений потребляет ограниченное количество памяти – в данном случае мы просто ограничиваем число карт в стопке.
На практике оказалось, что нет смысла показывать в стопке все карты. Если их слишком много, размер видимой части карты в стопке стремится к нулю, и красоты это не добавляет. У нас есть постоянное количество дочерних View, и нам не страшен серый волк OutOfMemoryException.
Можно считать, что с задачей построения прототипа мы справились. Определили вариант механики списка, который выглядит хорошо, а главное — технически реализуем. И теперь мы знаем, как его сделать лучше.
Будем рады пообщаться с вами и обменяться идеями по теме. Мы решили не выкладывать весь код в посте, а остановиться на основных принципах. Если у вас остались вопросы, пожалуйста, пишите в комментариях. | https://habr.com/ru/post/340998/ | null | ru | null |
# Dependency Injection, JavaScript и ES6-модули
Ещё одна имплементация [Dependency Injection в JavaScript](https://www.npmjs.com/search?q=Dependency%20Injection) — с ES6-модулями, с возможностью использовать один и тот же код в браузере, и в nodejs и не использовать транспиляторы.
Под катом — мой взгляд на DI, его место в современных web-приложениях, принципиальная реализация DI-контейнера, способного создавать объекты и на фронте, и на бэке, а также объяснение, при чём тут Майкл Джексон.
Очень сильно прошу тех, кому изложенное в статье покажется банальным, не насиловать себя и не читать до конца, чтобы потом, разочаровавшись, не ставить "минус". Я не против "минусов" — но только если минус сопровождается комментарием, что именно в публикации вызвало отрицательную реакцию. Это техническая статья, поэтому постарайтесь отнестись снисходительно к стилю изложения, а критиковать именно техническую составляющую изложенного. Спасибо.
Объекты в приложении
====================
Я очень уважаю функциональное программирование, но большую часть своей профессиональной деятельности я посвятил созданию приложений, состоящих из объектов. JavaScript мне импонирует тем, что функции в нём также являются объектами. При создании приложений я мыслю объектами, это моя профессиональная деформация.
По времени жизни объекты в приложении можно разделить на следующие категории:
* **постоянные** — возникают на каком-то этапе работы приложения и уничтожаются только при завершении приложения;
* **временные** — возникают при необходимости выполнения некоторой операции и уничтожаются при завершении выполнения этой операции;
В связи с этим в программировании есть такие шаблоны проектирования, как:
* [singleton](https://ru.wikipedia.org/wiki/%D0%9E%D0%B4%D0%B8%D0%BD%D0%BE%D1%87%D0%BA%D0%B0_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F));
* [abstract factory](https://ru.wikipedia.org/wiki/%D0%90%D0%B1%D1%81%D1%82%D1%80%D0%B0%D0%BA%D1%82%D0%BD%D0%B0%D1%8F_%D1%84%D0%B0%D0%B1%D1%80%D0%B8%D0%BA%D0%B0_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)), [builder](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D1%80%D0%BE%D0%B8%D1%82%D0%B5%D0%BB%D1%8C_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)), [pool](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%BD%D1%8B%D0%B9_%D0%BF%D1%83%D0%BB), ...
Т.е., с моей точки зрения, приложение состоит из постоянно-существующих одиночек, которые либо сами выполняют требуемые операции, либо для их выполнения порождают временные объекты.
Контейнер Объектов
==================
[Внедрение зависимостей](https://ru.wikipedia.org/wiki/%D0%92%D0%BD%D0%B5%D0%B4%D1%80%D0%B5%D0%BD%D0%B8%D0%B5_%D0%B7%D0%B0%D0%B2%D0%B8%D1%81%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D0%B8) — это подход, который облегчает создание объектов в приложении. Т.е., в приложении существует специальный объект, который "знает", каким образом создавать все остальные объекты. Такой объект называется Контейнер Объектов (иногда — Менеджер Объектов).
Контейнер Объектов не является [Божественным Объектом](https://ru.wikipedia.org/wiki/%D0%91%D0%BE%D0%B6%D0%B5%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82), т.к. его задачей является только создание значимых объектов приложения и предоставление доступа к ним другим объектам. Подавляющее большинство объектов приложения, будучи порождёнными Контейнером и размещаясь в нём, никакого представления о самом Контейнере не имеют. Их можно поместить в любую другую среду, снабдить необходимыми зависимостями и они будут также замечательно функционировать и там (тестировщики в курсе, о чём я).
Место внедрения
===============
По большому счёту есть [два способа](https://habr.com/ru/post/352530/) внедрить зависимости в объект:
* через конструктор;
* через свойство (или его акцессор);
Я, в основном, использовал первый подход, поэтому дальнейшее описание я буду вести с точки зрения внедрения зависимостей через конструктор.
Допустим, что у нас есть приложение, состоящее из трёх объектов:
В PHP (этот язык с давними традициями DI у меня в данный момент находится в активном багаже, к JS я перейду чуть позже) подобная ситуация могла бы быть отражена таким образом:
```
class Config
{
public function __construct()
{
}
}
class Service
{
private $config;
public function __construct(Config $config)
{
$this->config = $config;
}
}
class Application
{
private $config;
private $service;
public function __construct(Config $config, Service $service)
{
$this->config = $config;
$this->service = $service;
}
}
```
Этой информации должно хватать, чтобы DI-контейнер (например, [league/container](https://packagist.org/packages/league/container)) при соответствующей настройке смог по запросу на создание объекта `Application` также создать его зависимости `Service` и `Config` и передать их параметрами в конструктор объекта `Application`.
Идентификаторы зависимостей
===========================
Каким же образом Контейнер объектов понимает, что конструктору объекта `Application` требуются два объекта `Config` и `Service`? Путём анализа объекта через Reflection API ([Java](https://docs.oracle.com/javase/8/docs/api/index.html?java/lang/reflect/package-summary.html), [PHP](https://www.php.net/manual/ru/book.reflection.php)) или через анализ непосредственно кода объекта (аннотаций к коду). То есть, в общем случае, мы можем определить имена переменных, которые ожидает увидеть на входе конструктор объекта, а если язык типизируемый, то можем получить также и типы этих переменных.
Таким образом, в качестве идентификаторов объектов Контейнер может оперировать либо именами входных параметров конструктора, либо типами входных параметров.
Создание объектов
=================
Объект может быть в явном виде создан программистом и помещён в Контейнер под соответствующим идентификатором (например, "configuration")
```
/** @var \League\Container\Container $container */
$container->add("configuration", $config);
```
а может быть создан Контейнером по некоторым определённым правилам. Эти правила, по большому счёту, сводятся к сопоставлению идентификатора объекта его коду. Правила можно задавать явно (маппинг в виде кода, XML, JSON, ...)
```
[
["object_id_1", "/path/to/source1.php"],
["object_id_2", "/path/to/source2.php"],
...
]
```
или в виде некоторого алгоритма:
```
public function getSource($id)
{.
return "/path/to/source/${id}.php";
}
```
В PHP составление правил сопоставления имени класса файлу с его исходным кодом стандартизированы ([PSR-4](https://www.php-fig.org/psr/psr-4/)), в Java сопоставление идёт на уровне конфигурации JVM ([class loader](https://en.wikipedia.org/wiki/Java_Classloader)). Если Контейнер предусматривает автоматический поиск исходников при создании объектов, то имена классов являются достаточно хорошими идентификаторами для объектов в таком Контейнере.
Namespaces
==========
Обычно в проекте, помимо собственного кода, используются также сторонние модули. С появлением менеджеров зависимостей (maven, composer, npm) использование модулей очень сильно упростилось, а количество модулей в проектах очень сильно увеличилось. Пространства имён позволяют существовать в едином проекте одноимённым элементам кода из различных модулей (классы, функции, константы).
Есть языки, в которых пространство имён встроено изначально (Java):
```
package vendor.project.module.folder;
```
есть языки, в которых пространство имён добавлено в ходе развития языка (PHP):
```
namespace Vendor\Project\Module\Folder;
```
Хорошая реализация пространства имён позволяет однозначно адресовать любой элемент кода:
```
\Doctrine\Common\Annotations\Annotation\Attribute::$name
```
Пространство имён решает задачу по упорядочиванию множества программных элементов в проекте, а файловая структура решает задачу по упорядочиванию файлов на диске. Поэтому между ними не просто много общего, а иногда и очень много — в Java, например, публичный класс в пространстве имён однозначно должен быть привязан к файлу с кодом этого класса.
Таким образом, использование в Контейнере в качестве идентификаторов объектов идентификатора класса объекта в пространстве имён проекта является хорошей идеей и может служить основой для создания правил по автоматическому обнаружению исходных кодов при создании требуемого объекта.
```
$container->add(\Vendor\Project\Module\ObjectType::class, $obj);
```
Автозагрузка кода
=================
В PHP `composer` пространство имён модуля маппится на файловую систему внутри модуля в дескрипторе модуля `composer.json`:
```
"autoload": {
"psr-4": { "Doctrine\\Common\\Annotations\\": "lib/Doctrine/Common/Annotations" }
}
```
JS-сообщество могло бы делать аналогичный маппинг в `package.json`, если бы в JS были пространства имён.
Идентификаторы зависимостей в JS
================================
Выше я обозначил, что в качестве идентификаторов Контейнер может использовать либо имена входных параметров конструктора, либо типы входных параметров. Проблема в том, что:
1. JS — язык с динамической типизацией и не предусматривает указание типов при объявлении функции.
2. В JS используются минификаторы, которые могут переименовывать входные параметры.
Разработчики DI-контейнера [awilix](https://www.npmjs.com/package/awilix) предлагают использовать объект в качестве единственного входного параметра конструктора, а в качестве зависимостей — свойства этого объекта:
```
class UserController {
constructor(opts) {
this.userService = opts.userService
}
}
```
[Идентификатор](https://www.w3schools.com/js/js_syntax.asp) свойства объекта в JS может состоять из буквенно-цифровых символов, "\_" и "$", причем не может начинаться с цифры.
Так как нам для автозагрузки нужно будет мапить идентификаторы зависимостей на путь к их исходникам в файловой системе, то лучше отказаться от использования "$" и воспользоваться опытом PHP. До появления оператора `namespace` в некоторых framework'ах (например, в Zend 1) использовали такие наименования для классов:
```
class Zend_Config_Writer_Json {...}
```
Таким образом, мы могли бы отразить наше приложение из трёх объектов (`Application`, `Config`, `Service`) на JS как-то так:
```
class Vendor_Project_Config {
constructor() {
}
}
class Vendor_Project_Service {
constructor({Vendor_Project_Config}) {
this.config = Vendor_Project_Config;
}
}
class Vendor_Project_Application {
constructor({Vendor_Project_Config, Vendor_Project_Service}) {
this.config = Vendor_Project_Config;
this.service = Vendor_Project_Service;
}
}
```
Если мы размещаем код каждого класса:
```
export default class Vendor_Project_Application {
constructor({Vendor_Project_Config, Vendor_Project_Service}) {
this.config = Vendor_Project_Config;
this.service = Vendor_Project_Service;
}
}
```
в своём файле внутри модуля нашего проекта:
* `./src/`
+ `./Application.js`
+ `./Config.js`
+ `./Service.js`
То мы можем связать корневой каталог модуля с корневым "namespace'ом" модуля в конфигурации Контейнера:
```
const ns = "Vendor_Project";
const path = path.join(module_root, "src");
container.addSourceMapping(ns, path);
```
а затем, отталкиваясь от этой информации, конструировать на основании идентификатора зависимости (`Vendor_Project_Config`) путь к соответствующим исходникам (`${module_root}/src/Config.js`).
ES6 Модули
==========
ES6 [предлагает](https://frontender.info/es6-modules/) общую конструкцию для загрузки ES6-модулей:
```
import { something } from 'path/to/source/with/something';
```
Так как нам нужно один объект (класс) привязывать к одному файлу, то есть смысл в исходнике экспортировать этот класс по-умолчанию:
```
export default class Vendor_Project_Path_To_Source_With_Something {...}
```
В принципе, можно не писать такое длинное имя для класса, достаточно просто `Something` и тоже будет работать, но в Zend 1 писали и не переломились, а уникальность имени класса в пределах проекта положительно сказывается как на возможностях IDE (autocomplete и контекстные подсказки), так и при отладке:
Импорт класса и создание объекта в таком случае выглядит так:
```
import Something from 'path/to/source/with/something';
const something = new Something();
```
Front & Back импорт
===================
Импорт работает как в браузере, так и в nodejs, но есть нюансы. Например, браузер не понимает импорта nodejs-модулей:
```
import path from "path";
```
В браузере получаем ошибку:
```
Failed to resolve module specifier "path". Relative references must start with either "/", "./", or "../".
```
То есть, если мы хотим, чтобы наш код работал **и** в браузере, **и** в nodejs, мы не можем использовать конструкции которые не понимает браузер **или** nodejs. Я специально акцентирую на этом внимание, потому что такой вывод слишком естественен, чтобы о нём думать. Как дышать.
Место DI в современных web-приложениях
======================================
Это сугубо моё личное мнение, обусловленное моим персональным опытом, как и всё остальное в этой публикации.
В web-приложениях JS практически безальтернативно занимает своё место на фронте, в браузере. На серверной стороне плотно окопались Java, PHP, .Net, Ruby, python,… Но с появлением nodejs JavaScript также проник и на сервер. А технологии, используемые в других языках, в том числе и DI, начали проникать в серверный JS.
Развитие JavaScript обусловлено асинхроностью работы кода в браузере. Асинхронность не является исключительной особенностью JS, скорее врождённой. Сейчас наличие JS и на сервере, и на фронте уже никого не удивляет, а скорее, стимулирует к использованию одних и тех же подходов на обоих "концах" web-приложения. И одного и того же кода. Разумеется, что фронт и бэк слишком различаются по своей сути и по решаемым задачам, чтобы использовать один и тот же код и там, и там. Но можно предположить, что в более-менее сложном приложении будет код браузерный, серверный и общий.
DI уже сейчас используется на фронте, в [RequireJS](https://requirejs.org/):
```
define(
["./config", "./service"],
function App(Config, Service) {}
);
```
Правда тут идентификаторы зависимостей прописываются в явном виде и сразу в виде ссылок на исходники (можно настроить маппинг идентификаторов в конфиге загрузчика).
В современных web-приложениях DI существует не только на серверной стороне, но и в браузере.
При чём тут Майкл Джексон?
==========================
При [включении](https://nodejs.org/api/esm.html#esm_enabling) поддержки ES-модулей в nodejs (флаг `--experimental-modules`) движок идентифицирует содержимое файлов с расширением `*.mjs` как EcmaScript-модули (в отличие от [Common-модулей](https://nodejs.org/api/esm.html#esm_package_scope_and_file_extensions) с расширением `*.cjs`).
Иногда такой подход называют "[Michael Jackson Solution](https://anasshekhamis.com/2017/09/14/es6-modules-arrived-to-node-js/)", а скрипты — Michael Jackson Scripts (`*.mjs`).
Согласен, что так себе интрига с КДПВ разрешилась, но… [камон ребят, Майкл Джексон...](https://www.youtube.com/watch?v=FZzsb4Q4Pfs)
Yet Another DI Implementation
=============================
Ну и как полагается, собственный ~~велосипед~~ DI-модуль — [@teqfw/di](https://github.com/teqfw/di/tree/0.1.1#teqfwdi)
Это не готовое "к бою" решение, а скорее принципиальная реализация. Все зависимости должны представлять из себя ES-модули и использовать общие для браузера и nodejs возможности.
Для разрешения зависимостей в модуле применяется подход [awilix](https://www.npmjs.com/package/awilix):
```
constructor(spec) {
/** @type {Vendor_Module_Config} */
const _config = spec.Vendor_Module_Config;
/** @type {Vendor_Module_Service} */
const _service = spec.Vendor_Module_Service;
}
```
Для запуска back-примера:
```
import Container from "./src/Container.mjs";
const container = new Container();
container.addSourceMapping("Vendor_Module", "../example");
container.get("Vendor_Module_App")
.then((app) => {
app.run();
});
```
на сервере:
```
$ node --experimental-modules main.mjs
```
Для запуска front-примера (`example.html`):
```
DI in Browser
Load main script './main.mjs', create new DI container, then get object by ID from container.
Open browser console to see output.
```
нужно выложить модуль на сервер и открыть страницу `example.html` в браузере (или воспользоваться возможностями IDE). Если открывать `example.html` напрямую, то в Chrom'е ошибка:
```
Access to script at 'file:///home/alex/work/teqfw.di/main.mjs' from origin 'null' has been blocked by CORS policy: Cross origin requests are only supported for protocol schemes: http, data, chrome, chrome-extension, https.
```
Если всё прошло удачно, то в консоли (браузера или nodejs) будет примерно такой вывод:
```
Create object with ID 'Vendor_Module_App'.
Create object with ID 'Vendor_Module_Config'.
There is no dependency with id 'Vendor_Module_Config' yet.
'Vendor_Module_Config' instance is created.
Create object with ID 'Vendor_Module_Service'.
There is no dependency with id 'Vendor_Module_Service' yet.
'Vendor_Module_Service' instance is created (deps: [Vendor_Module_Config]).
'Vendor_Module_App' instance is created (deps: [Vendor_Module_Config, Vendor_Module_Service]).
Application 'Vendor_Module_Config' is running.
```
Резюме
======
[AMD, CommonJS, UMD?](https://www.davidbcalhoun.com/2014/what-is-amd-commonjs-and-umd/)
[ESM](https://nodejs.org/api/esm.html)! | https://habr.com/ru/post/464347/ | null | ru | null |
# Flash 10.1 стресс тест, где скорость?
После выхода 10.1 pre-release версии решил потестить её на drawTriangles()
Написано приложение, которое в 800x600 рисует 2700 крутящихся текстурированных треугольников (текстура 32х32 random perlin noise)
Скомпилировано под flash 10.0 и flash 10.1.
Компилировалось под flex builder 3, playerglobal.swc под 10.1 взят с официальной страницы <http://labs.adobe.com/downloads/flashplayer10.html>
Драйвера на видео поставлены из поста <http://habrahabr.ru/blogs/adobe/75532/>
Система Core i7 920 + gtx295
[www.rexxar.ru/stress10](http://www.rexxar.ru/stress10/) (сборка под 10.0.ххх)
flash 10.0 — в среднем 22 fps (debug) / 25 fps (release)
flash 10.1 — в среднем 36 fps
[www.rexxar.ru/stress101](http://www.rexxar.ru/stress101/) (сборка под 10.1.ххх)
flash 10.0 — понятно не работает, нужен 10.1
flash 10.1 — в среднем 36 fps
Кстати, в 10.1 версии под opera/firefox на пустом клипе fps режется до 120, хотя во флеше прописано 200. В 10.0 такого нет.
Исходники обоих приложений — [www.rexxar.ru/data/stress.zip](http://www.rexxar.ru/data/stress.zip)
Ну и здесь выложу, там всего два класса.
Главный:
> `package {
>
> import flash.display.Sprite;
>
>
>
> [SWF(frameRate="200", width="800", height="600")]
>
>
>
> public class stress101 extends Sprite
>
> {
>
> private static const NUM\_COLS : int = 60;
>
> private static const NUM\_ROWS : int = 45;
>
>
>
> private var canvas : Sprite = new Sprite();
>
>
>
> public function stress101()
>
> {
>
> canvas.graphics.beginFill(0xDDDDFF);
>
> canvas.graphics.drawRect(0, 0, stage.stageWidth, stage.stageHeight);
>
> canvas.graphics.endFill();
>
>
>
> addChild(canvas);
>
> addChild(new FPSCounter());
>
>
>
> drawTriangles();
>
> }
>
>
>
> private function drawTriangles() : void
>
> {
>
> const dx : Number = canvas.width / NUM\_COLS;
>
> const dy : Number = canvas.height / NUM\_ROWS;
>
>
>
> const size : Number = 0.5 \* (dx > dy ? dx : dy);
>
>
>
> var cy : Number = 0.5 \* dy;
>
> for(var row : int = 0; row < NUM\_ROWS; row++, cy += dy)
>
> {
>
> var cx : Number = 0.5 \* dx;
>
> for(var col : int = 0; col < NUM\_COLS; col++, cx += dx)
>
> {
>
> var triangle : Triangle = new Triangle(size);
>
> triangle.x = cx;
>
> triangle.y = cy;
>
> canvas.addChild(triangle);
>
> }
>
> }
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Triangle:
> `package
>
> {
>
> import flash.display.BitmapData;
>
> import flash.display.Shape;
>
> import flash.events.Event;
>
>
>
> public class Triangle extends Shape
>
> {
>
> private static const TEXTURE\_WIDTH : int = 32;
>
> private static const TEXTURE\_HEIGHT : int = 32;
>
>
>
> public function Triangle(size : Number)
>
> {
>
> super();
>
>
>
> var bitmapData : BitmapData = new BitmapData(TEXTURE\_WIDTH, TEXTURE\_HEIGHT, false);
>
> bitmapData.perlinNoise(TEXTURE\_WIDTH, TEXTURE\_HEIGHT, 6, Math.random() \* int.MAX\_VALUE, false, true);
>
>
>
> graphics.beginBitmapFill(bitmapData, null, false, true);
>
> graphics.drawTriangles(
>
> Vector.([
>
> 0, -size,
>
> size, size,
>
> -size, size,
>
> ]),
>
> Vector.<int>([
>
> 0, 1, 2,
>
> ]),
>
> Vector.([
>
> 0.5, 0.0, 0.5,
>
> 1.0, 1.0, 0.5,
>
> 0.0, 1.0, 0.5,
>
> ])
>
> );
>
> graphics.endFill();
>
>
>
> addEventListener(Event.ENTER\_FRAME, onEnterFrame);
>
> }
>
>
>
> private function onEnterFrame(event : Event) : void
>
> {
>
> rotation += 1.0;
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Так вот — или я что-то делаю не так или одно их двух. Настойчивое гугление не дало никаких зацепок.
Конечно приятно повышение производительности в ~1.6 раза, но ёлки-палки, 36fps на 2700 треугольников это уровень 3dfx Voodoo.
Ещё для теста можно сходить на <http://www.rexxar.ru/3d/> (flash player 10.0.xx required)
Для начала ткнуть во флешку, а то всё забываю фокус на неё переставить, без этого клавиши работать не будут. И дальше:
key 1 — beginFill + moveTo/lineTo
key 2 — beginBitmapFill + moveTo/lineTo
key 3 — beginBitmapFill + drawTriangles
key 4 — beginShaderFill (3-point bilinear gradient) + drawTriangles
key 5 — beginBitmapFill (3-point bilinear gradient emulation with 2x2 texture) + drawTriangles
keys w+s+a+d — смена кол-ва треугольников по осям
Сейчас сам потестил — всё как было (
Робкие надежды на то, что pixel-bender шейдер как-нибудь скомпилируется, заработает под CUDA и позволит рисовать вообще ВСЁ, накрылись либо моим неумением либо медным тазом.
Грустно всё.
p.s.
Объяснение картинки в заглавии:
первая — flash player 10.0, 3-point gradient shader, треугольники набраны до ~32fps, полная — <http://www.rexxar.ru/img/flash100.jpg>
вторая — flash player 10.1, 3-point gradient shader, треугольники набраны до ~32fps, полная — <http://www.rexxar.ru/img/flash101.jpg>
Использование ядер очень странное.
Сначала 5, чуть больше треугольников — 8, возвращаешься назад — 4, снова больше — 6. | https://habr.com/ru/post/75584/ | null | ru | null |
# Низкоуровневая оптимизация кода на платформе Эльбрус: векторное сложение uint16_t с помощью интринсиков
В этой статье мы расскажем про более низкоуровневые оптимизации, которые можно делать на процессорах Эльбрус.
*В принципе, оптимизации подобного уровня не являются необходимым этапом разработки под Эльбрус. Для большинства вычислительных операций, требующих высокой производительности, можно и нужно использовать функции из библиотеки EML.*
Однако в текущей версии EML мы не нашли некоторых интересных нам функций, поэтому приняли решение написать их сами.
Для этого мы использовали интринсики. Интринсики – конструкции, выглядящие для программиста как обычные функции, но их вызовы заменяются компилятором “по месту” на высокоэффективный код. Чаще всего интринсики нужны, когда хочется использовать векторные расширения процессора, позволяющие выполнять одну и ту же операцию над регистром, содержащим сразу несколько элементов данных. Даже оптимизирующий компилятор не всегда может угадать, что такая конструкция ускорит ваш код. В таких случаях раньше, если не было подходящей оптимизированной библиотеки, приходилось использовать ассемблер. Но быстродействие ассемблерного кода существенно зависит от эффективности использования регистров, учета задержек АЛУ и прочих чудесных вещей. А Эльбрус еще и имеет VLIW-архитектуру, а значит, если мы хотим писать на ассемблере, нам предстоит самостоятельно следить за формированием широких командных слов. С другой стороны, для подобных тонкостей и создаются оптимизирующие компиляторы. Переход на интринсики позволяет разумно распределить работу между человеком и программой. Код, использующий интринсики, можно без проблем переносить между системами, поддерживающими все задействованные интринсики. То есть в нашей ситуации интринсики очевидно являются оптимальным решением.
Микропроцессоры Эльбрус-4С и Эльбрус-8С поддерживают векторные операции с регистром размера 64 бита. С помощью такого регистра можно одновременно обработать два 32-битных числа, четыре 16-битных целых числа или восемь 8-битных целых чисел. Набор интринсиков микропроцессора Эльбрус включает в себя операции для преобразования данных, инициализации элементов вектора, арифметических операций, побитовых логических операций, перестановки элементов вектора и, как нам показалось, достаточно похож на набор инструкций SSE/SSE2 процессоров x86.
Итак, приступим к оптимизации. Возьмем кусочек кода для сложения двух массивов типа uint16\_t с записью результата в третий массив (такой операции в EML пока нет):
```
// Вариант 0
// eml_16u *src1 - указатель на первый аргумент суммы массивов
// eml_16u *src2 - указатель на второй аргумент суммы массивов
// eml_16u *dst - указатель на результирующий массив
// len - длина массивов
for (size_t i = 0; i < len; ++i)
dst[i] = src1[i] + src2[i];
```
Теперь перепишем его с использованием интринсиков. Для простоты будем считать, что длина массивов `len` делится на 4, а остающиеся элементы массивов обрабатываются отдельно. Тогда получится примерно так:
```
// Вариант 1
// eml_16u *src1 - указатель на первый аргумент суммы массивов
// eml_16u *src2 - указатель на второй аргумент суммы массивов
// eml_16u *dst - указатель на результирующий массив
// len - длина массивов
static const size_t block_size = sizeof(eml_64u) / sizeof(eml_16u);
for (size_t i = 0; i < len; i += block_size, src1 += block_size, src2 +=
block_size, dst += block_size)
*(__di*)dst = __builtin_e2k_paddh(*(__di*)src1, *(__di*)src2);
```
Здесь `__di` – 64-битный тип данных, а `__builtin_e2k_paddh` – интринсик, осуществляющий 16-битное беззнаковое сложение.
Однако этот код неоптимален, поскольку для загрузки невыровненного 64-битного числа `r` по адресу `p` процессору необходимо осуществить следующие элементарные операции:
1. Определить смещение `s` адреса `p` от границы выравнивания на 64-бита (см. Рис. 1). Адрес выровненного 64-битного числа, содержащего начало `r` будет равен `p - s`. Адрес следующего за ним выровненного 64-битного числа, содержащего конец `r`, будет равен `p - s + 8`.
2. Загрузить из памяти 2 64-битных числа r1, r2, содержащих `r`, по выровненным адресам.
3. Найти число `r`, зная r1, r2, `s`.
*Рис. 1. Схема невыровненной загрузки 64-битных данных из памяти.*
Для дальнейшей оптимизации запишем это в явном виде, используя макросы Эльбруса:
```
__di s = E2K_BYTES_FROM_ALIGN(p, 8);
__di tmp;
E2K_PREPARE_ALIGN(s, tmp);
const __di *p_aligned = (__di *)E2K_ALIGN_PTR_BACK(p, 8);
__di r1 = *p_aligned;
__di r2 = *(p_aligned + 1);
__di r;
E2K_ALIGN_DATA(r1, r2, r, tmp);
```
Такой код будет выполнять по 6 обращений в память на каждой итерации цикла, как и исходный вариант с невыровненной загрузкой. Однако явное обращение по выровненным адресам делает возможным использование специального буфера подкачки массивов, имеющегося в архитектуре Эльбрус для повышения эффективности доступа к памяти (кстати, в коде без интринсиков этот буфер также использовался).
Можно легко уменьшить число обращений в память на каждой итерации до 3, сохранив значения, загруженные на предыдущей итерации цикла. Кроме того, будем использовать только выровненную запись в массив-результат, обрабатывая начальную часть массивов отдельно. Благодаря этому и чтение, и запись в память будут происходить более эффективно.
```
// Вариант 2
// eml_16u *src1 - указатель на первый аргумент суммы массивов
// eml_16u *src2 - указатель на второй аргумент суммы массивов
// eml_16u *dst - указатель на результирующий массив
// len - длина массивов
size_t i = 0;
// Найдем количество элементов до границы выравнивания на 64-бита для dst и обработаем их
size_t offset = E2K_BYTES_TO_ALIGN(dst, sizeof(eml_64u)) / sizeof(eml_16u);
for (; i < offset; ++i)
dst[i] = src1[i] + src2[i];
// Обработаем основную часть массива
__di spec0, spec1;
__di tmp0, tmp1;
__di align1 = E2K_BYTES_FROM_ALIGN(src1 + offset, sizeof(eml_64u));
E2K_PREPARE_ALIGN(align1, spec0);
__di align2 = E2K_BYTES_FROM_ALIGN(src2 + offset, sizeof(eml_64u));
E2K_PREPARE_ALIGN(align2, spec1);
const __di *v1 = (__di *)E2K_ALIGN_PTR_BACK(src1 + offset, 8);
const __di *v2 = (__di *)E2K_ALIGN_PTR_BACK(src2 + offset, 8);
__di *v3 = (__di*)(dst + offset);
__di d01, d11;
__di d00 = *v1;
__di d10 = *v2;
++v1;
++v2;
static const size_t block_size = sizeof(eml_64u) / sizeof(eml_16u);
size_t effective_len = offset + ((len - offset) & ~(block_size - 1));
for (; i < effective_len; i += block_size, ++v1, ++v2, ++v3) {
d01 = *v1;
d11 = *v2;
E2K_ALIGN_DATA(d00, d01, tmp0, spec0);
E2K_ALIGN_DATA(d10, d11, tmp1, spec1);
*v3 = __builtin_e2k_paddh(tmp0, tmp1);
d00 = d01;
d10 = d11;
}
// Обработаем оставшиеся элементы последовательно, если они есть
```
Казалось бы, что можно ещё сделать?
Однако, как мы помним, на современных Эльбрусах имеется 6 каналов исполнения, в которые можно поместить до 24 инструкций, и они будут исполняться за 1 такт. Из этих инструкций только 6 могут быть арифметическими для целых чисел, т. к. на каждый канал есть только одно векторное АЛУ (другие инструкции могли бы относиться к вещественной арифметике, загрузке/записи и пр.) Кроме того, есть ещё одна тонкость: эти 6 АЛУ разные, и каждая арифметическая команда может быть исполнена только в определенных каналах. Для ненасыщающего сложения подходят только каналы 0 и 3. Поэтому за 1 такт мы можем выполнить не больше 2 сложений. Чтобы подсказать осторожному компилятору, что эти два сложения независимы (т. е. результат первого не используется во втором), развернем цикл. Это можно сделать вручную или с помощью директивы компилятора:
`#pragma unroll(2)`
Кроме того, можно подсказать компилятору количество ожидаемых итераций цикла, например, для цикла по строке изображения подойдёт число около 1024 (это вполне разумная оценка линейных размеров распознаваемых изображений, да и коллеги из МЦСТ рекомендовали такой размер; общая идея в том, что число должно быть достаточно большим, чтобы компилятор счёл уместным использовать специальные цикловые оптимизации):
`#pragma loop count(1024)`
Разумеется, в заведомо коротких циклах компилятору следует оставить противоположную подсказку (см. ниже).
```
// Вариант 3
// eml_16u *src1 - указатель на первый аргумент суммы массивов
// eml_16u *src2 - указатель на второй аргумент суммы массивов
// eml_16u *dst - указатель на результирующий массив
// len - длина массивов
size_t i = 0;
// Найдем количество элементов до границы выравнивания
на 64-бита для dst и обработаем их
size_t offset = E2K_BYTES_TO_ALIGN(dst, sizeof(eml_64u)) / sizeof(eml_16u);
#pragma loop count(3)
for (; i < offset; ++i) {
dst[i] = src1[i] + src2[i];
}
// Обработаем основную часть массива
__di spec1, spec2;
__di tmp0, tmp1;
__di align1 = E2K_BYTES_FROM_ALIGN(src1 + offset, sizeof(eml_64u));
E2K_PREPARE_ALIGN(align1, spec1);
__di align2 = E2K_BYTES_FROM_ALIGN(src2 + offset, sizeof(eml_64u));
E2K_PREPARE_ALIGN(align2, spec2);
const __di *v1 = (__di *)E2K_ALIGN_PTR_BACK(src1 + offset, sizeof(eml_64u));
const __di *v2 = (__di *)E2K_ALIGN_PTR_BACK(src2 + offset, sizeof(eml_64u));
__di *v3 = (__di*)(dst + offset);
__di d01, d11, d02, d12;
__di d00 = *v1;
__di d10 = *v2;
++v1;
++v2;
size_t effective_len = offset + ((len - offset) & ~0x03);
#pragma unroll(2)
#pragma loop count(1024)
for (; i < effective_len; i += 4, ++v1, ++v2, ++v3) {
d01 = *v1;
d11 = *v2;
E2K_ALIGN_DATA(d00, d01, tmp0, spec0);
E2K_ALIGN_DATA(d10, d11, tmp1, spec1);
*v3 = __builtin_e2k_paddh(tmp0, tmp1);
d00 = d01;
d10 = d11;
}
// Обработаем оставшиеся элементы последовательно, если они есть
```
Теперь приведем результаты замеров. Для этого мы измеряли время сложения двух массивов длины 105. Среднее время по 105 итерациям приведено в таблице.
| Вариант | Среднее время сложения массивов, мкс |
| --- | --- |
| 0 | 219,0 |
| 1 | 250,7 |
| 2 | 62,6 |
| 3 | 31,4 |
Наша оптимизация позволила в 7 раз ускорить сложение! Мы видим, что, задавшись целью выжать максимум производительности и потратив немного времени на изучение особенностей Эльбруса, можно добиться значительных результатов.
***Большое спасибо сотрудникам МЦСТ, которые неоднократно консультировали нас при написании этого материала!*** | https://habr.com/ru/post/351134/ | null | ru | null |
# Bhunter — взламываем узлы бот-сетей
Вирусные аналитики и исследователи компьютерной безопасности стремятся собрать как можно больше образцов новых ботнетов. В своих целях они используют honeypot'ы.… Но что если хочется понаблюдать за зловредом в реальных условиях? Подставить под удар свой сервер, маршрутизатор? А что если подходящего устройства нет? Именно эти вопросы натолкнули меня на создание bhunter — инструмента для получения доступа к узлам бот-сетей.
Основная идея
=============
Существует много способов распространения вредоносного по для расширения бот-сетей: начиная от фишинга и заканчивая эксплуатацией 0-day уязвимостей. Но самым распространенным методом до сих пор остается перебор паролей к SSH.
Идея очень проста. Если с какого-то узла бот-сети осуществляется перебор паролей к вашему серверу, то вероятнее всего этот узел сам был захвачен перебором простых паролей. А значит, чтобы получить к нему доступ, надо просто ответить ему «взаимностью».
Именно так и работает bhunter. Слушает 22 порт (служба SSH) и собирает все лоигны и пароли, с которыми пытаются к нему подключиться. Затем, используя собранные пароли, пытается подключиться к атакующим узлам.
Алгоритм работы
===============
Программу можно условно разделить на 2 основные части, которые работают в отдельных потоках. Первая — honeypot. Обрабатывает попытки входа, собирает уникальные логины и пароли (в данном случае пара логин+пароль рассматривается как единое целое), а также добавляет в очередь для дальнейшей атаки IP-адреса, которые пытались подключиться.
Вторая часть отвечает непосредственно за атаку. При чем атака ведется в двух режимах: BurstAttack (атака очередью) — перебор логинов и паролей из общего списка и SingleShotAttack (атака одиночными выстрелами) — перебор паролей, которые использовались атакуемым узлом, но еще не были добавлены в общий список.
Чтобы иметь хоть какую-то базу логинов и паролей сразу после запуска, bhunter инициализируется списком из файла /etc/bhunter/defaultLoginPairs.
Интерфейс
=========
Предусмотрено несколько способов запуска bhunter:
##### Просто командой
```
sudo bhunter
```
При таком запуске есть возможность управлять bhunter'ом через его текстовое меню: добавлять логины и пароли для атаки, экспортировать базу логинов и паролей, указать цель для атаки. Все взломанные узлы можно увидеть в файле /var/log/bhunter/hacked.log
##### Используя tmux
```
sudo bhunter-ts # команда запуска bhunter через tmux
sudo tmux attach -t bhunter # подключаемся к сессии, в которой запущен bhunter
```
Tmux — терминальный мультиплексор, очень удобный инструмент. Позволяет в рамках одного терминала создавать несколько окон, а окна разбивать на панели. Используя его можно выйти из терминала а потом зайти не прерывая запущенные процессы.
Скрипт bhunter-ts создает tmux-сессию и разбивает окно на три панели. В первой — самой большой, находится текстовое меню. Верхняя правая содержит в себе логи honeypot'а, тут можно увидеть сообщения о попытках входа на honeypot. В нижней правой панели выводится информация о ходе атаки на узлы бот-сетей и об успешных взломах.
Преимущество этого способа над первым в том, что мы можем смело закрыть терминал и вернуться к нему позже, при этом bhunter не остановит работу. Тем, кто мало знаком с tmux предлагаю [эту шпаргалку](https://habr.com/ru/post/126996/).
##### As a service
```
systemctl enable bhunter
systemctl start bhunter
```
В данном случае мы включаем автозапуск bhunter при старте системы. В данном методе взаимодействие с bhunter не предусмотрено, а список взломанных узлов можно получить из /var/log/bhunter/hacked.log
Эффективность
=============
За время работы над bhunter мне удалось найти и получить доступ к совершенно разным устройствам: raspberry pi, маршрутизаторы (особенно mikrotik), web-сервера, а однажды ферма для майнинга (к сожалению доступ к ней был в течении дня, поэтому интересной истории не получилось). Вот скриншот программы, на котором виден список взломанных узлов после нескольких дней работы:
К сожалению, эффективность данного инструмента не достигла моих ожиданий: bhunter может перебирать пароли к узлам несколько дней безрезультатно, а может взломать несколько целей за пару часов. Но для регулярного притока новых образцов ботнетов этого достаточно.
На эффективность влияют такие параметры как: страна, в которой расположен сервер с bhunter, хостинг, и диапазон из которого выделен ip-адрес. На моем опыте был случай, когда я арендовал два виртуальных сервера у одного хостера, и один из них подвергался атакам со стороны ботнетов в 2 раза чащще.
Баги, которые я пока не исправил
================================
При атаке на зараженные узлы в некоторых ситуациях не удается однозначно определить подошел пароль или нет. Журналирование таких случаев ведется в файле /var/log/debug.log.
Модуль Paramiko, который используется для работы с SSH иногда ведет себя некорректно: уходит в бесконечное ожидание ответа от узла, когда пытается к нему подключиться. Я экспериментировал с таймерами, но нужного результата не получил
Над чем еще предстоит поработать?
=================================
##### Service name
Согласно RFC-4253, клиент и сервер перед установкой обмениваются названиями служб, реализующих протокол SSH. Данное название содержится в поле «SERVICE NAME», содержащимся как в запросе со стороны клиента, так и в ответе со стороны сервера. Поле представляет из себя строку, и его значение можно узнать используя wireshark или nmap. Вот пример для OpenSSH:
```
$ nmap -p 22 ***.**.***.** -sV
Starting Nmap ...
PORT STATE SERVICE VERSION
22/tcp open ssh **OpenSSH 7.9p1 Debian 10+deb10u2** (protocol 2.0)
Nmap done: 1 IP address (1 host up) scanned in 0.47 seconds
```
Однако в случае с Paramiko, данное поле содержит строку вида «Paramiko Python sshd 2.4.2», что может отпугнуть ботнеты, в которые заложено «избегание» ловушек. Поэтому считаю необходимым заменить эту строку на что-то более нейтральное.
##### Другие вектора
SSH не является единственным средством удаленного управления. Есть еще telnet, rdp. Стоит присмотреться и к ним.
##### Расширение
Было бы здорово иметь несколько ловушек в разных странах и централизовано собирать с них логины, пароли и взломанные узлы в общую базу данных
Где скачать?
============
На момент написания статьи готова только тестовая версия, которую можно скачать из [репозитория на Github](https://github.com/dvoropaev/bhunter). | https://habr.com/ru/post/491098/ | null | ru | null |
# 2D магия в деталях. Часть четвёртая. Вода
> — Я тут воду для проекта запилил.
>
> — О, круто! А почему она плоская? Даёшь волны!
>
> …
>
> — Слушай, ты тогда про волны говорил, помнишь? Зацени!
>
> — Да, хорошие волны, а преломление и каустику ещё не делал?
>
> …
>
> — Привет, я тут игрался с Unity всю ночь, смотри какие отражения и каустику закодил!
>
> — Дарова, и правда, хорошо! А когда у тебя вода кипит, отражения не глючат?
>
> …
>
> — Хай, реализовал наконец, кипение, вроде ничего?
>
> — О, прямо как нужно! Слушай, прикинь как круто, если кипящую волну заморозить?
>
> …
>
> — Лови картинку, лёд вроде ничего придумал?
>
> — Норм, слушай, а у тебя лёд замерзает, он в объёме увеличивается? И кстати, ты когда геймлей то делать начнёшь?
>
> *Вариации на тему лога с другом.*
Да, вы уже поняли, наконец-то расскажу про реализацию воды в проекте. Приступим?
Предыдущие статьи
------------------
[Часть первая. Свет.](https://habrahabr.ru/post/305252)
[Часть вторая. Структура.](https://habrahabr.ru/post/312046)
[Часть третья. Глобальное освещение.](https://habrahabr.ru/post/313776)
**Часть четвёртая. Вода**
Оглавление
-----------
1. Подглядывание за 3D
2. Хотелки
3. Первый блин комом
4. Статика
5. Генерация воды
6. Динамика
7. Температура
8. Заключение и интрига
Подглядывание за 3D
--------------------
Для начала подсмотрим, как делают воду "взрослые ребята" из всяких крупных 3D проектов.
Вообще, перетаскивать идеи из 3D — отличный план, в 2D классных алгоритмов ощутимо меньше.
Итак, от самого простого к более сложному:
* **Плоская вода без физики.** Бросили полигон на уровень и радуемся. Потому что fps не проседает и выглядит неплохо (художники постарались и собрали красивый шейдер). Взаимодействовать нельзя, говорите? Так у нас гоночная игра, воду видно только на горизонте!
* **Полигональная вода без физики.** Планировали карту с плохой погодой, а вода плоская, как зеркало? Добавим полигонов, вспомним про синусы и вот, на горизонте громоздятся штормовые волны. Если в воду не заехать случайно — даже и не заметно, что вода ненастоящая.
* **Плоская вода с физикой.** С гонками закончили, делаем Skyrim. Плоская вода с красивыми эффектами, несколько проверок в физическом движке и по воде можно плавать. Никаких тебе бурь и волн, но кому они в rpg нужны, когда по небу летают драконы, а фус-ро-да сбивает с ног прохожих?
* **Полигональная вода с физикой.** Завязали с фэнтези и начали делать GTA. И тут уже реалистичные волны, да ещё и с физикой водного транспорта (как в [этой великолепной статье](https://habrahabr.ru/post/307362/)). Хорошая вода, неужели можно ещё усложнить?
* **Система частиц**. Ещё как можно! Если вы парни из Dark Energy Digital, и когда-то сделали Hydrophobia с "честной" водой, которая умеет течь, брызгаться и затапливать. И если у вас мощная видеокарта (или две) и процессор, способный всё это рассчитать.
Хотелки
--------
Теперь, когда у нас есть референсы из крупных проектов, помечтаем, чего бы хотелось реализовать в нашем проекте.
> Помните, шутливое вступление в начале статьи? Это совсем не шутка — каждый раз, когда я кидал другу скрины или видео из очередной демки, он предлагал какие-то совершенно безумные идеи. И это великолепно, ведь большую часть этих идей удалось воплотить, сделав проект ещё интереснее с точки зрения разработки. Поэтому список ниже составлялся итеративно, без мейлстоунов и плана.
А вот и список хотелок:
1. Возможность в realtime добавлять новые объёмы воды или "испарять" существующие.
2. Волны на поверхности воды.
3. Температура, возможность замерзания и кипения воды.
4. Взаимодействие с другими модулями: ветром, физическими телами, погодой.
5. Тесное взаимодействие с системой освещения: каустика, рассеивание света, отражения.
6. Возможность настройки в редакторе.
> А про взаимодействия с модулями — тема практически бесконечная. Смотрите сами — в статье про свет я рассказывал, что в проекте есть возможность включить god rays — лучи света, видимые из-за пыли в воздухе. А теперь, когда я доделал кипящую воду, ничто не мешает сделать генерацию частиц пара, над которыми будут видны эти god rays! А ведь с частицами умеет взаимодействовать ветер, а значит, пар над горячей водой будет красиво рассеиваться. И таких взаимодействий столько, что не успеваешь записывать, не то что прототипировать.
Первый блин комом
------------------
Мы не пойдем путём команды, сделавшей Hydrophobia, "честно" моделировать жидкость — слишком уж требователен к ресурсам этот способ. Нужно упрощать. Раз уж в проекте пиксельарт — все плоскости либо горизонтальны, либо вертикальны. И пустое пространство на уровне представимо в виде набора прямоугольников. Вот с ними и будем работать.
В препроцессинге на начале уровня:
1. Разбиваем всё пустое пространство на уровне на прямоугольные непересекающиеся объёмы.
2. Находим связи объёмов друг с другом и строим граф "течений" воды.
В реальном времени:
1. Для каждого объёма отдельно рассчитываем волны на поверхности (игнорируем тот факт, что с помощью волн вода может перетекать из объёма в объём).
2. Рассчитываем перетекание воды с помощью графа.
*Граф водных объёмов*
Но, сказать по правде, ничего не получилось. Подводных камней столько, что можно построить парочку пятиэтажек. Например: нужно синхронизировать волны, разбираться с давлением в сообщающихся сосудах и т.д. Но нет худа без добра — именно для реализации этого метода когда-то была написана имплементация region tree, которая сейчас используется повсюду в проекте.
Статика
--------
Раз с совсем динамической водой не получилось, давайте упростим себе жизнь — будем настраивать воду в редакторе, а в для иллюзии динамики оставим волны. По сути, перейдем к варианту №3 из списка вариантов.
Вода — очень противоречивая штука, потому что умеет течь: нельзя сказать "вот в этих точках будет вода", разместить там меши для жидкости и получить хорошую картинку. Ну и ладно, пусть левел дизайнеры (мы в будущем) разместят некие ключевые точки, где точно должна быть вода, а движок выльет её из своих запасов, причем ровно до уровня ключевых точек. Конечно, можно поместить один "якорь" под другим, но это уже проблема не движка, а тех самых неизвестных нам левел дизайнеров: наш код аккуратно заполнит водой уровень до самой верхней ключевой точки.
Ещё одна фишка — отдельные якоря для создания "пузырей". Если алгоритм найдёт такой якорь, он постарается не залить его водой, оставив аккуратную каверну с воздухом.
Теперь, когда есть понимание, какие результаты мы получим, пора разработать алгоритм, не так ли?
Генерация воды
---------------
В общем случае, вода может залить весь уровень. Так как стены состоят из прямоугольных кусочков и могут быть расположены где угодно, водный объём — это невыпуклый прямоугольный многоугольник с дырами. Гадость какая. Давайте разбивать на более простые фигуры.
> Небольшой спойлер, чтобы было понятнее. В результате препроцессинга мы должны получить некие водные объёмы, в которых просто рассчитывать волны. По сути, один водный объём — это набор водяных столбиков толщиной в один пиксель.
Разберёмся с пустым пространством, в котором может быть жидкость. Великолепное region tree, про которое я рассказывал в прошлых статьях, очень поможет. Получим с его помощью все прямоугольные объёмы, не занятые стенами:
1. Начиная с нижнего (изначально — левого) угла дерева ищем первую пустую область сверху.
2. Начиная с найденной пустой области, ищем первую непустую область сверху.
3. Добавляем полученный отрезок в список.
4. Если достигли верхней (в геометрическом смысле) границы дерева, перемещаемся на 1 пиксель вправо.
5. Если не достигли правой границы дерева, переходим к пт.1.
6. Собираем из списка отрезков (а они довольно удачно отсортированы) прямоугольники.
7. Строим связи между смежными прямоугольниками.
*Вместо тысячи слов*
> Скорее всего, можно получить эти прямоугольники куда более красивым способом. Буду рад комментариям на эту тему.
На самом деле, прямоугольники — не самый удачный выбор. Из-за большого количества деталей (например, зубцов на башнях) прямоугольных водных объёмов получится очень много. А это уменьшит производительность. Спокойная вода — плоская, а форма дна нам не важна, поэтому объединим смежные прямоугольники таким образом:
`Если у прямоугольника A только одна связь справа (с прямоугольником B), а у прямоугольника B - только одна связь слева (с прямоугольником A) - объединяем эти прямоугольники в одну структуру.`
После этого этапа останется небольшое количество водных объёмов с ребристым дном, на рисунке ниже это хорошо видно.
*Разметка пустого пространства на карте (со связями)*
Теперь нужно найти все метки, оставленные на карте левел дизайнерами и "обрезать" наши заготовки по их уровню. С этим справится примерно такой алгоритм:
1. Собираем все метки уровня воды (), сортируем их по y-координате по убыванию значения.
2. Для каждой метки:
2.1. Находим прямоугольник, которому принадлежит метка.
2.2. Если прямоугольник не найден, метка — в стене, игнорируем её и переходим к пт. 2.
2.2. Уменьшаем высоту прямоугольника до уровня метки.
2.3. Если высота прямоугольника стала равна нулю — удаляем прямоугольник.
2.4. Находим все смежные прямоугольники, нижний край которых выше метки и удаляем их.
2.5. Находим все прочие смежные прямоугольники, переходим к пт. 2.3 (рекурсивно обрезаем все прямоугольники по уровню воды).
3. Собираем все метки воздушных пузырей (), сортируем их по y-координате по убыванию значения.
4. Для каждой метки:
4.1. Находим прямоугольник, которому принадлежит метка.
4.2. Если прямоугольник не найден, метка — в стене, игнорируем её и переходим к пт. 4.
4.2. Уменьшаем высоту прямоугольника до уровня метки.
4.3. Если высота прямоугольника стала равна нулю — удаляем прямоугольник.
4.4. Находим все смежные прямоугольники, нижний край которых выше метки и удаляем их.
4.5. Находим все прочие смежные прямоугольники, у которых верхний край **выше уровня метки**, переходим к п 4.3 (рекурсивно обрезаем все прямоугольники по уровню воздушного пузыря).
Как видите, отличие меток воды от меток воздушных пузырей в том, что первые проходят по всем соседям рекурсивно, а вторые останавливаются, когда сосед находится целиком под уровнем пузыря.
А теперь в картинках:
*Добавили на карту метки уровня воды*
*То же самое, но со связями*
*Обрезали прямоугольники по уровню воды*
*Удалили лишние связи и прямоугольники*
*Дебажная визуализация полученных водных объёмов*
**Небольшая, но важная заметка**
Несмотря на то, что мы обрезаем прямоугольники по уровню меток, в каждом из них сохраняем массив изначальных высот (y-координату потолка над водой). В дальнейшем эти высоты понадобятся для ограничения волн — в противном случае волны смогут проходить сквозь стены.
Самое время посмотреть, как это выглядит в редакторе:
Динамика
---------
Раз уж мы отказались от текущей в реальном времени воды, давайте хоть волны красивые сделаем. После генерации воды у нас получается примерно такой менеджер для воды:
```
namespace NewEngine.Core.Water {
public class WaterManager : MonoBehaviour {
// куча настроек для жидкости
// ...
WaterPolygon[] waters;
CombineInstance[] combineInstances = null;
Mesh mesh;
public void Generate() {
if (tree == null)
return;
waters = WaterGenerator.Generate(tree, waveCeil);
Debug.Log("Regenerate water");
}
void FixedUpdate() {
if (waters == null)
return;
var viewportRect = cameraManager.ViewRect;
WaterPolygon.Update(waters, ref combineInstances, viewportRect, /*а тут куча настроек, в виде структуры или просто списком, кому как больше нравится*/);
mesh.Clear();
mesh.CombineMeshes(combineInstances);
}
}
}
```
Пока что из всего этого кода нас (*ну или меня, как рассказчика*) интересует только *WaterPolygon*. Это те самые минимальные кусочки воды, для которых можно строить волны. А еще эти элементы связаны друг с другом (информация о графе осталась доступна в этих полигонах). Если упустить неважные детали, выглядит этот класс так:
**Большущий кусок кода**
```
namespace NewEngine.Core.Water {
public class WaterPolygon {
// одна "линия" - колонка воды шириной в один пиксель
// хранит свою геометрию (минимальное значение по y, максимальное), свойства пружины (например, текущую скорость)
class Line {
public int min; // y-координата нижнего края воды
public int max; // y-координата верхнего края воды
public int target; // y-координата верхнего края воды, когда жидкость не колеблется
public int height; // y-координата максимального верхнего края воды (потолок, если есть или MAX_WAVE_HEIGHT, если нет)
public float speed;
float lastDelta;
public void Add(float additionalWater);
public void Sleep();
public void Update(float tension, float dampening, float foamThreshold, float foamForce, float foamDampening, float airTemperature, float airTranscalency, float verticalTranscalency, float minBoilTemperature, float minBoilBubble, float maxBoilBubble, float boilFrequency);
}
// координаты по y хранятся в Line, а все линии последовательны, так что нужно хранить только начальную позицию по x
int x;
// соседние водные полигоны; для синхронизации волн и температуры
WaterPolygon[] left;
WaterPolygon[] right;
// сами водные "колонки"
Line[] lines;
// мы не обрабатываяем спящую воду
bool sleeping;
int sleepingFrames;
// кешированные значения для проверки пересечения AABB
int minWaterY;
float maxWaterY;
// обычный меш из UnityEngine
Mesh mesh;
// когда я допишу эту статью, запихну все параметры в аккуратную структуру, честно :)
public static void Update(WaterPolygon[] water, ref CombineInstance[] combineInstances, Geom.IntRect viewportRect, int outsideCameraSleepOffset, float heightSleepThreshold, float speedSleepThreshold, float tension, float dampening, float spread, int steps, float foamThreshold, float foamForce, float foamDampening, float airTemperature, float airTranscalency, float verticalTranscalency, float horisontalTranscalency, float minBoilTemperature, float minBoilBubble, float maxBoilBubble, float boilFrequency, int sleepingUpdateFrames);
// проверка AABB с неким допуском offset
public bool IsOutside(Geom.IntRect viewportRect, int offset);
// первый шаг обновления - фактически, расчет новых скоростей и положений пружин в lines
void UpdateFirst(Geom.IntRect viewportRect, int outsideCameraSleepOffset, float tension, float dampening, int steps, float foamThreshold, float foamForce, float foamDampening, float airTemperature, float airTranscalency, float verticalTranscalency, float minBoilTemperature, float minBoilBubble, float maxBoilBubble, float boilFrequency, int sleepingUpdateFrames);
// второй шаг обновления - обмен скоростями между соседними пружинами, в том числе из полигонов соседей (left и right)
void UpdateSecond(float heightSleepThreshold, float speedSleepThreshold, float spread, int steps, float foamThreshold, float foamForce, float foamDampening, float horisontalTranscalency, float airTemperature, float minBoilTemperature);
// чистка кешей и ненужных данных перед сном
void Sleep(bool withClear);
// поиск ближайшей линии соседа полигона (в зависимости от высоты волны), об этом ниже
void FindLine(bool isRight, out Line line, out WaterPolygon water);
// тут всё говорит само за себя
public void CreateMesh(ref CombineInstance combineInstance);
}
}
```
> Я не буду рассказывать про физику жидкости, потому что я делал волны по [одному хорошему туториалу](https://gamedevelopment.tutsplus.com/tutorials/make-a-splash-with-dynamic-2d-water-effects--gamedev-236). Если в двух словах: представляем воду в виде связанных пружин, где у пружины известна текущая высота, скорость и оптимальная высота. Пружины колеблются и передают колебания соседям. Ширина пружины в проекте — один пиксель.
Но есть одно важное дополнение. В туториале всего один "водный полигон" в то время как у нас их целый граф. И нужно правильно синхронизировать волны. На примере понятнее:
*Допустим, у нас есть вот такой уровень*
*Он будет состоять из трёх водных полигонов*
*В какой то момент в синем полигоне возникает волна*
*Алгоритм находит подходящего соседа, исходя из высоты левой колонки и синхронизирует волну*
*При очень больших волнах алгоритм выберет другого соседа*
Минутка оптимизаций. Нет смысла рассчитывать волны для:
1. Полигонов за пределами экрана.
2. Полигонов, в которых нет волн.
При очередном расчете волн происходит проверка — не оказались ли все волны меньше порогового значения, и если да — bed time! Если же полигон целиком за пределами экрана — пороговое значение чуть выше. Соответственно, разбудить воду может связный полигон или влияние других модулей (физика, ветер и т.д.).
Пока что у воды нет причин для колебаний. Ничто не может потревожить её покой, ни сражения боевых магов, ни банальный ураган. Холодна, как сердце Морры. Время растопить лёд.
Температура
------------
Несмотря на несколько маниакальную проработку никому не нужных мелочей, не очень хочется потратить на реалистичную термодинамику ещё полгода разработки. Так что упростим донельзя. И ещё чуть-чуть.
Начнём с погодного менеджера. Когда-нибудь в нем будут и бури и штиль, но сейчас — только это:
```
namespace NewEngine.Core.Weather {
public class WeatherManager : MonoBehaviour {
[SerializeField, Range(-100, 200)] float airTemperature;
public float AirTemperature {
get {
return airTemperature;
}
}
}
}
```
Концепция такова:
1. Температура воды изначально равна температуре воздуха.
2. При температуре ниже 0 °C вода замерзает.
3. При температуре в 100 °C вода закипает.
4. Водные объёмы обмениваются температурой друг с другом.
5. Водные объёмы обмениваются температурой с атмосферой, при этом учитывается объём (в геометрическом смысле) атмосферы.
6. Оптимизации и деоптимизации:
6.1 Кипящая вода никогда не спит.
6.2. При "пробуждении" воды происходит упрощенный расчёт изменений температуры жидкости за время сна.
Температуру для *WaterPoligon.Line* будем хранить только для верхнего и нижнего концов водного столба.
```
class Line {
public int min;
public int max;
...
public float minTemperature;
public float maxTemperature;
...
}
```
Крайне неточный способ — ведь у всех столбов разная высота, но нам подойдёт.
> Сначала была идея разбивать столбы на некоторое количество кусочков и рассчитывать передачу тепла между этими кусочками (как в одном столбе, так и между соседними). В этом случае можно было бы делать "слоистую воду" — лёд/вода/лед, что невозможно в текущей реализации.
Передача температуры осуществляется в трёх разных "направлениях". Самое первое и очевидное — между краями водного столба:
```
if (length > 0) {
...
float avgTemperature = (maxTemperature + minTemperature) * 0.5f;
float ratioTranscalency = verticalTranscalency / length;
maxTemperature = maxTemperature + (avgTemperature - maxTemperature) * ratioTranscalency;
minTemperature = minTemperature + (avgTemperature - minTemperature) * ratioTranscalency;
}
```
Второе — более интересное. Теплообмен между воздухом и верхним краем столба. При генерации воды мы получали *height*, фактически, координату потолка. А значит, в любой момент времени мы можем получить высоту воздушной прослойки над водой. Чем больше воздуха над водой, тем быстрее происходит теплообмен. Спорное утверждение. Зато на открытом воздухе вода будет остывать/разогреваться быстрее, чем в невысоких пещерах:
```
float length = height - min;
if (length > 0) {
if (height < max) {
float airVolume = Mathf.Min(max - height, MAX_AIR_VOLUME);
maxTemperature = maxTemperature + (airTemperature - maxTemperature) * Mathf.Clamp01(airTranscalency * airVolume);
}
...
}
```
Остается теплообмен между соседними столбиками. Так как информация о температуре хранится только на краях столбов, линейная интерполяция выходит на сцену.
*Для любителей картинок*
**Для любителей кода**
```
static void UpdateTemperatureDelta(float horisontalTranscalency, float[] minTemperatureDelta, float[] maxTemperatureDelta, int i, Line line, Line other) {
if (line.height <= line.min || other.height <= other.min) {
minTemperatureDelta[i] = 0;
maxTemperatureDelta[i] = 0;
return;
}
float height = line.height - line.min;
float otherHeight = other.height - other.min;
if (Mathf.Max(line.height, other.height) - Mathf.Min(line.min, other.min) >= height + otherHeight) {
minTemperatureDelta[i] = 0;
maxTemperatureDelta[i] = 0;
return;
}
float minY = Mathf.Max(line.min, other.min);
float maxY = Mathf.Min(line.height, other.height);
float minT = (minY - line.min) / height;
float maxT = (maxY - line.min) / height;
float otherMinT = (minY - other.min) / otherHeight;
float otherMaxT = (maxY - other.min) / otherHeight;
float minTemperature = Mathf.Lerp(line.minTemperature, line.maxTemperature, minT);
float maxTemperature = Mathf.Lerp(line.minTemperature, line.maxTemperature, maxT);
float otherMinTemperature = Mathf.Lerp(other.minTemperature, other.maxTemperature, otherMinT);
float otherMaxTemperature = Mathf.Lerp(other.minTemperature, other.maxTemperature, otherMaxT);
float ratio = horisontalTranscalency * Mathf.Clamp01(height / otherHeight);
minTemperatureDelta[i] = ratio * (minTemperature - otherMinTemperature);
maxTemperatureDelta[i] = ratio * (maxTemperature - otherMaxTemperature);
}
```
Обмен температурой похож по структуре на обмен волнами, но волна передаётся только одному соседнему *WaterPolygon*'у с каждой стороны, а теплота — каждому из соседей.
И последний штрих — кипение и замерзание воды. Если температура выше или равна 100 °C — добавляем случайную скорость пружины к столбу жидкости, причем чем выше температура — тем больше разброс скоростей (на самом деле, не ровно 100 °C, вода начинает пузыриться чуть раньше).
Ну а если температура ниже или равна 0 °C — сохраняем скорость пружины равной нулю и перестаём реагировать на передачу скоростей от соседних столбиков-пружин.
Или, другими словами:
```
if (height < max) {
if (maxTemperature >= minBoilTemperature) {
float depth = target - min;
float ratio = Mathf.Clamp01((maxTemperature - minBoilTemperature) / (100 - minBoilTemperature));
float heightValue = Mathf.Min(depth * 2, Mathf.Max(minBoilBubble, ratio * maxBoilBubble));
float frequency = Mathf.Lerp(0, boilFrequency, ratio * ratio);
if (Random.value > 1 - frequency)
height += Random.Range(-heightValue, heightValue);
}
}
if (maxTemperature <= 0) {
speed = 0;
return;
}
```
*Постепенное закипание воды*
Заключение и интрига
---------------------
После всего вышеописанного в проекте появилась вода, которую можно "вылить" на уровень в редакторе. Волнующаяся, кипящая, твердеющая на морозе живительная влага!
Было бы обидно получить некрасивую картинку, написав столько кода. Отражения, преломления, каустика — наше всё! А значит, снова толстые шейдеры, взаимодействие с системой освещения, рендер в текстуру и всё такое.
Но об этом — в следующей статье. :) | https://habr.com/ru/post/308220/ | null | ru | null |
# Организация кнопок на сайте с помощью Sass
Довольно часто наши любимые дизайнеры делают в макетах кнопки разных размеров и величин, некоторые из которых повторяются, некоторые нет. Неплохо было бы организовать систему для быстрого добавления и редактирования этих самых кнопок, в чем на могут помочь sass @extend's. Приведу небольшую иллюстрацию кнопок в типичном проекте.
#### Как не надо делать
HTML для наших кнопок будет неизменным в течение всей статьи:
```
* [Инфраструктура](#)
* [Квартиры](#)
* [Галерея](#)
```
Первое что может прийти в голову верстальщику — записать стили для кнопок сразу в классы наших элементов.
SCSS:
```
.about_butt {
display: block;
height:50px;
line-height: 50px;
text-align: center;
font-family: 'intro';
font-size: 12px;
}
```
Мы написали стили для нашего основного класса, теперь сделаем его модификации по цвету(для цвета использованы переменные для удобства):
```
.about_butt {
display: block;
height: 50px;
line-height: 50px;
text-align: center;
font-family: 'intro';
font-size: 12px;
&.blue_mod {
background: $blue_1;
color: $white;
transition: background .3s ease;
&:hover, &:focus {
text-decoration: none;
}
&:hover {
background: lighten($blue_1, 5%);
}
}
&.red_mod {
background: $red_1;
color: $white;
transition: background .3s ease;
&:hover, &:focus {
text-decoration: none;
}
&:hover {
background: lighten($red_2, 5%);
}
}
&.yellow_mod {
background: $yellow_1;
color: $white;
transition: background .3s ease;
&:hover, &:focus {
text-decoration: none;
}
}
}
```
Пока все просто и понятно.Но на следующей странице появляется вот такая кнопка:
Эта кнопка имеет те же размеры, что и предыдущие, но другое оформление. Давайте нарушим принцип DRY и скопируем стили для нее от наших предыдущих кнопок:
```
.news_more_butt {
display: block;
height:50px;
line-height: 50px;
text-align: center;
font-family: 'intro';
font-size: 12px;
}
```
С размерами определились, давайте добавим оформление:
```
.news_more_butt {
color:$black_2;
background: transparent;
box-shadow:inset 0 0 0 2rem $gray_4;
transition:all .3s ease;
&:hover,&:focus {
text-decoration: none;
}
&:hover {
background: $gray_4;
color:$white;
}
}
```
Ну и немного стилей для размещения нашей кнопки:
```
.news_more_butt {
width: 186px;
margin: 20px auto;
}
```
Идем дальше и на другой странице встречаем следующую кнопку:
Оформление осталось прежним, а вот размеры кнопки и шрифта изменились. И тут перед нами два пути:
1. Продолжать копировать стили для разных кнопок и давать им уникальные классы
2. Сделать специальные классы для оформления и добавлять его в наши теги
Минусы каждого из этих подходов очевидны. В первом мы копируем слишком много кода, и когда нужно что-либо изменить — менять нужно в нескольких местах. Во втором мы добавляем презентационные классы, и это тоже не очень хорошо(любители Bootstrap бы возразили).
Но есть и третий путь — использование sass @extend(хотя это можно реализовать в любом препроцессоре).
#### Третий путь
У меня примеси лежат в отдельном scss файле — buttons.scss, это крайне удобно.Мы будем разделять их на размеры(+типографика) и цветовые схемы.Напишем классы для размеров:
```
%butt_size_1 {
display: block;
height:50px;
line-height: 50px;
text-align: center;
font-family: 'intro';
font-size: 12px;
}
%butt_size_2 {
display: block;
height:70px;
line-height: 70px;
text-align: center;
font-family: 'intro';
font-size: 16px;
}
```
Отлично, а теперь цветовые схемы:
```
%butt_gray_1 {
color: $black_2;
background: transparent;
box-shadow: inset 0 0 0 2rem $gray_4;
transition: all .3s ease;
&:hover, &:focus {
text-decoration: none;
}
&:hover {
background: $gray_4;
color: $white;
}
}
%butt_blue_1 {
background: $blue_1;
color: $white;
transition: all .3s ease;
&:hover, &:focus {
text-decoration: none;
}
&:hover {
background: lighten($blue_1, 5%);
}
}
%butt_red_1 {
background: $red_2;
color: $white;
transition: all .3s ease;
&:hover, &:focus {
text-decoration: none;
}
&:hover {
background: lighten($red_2, 5%);
}
}
%butt_yellow_1 {
background: $yellow_1;
color: $white;
transition: all .3s ease;
&:hover, &:focus {
text-decoration: none;
}
&:hover {
background: lighten($yellow_1, 5%);
}
}
%butt_green_1 {
background: $green_1;
color: $white;
transition: all .3s ease;
&:hover, &:focus {
text-decoration: none;
}
&:hover {
background: lighten($green_1, 5%);
}
}
```
Вот мы и получили гибкую систему для организации наших кнопок.Теперь наш scss будет выглядеть следующим образом:
```
.about_butt {
@extend %butt_size_1;
&.blue_mod {
@extend %butt_blue_1;
}
&.red_mod {
@extend %butt_red_1;
}
&.yellow_mod {
@extend %butt_yellow_1;
}
}
.news_more_butt {
@extend %butt_size_1;
@extend %butt_gray_1;
width: 186px;
margin: 20px auto;
}
.show_news_butt {
@extend %butt_size_2;
@extend %butt_gray_1;
display: inline-block;
}
```
Если появляется новая цветовая схема — мы просто делаем для нее @extend и используем, если изменяется текущая — ~~ругаемся на дизайнера~~ правим в одном месте.
#### Ключевые моменты
* Используем тихие классы, а не миксины(меньше результирующего CSS)
* Если у вас одно-страничный сайт с небольшим количеством кнопок — данная система будет излишней
* В тихих классах объявляется display:block, потом это можно переписать в правиле селектора
P.S.: Данную систему разработал [Андрей Бойко](http://habrahabr.ru/users/Glivera/), за что ему огромное спасибо! | https://habr.com/ru/post/271311/ | null | ru | null |
# Jivosite больше не снизит Google Speed
Передо мной возникла одна задачка - повысить Google Speed на одном из интернет-ресурсов.
Задачка ещё та, учитывая то, что большинство пунктов выполнено, но при этом просадка капитальная. А всё из-за чего? Куча метрик, яндекс информеры *(оцени Я.Маркет, рейтинг Я.Маркет)* и... ***Jivosite***.
Демонстрирую как влияет Jivosite на Google SpeedПросадка *-14 в мобильном* и *-8 на десктоп*. Эти показатели могут варьироваться в зависимости от времени блокировки потока.
В сети нашел код отложенной загрузки Jivosite, но при первом взгляде он показался мне не надежным, т.к. во первых, уменьшал просадку ***не всю***, а во вторых, при загрузке отключал и инициализировал заново некоторые JS события Jivosite. А это чревато, при обновлении движка чата.
Я пошел иным путём. Решил ПОЛНОСТЬЮ убрать влияние Jivosite на Google Speed. Каким образом?
1. Убрать влияние чата на показатели можно лишь в одном случае - не загружая его вовсе. *(Ахах, классный выход из ситуации :D)*. Не-не, слушай дальше.
2. Инициализируем Jivosite при первом визите на сайт, ТОЛЬКО после того, как пользователь куда-нибудь нажмет, или проскроллит страницу, либо подвигает мышью.
Логично? Ведь Google Speed совершенно бездействует на сайте. Таким образом для него чата не будет вовсе, а для пользователя в первый визит он появится после какого-либо действия. При последующих же визитах всё стандартно.
И так, релиз в пост!
* Вначале проверяем в сессии существование ключа, который свидетельствует о том, что ранее отложенная по действию пользователя загрузка Jivosite уже осуществлялась, а значит загружаем в обычном режиме.
Я сделал именно сессией т.к. на больших проектах желательно на куках экономить, дабы не вывалило кому-то ошибку 500 из-за большого количества кук.
Но, если Вы владелец сайта не на фреймворке с единой точкой входа, то в этом случае целесообразнее использовать куки.
```
php if ( !isset($_SESSION['jivoLazy']) ) { ?
php $_SESSION['jivoLazy'] = 'ready'; ?
php } else { ?
php } ?
```
* Уже прилично давно Jivosite упростила код инициализации своего чата. Обычный инициализатор выглядит вот так:
* Я не приверженец какой-либо кастомизации стороннего кода, но именно один раз нам придется его загрузить старым способом, который раньше предлагал Jivo. Это связано с тем, что как я не крутил с новой версией инициализатора, при отложенной загрузке он не видит ID виджета.
По этому вот старый инициализатор Jivosite
```
(function(){ var widget_id = '#widgetId#';var d=document;var w=window;function l(){
var s = document.createElement('script'); s.type = 'text/javascript'; s.async = true; s.src = '//code.jivosite.com/script/widget/'+widget_id; var ss = document.getElementsByTagName('script')[0]; ss.parentNode.insertBefore(s, ss);}if(d.readyState=='complete'){l();}else{if(w.attachEvent){w.attachEvent('onload',l);}else{w.addEventListener('load',l,false);}}})();
```
* Теперь напишем просто JS функцию, которая будет инициализировать чат при отложенной загрузке.
```
function jivoAsync()
{
if ( typeof window.jivoLazyReady === 'undefined' )
{
window.jivoLazyReady = true;
window.jivoLazyTimeout = setTimeout(function()
{
// Сюда вставляем старый способ инициализации Jivo
// Я его привёл выше
console.log('jivosite load from lazy');
clearTimeout(window.jivoLazyTimeout);
},
1000);
}
}
```
* В данной функции мы проверяем был ли уже ранее загружен чат, если нет, то загружаем.
* Далее инициализируем функцию jivoAsync()
В данном инициализаторе мы слушаем события *Движение мыши, Клик, Скроллинг страницы*. И инициализируем написанную нами функцию jivoAsync.
```
['mouseover','click','scroll'].forEach(function(event)
{
var elm = event == 'click' ? document.getElementsByTagName('body')[0] : window;
if ( typeof window.addEventListener === 'undefined' ) {
elm.addEvent(event, jivoAsync);
} else {
elm.addEventListener(event, jivoAsync, false);
}
});
```
Данный скрипт инициализирует чат только 1 раз. Ведь кликов, движений мыши, скроллинга может быть много, но функция контролирует этот момент.
В мобильном срабатывают события *Клик куда угодно и скроллинг страницы*.
Таким образом Jivosite загрузится через секунду после того, как пользователь первый раз вошел на сайт и что-либо сделал на нём. Согласитесь, чат не очень-то и нужен прямо сразу. Ну а при сёрфинге Jivosite загрузится уже стандартно.
Полный код примера
```
php if ( !isset($_SESSION['jivoLazy']) ) { ?
php $_SESSION['jivoLazy'] = 'ready'; ?
function jivoAsync()
{
if ( typeof window.jivoLazyReady === 'undefined' )
{
window.jivoLazyReady = true;
window.jivoLazyTimeout = setTimeout(function()
{
(function(){ var widget\_id = '#widgetID#';var d=document;var w=window;function l(){
var s = document.createElement('script'); s.type = 'text/javascript'; s.async = true; s.src = '//code.jivosite.com/script/widget/'+widget\_id; var ss = document.getElementsByTagName('script')[0]; ss.parentNode.insertBefore(s, ss);}if(d.readyState=='complete'){l();}else{if(w.attachEvent){w.attachEvent('onload',l);}else{w.addEventListener('load',l,false);}}})();
console.log('jivosite load from lazy');
clearTimeout(window.jivoLazyTimeout);
},
1000);
}
}
['mouseover','click','scroll'].forEach(function(event)
{
var elm = event == 'click' ? document.getElementsByTagName('body')[0] : window;
if ( typeof window.addEventListener === 'undefined' ) {
elm.addEvent(event, jivoAsync);
} else {
elm.addEventListener(event, jivoAsync, false);
}
});
php } else { ?
php } ?
```
**Поздравляю, Google Speed добавил +10-15 пунктов на Вашем проекте!**
**Не забудьте** в двух местах *#widgetID#* изменить на ID виджета Jivosite.
*Всем пока, всем мира.* | https://habr.com/ru/post/590905/ | null | ru | null |
# Графы для самых маленьких: BFS
В [предыдущем посте](http://habrahabr.ru/post/200074/) рассказывалось об обходе графа в глубину. Сегодня я бы хотел рассказать о не менее важном алгоритме теории графов — об обходе в ширину.
В прошлый раз мы уже научились искать какой-нибудь путь сквозь лабиринт. Всех желающих найти кратчайший путь прошу под кат.
#### Постановка задачи
Требуется найти путь от одной вершины графа до другой, причем путь должен быть минимальным по количеству ребер.
#### Описание алгоритма
Интуитивно хочется рассматривать вершины графа в порядке увеличения расстояния от исходной — так, как показано на рисунке.
Разделим все вершины на три множества:
* Полностью обработанные вершины (изначально множество пусто, на рисунке обозначено черным цветом)
* Вершины, до которых известно расстояние (изначально в множестве только одна вершина — начальная, на рисунке обозначено серым цветом)
* Вершины, про которые ничего не известно (изначально — все вершины, кроме начальной, на рисунке обозначено белым цветом)
Очевидно, что, как только все вершины черные, работа алгоритма завершена. Будем хранить все серые вершины в очереди и поддерживать следующее свойство: расстояния до всех серых вершин в том порядке, в котором они лежат в очереди, монотонно не убывают.
Достанем первую вершину из очереди (обозначим ее v). Для каждого из ее соседей w возможен один из двух вариантов:
1. w — черная или серая вершина. В таком случае, мы не получаем никакой новой информации.
2. w — белая вершина. Тогда расстояние до нее равно d(w) = d(v) + 1. И, поскольку мы узнали расстояние, w становится серой вершиной
Повторяем до тех пор, пока есть хотя бы одна серая вершина.
#### Реализация
Предполагается, что граф хранится в массиве vector> edges, причем edges[v] содержит номера всех вершин, к которым есть ребро от v. Также предполагается, что в глобальной переменной start хранится номер начальной вершины.
**BFS**
```
void BFS()
{
queue q;
// Инициализация: есть информация про начальную вершину
q.push(start);
d[start] = 0;
mark[start] = 1;
// Главный цикл - пока есть серые вершины
while (!q.empty())
{
// Берем первую из них
int v = q.front();
q.pop();
// Пробегаемся по всем ее соседям
for (int i = 0; i < (int)edges[v].size(); ++i)
{
// Если сосед белый
if (mark[edges[v][i]] == 0)
{
// То вычисляем расстояние
d[edges[v][i]] = d[v] + 1;
// И он становится серым
mark[edges[v][i]] = 1;
q.push(edges[v][i]);
}
}
}
}
```
#### Почему это работает?
Рассмотрим любую вершину v, достижимую из начальной. Пусть p[0] = start, p[1], ..., p[k] = v — кратчайший путь из начальной вершины в вершину v. Тогда полученное в результате работы алгоритма значение d[v] = k.
Доказательство:
1. d[v] ≤ k
* База: вершина p[0] = start посещается алгоритмом, причем d[p[0]] = 0
* Предположение: вершина p[i — 1] посещается алгоритмом, причем d[p[i]] ≤ i
* Шаг: при рассмотрении вершины p[i — 1] (а может, и раньше) будет рассмотрено ребро, ведущее в вершину p[i]. Таким образом, d[p[i]] ≤ i
2. d[v] ≥ k
Предположим, что d[v] < k. Рассмотрим вершину v; ту вершину, при рассмотрении которой вершина v была покрашена в серый цвет (обозначим ее w); ту вершину, при рассмотрении которой вершина w была покрашена в серый цвет;…; начальную вершину start. Каждые две соседние вершины в этой последовательности соединены ребром по построению алгоритма. Таким образом, мы нашли путь из вершины start до вершины v длиной менее k — противоречие, следовательно, d[v] ≥ k
#### Сложность алгоритма
Для каждого ребра и каждой вершины алгоритм выполняет константное число действий, следовательно, временная сложность — O(V + E).
Максимальное число вершин, одновременно хранящихся в очереди — V, то есть, максимальный объем используемой памяти — O(V).
#### Вместо заключения
В этой статье мы нашли кратчайший путь через лабиринт с использованием одного из самых известных алгоритмов теории графов — BFS.
В следующий раз я постараюсь рассмотреть более сложную задачу на базе нашего любимого лабиринта и, на ее примере, рассказать алгоритм Дейкстры. | https://habr.com/ru/post/200252/ | null | ru | null |
# Настройка пользовательского интерфейса при установке приложений на nanoCAD Plus 8.5
Для значительного числа пользователей установка приложения равнозначна появлению ярлыка на рабочем столе или кнопки на панели инструментов. В данной статье мы рассмотрим механизм добавления меню и панелей инструментов для пользовательских приложений, устанавливаемых на nanoCAD Plus 8.5, а также разберём процедуру создания ярлыка, который позволит запускать конкретное пользовательское приложение в среде nanoCAD.
Для тех, кому интереснее попробовать, чем читать описание, сразу же приводим [ссылку на дистрибутив приложения «Примеры nanoCAD SDK 8.5»](http://ftp.nanocad.ru/habr/Installer8/SamplesApp85_4028.2618.4030.msi). После установки данного приложения при запуске nanoCAD Plus 8.5 будут автоматически загружаться примеры, созданные на LISP, C++, С#, VB.NET, JScript и VBScript, а в пользовательский интерфейс будут добавляться выпадающее меню и панель инструментов (как на заглавном скриншоте), позволяющие вызывать команды примеров.
Для начала проиллюстрируем готовое приложение для установки примеров, идущих в комплекте с nanoCAD Plus 8.5 — «Примеры nanoCAD SDK 8.5», а затем рассмотрим, как включить в его состав файл описания меню и панелей инструментов.
Обзор установщика примеров
--------------------------
Инсталлятор примеров для nanoCAD представляет собой файл в формате Windows Installer с именем SamplesApp<версия>.msi. После запуска он построит список установленных версий nanoCAD, совместимых с инсталлятором, и предложит выбрать, на какие версии устанавливать приложение, а на какие — нет:
Папка установки: C:\Program Files (x86)\Nanosoft\Примеры nanoCAD SDK 8.5\NCAD80x64.
Установленное приложение «Примеры nanoCAD SDK 8.5» следует добавить в список автозагрузки:
При запуске nanoCAD 8.5 в командную строку выводится сообщение о загружаемом приложении:
Загруженные команды можно выполнить:
• из командной строки,
• из установленного вместе с приложением выпадающим меню:
• или при помощи панели инструментов **nanoCAD SDK**, куда вынесены некоторые команды примеров SDK:
Что устанавливает инсталлятор
-----------------------------
Для каждой из выбранных в процессе установки версий nanoCAD, инсталлятор создает директорию с файлами примеров:
Для платформ 8.0-8.5 устанавливается полный набор примеров (папка NCAD80x64), а для предыдущих версий платформы устанавливаются только скрипты (JS, VBS), не требующие пересборки под каждую платформу (папки получают имена по номеру версии: NC70x64 и т.п.). Это не является ограничением технологии установки приложений: если построить примеры SDK всех предыдущих версий, то можно создать единый инсталлятор, который будет устанавливать полный набор примеров на все поддерживаемые платформы.
Файл описания приложения (\*.package)
-------------------------------------
Кроме файлов приложений, в папке с установленными примерами находится файл пакета — с расширением .package, который содержит всю необходимую информацию о пользовательских конфигурациях nanoCAD (включая приложения для загрузки и пользовательские меню) и позволяет загружать выбранную конфигурацию непосредственно при старте nanoCAD.
Рассмотрим пакетный файл для загрузки NRX-модулей из комплекта примеров для nanoCAD. Содержимое файла представляет собой следующую XML-структуру:
```
xml version="1.0" encoding="utf-8" ?
```
Элементы, которые используются для описания пакета:
• ApplicationPackage
• Components
• ConfigEntry
• ComponentEntry
Главный элемент ApplicationPackage содержит атрибут Name для задания имени приложения, которое по окончании загрузки будет отображаться в командной строке.
Элемент Components описывает компоненты пакета: загружаемый модуль приложения – элемент ComponentEntry, а также конфигурационный файл приложения с меню – ConfigEntry.
ComponentEntry содержит атрибуты: AppName — имя приложения, ModuleName – имя исполняемого модуля, ModuleType – тип модуля. Допускается использование следующих типов:
LISP, NRX, MGD, NSF, TX, они же перечислены в списке поддерживаемых типов команды APPLOAD.
Параметры командной строки, создание ярлыка
-------------------------------------------
Дистрибутив «Примеры nanoCAD SDK 8.5» добавляет приложение в автозагрузку и оно загружается при каждом запуске платформы. Рассмотрим ситуацию, когда приложение автоматически загружать не нужно, но оно должно загружаться при запуске nanoCAD с помощью специального ярлыка на рабочем столе Windows.
1. Отключим автозагрузку:
2. Создадим ярлык для «C:\Program Files\Nanosoft\nanoCAD x64 Plus 8.5\nCad.exe» (исходим из того, что вы установили nanoCAD x64 Plus 8.5 на диск C, в папку Program Files), назовем его “nanoCAD Plus 8.5 c Примерами SDK”.lnk.
3. Добавим в командную строку параметры:
a. -r — Название стартовой конфигурации (NCADSamples),
b. -p — Название профиля (если не указан, соответствует названию стартовой конфигурации),
c. -g — путь к загружаемому приложению, может быть указан несколько раз.
При первом запуске при помощи нового ярлыка будет создан профиль, имя которого было указано в командной строке ярлыка:
Важно не путать понятия стартовой конфигурации и профиля:
* Стартовая конфигурация – содержит информацию о том, какой основной и какие дополнительные файлы пользовательского интерфейса (\*.cfg) загружены, а также ссылку на текущий профиль. Предназначена для создания независимых конфигураций (ярлыков), в которых запускаются приложения.
* Профиль – содержит настройки программы. Различные стартовые конфигурации могут как ссылаться на различные, независимые профили, так и использовать одинаковые настройки, ссылаясь на один и тот же профиль.
Заключение
----------
Исходный код инсталлятора примеров для nanoCAD входит в состав SDK. Для того, чтобы собрать инсталлятор самостоятельно, потребуется [WiX Toolset](http://wixtoolset.org) версии 3.8. Пример файла с расширением .cfg также включен в состав SDK, описание процесса создания пользовательской панели инструментов и пользовательского меню nanoCAD приведено в [статье](https://habrahabr.ru/company/nanosoft/blog/239533/). | https://habr.com/ru/post/343496/ | null | ru | null |
# Почему мы пишем бизнес-логику на Lua
Привет, Хабр. В этом посте мы хотим рассказать о том, как и почему мы в IPONWEB используем язык программирования с красивым названием Lua.
Lua — скриптовый встраиваемый язык программирования со свободно распространяемым интерпретатором и открытыми исходными текстами на C. Он был разработан в 1993 году в Бразилии, в подразделении Tecgraf Католического университета Рио-де-Жанейро, а его прародителями были DEL (Data-Entry Language) и SOL (Simple Object Language), разработанные там же ранее. Один из прародителей, язык SOL, косвенно поучаствовал и в «крещении» новорожденного — «Sol» переводится с португальского как «солнце», а новый язык получил имя «Lua», «луна».
Легкость встраивания Lua в написанные на “системных” языках движки сделала его популярным скриптовым языком видеоигр. На Lua написаны, к примеру, скрипты в Grim Fandango и Baldur's Gate. Те, кто играет в World of Warcraft, тоже наверняка слышали о Lua не раз и не два — именно на нем пишут аддоны к игре, облегчающие жизнь хардкорщикам, казуалам, любителям помериться эффективностью и прочим обитателям игрового мира. Вне геймдева Lua используется как скриптовый язык встроенных систем (телевизоров, принтеров, автомобильных панелей), а также приложений, например, медиаплеера VLC Media Player. Lua используют в качестве встроенного языка такие инструменты, как Tarantool, Redis и OpenResty. А еще Lua был использован как язык расширения для расчетных кодов на языке Фортран, моделирующих термомеханическое поведение ядерного топлива.
### Почему Lua?
IPONWEB — разработчик высоконагруженных платформ для компаний, работающих в сфере онлайн-рекламы: DSP, SSP, рекламных агентств и рекламодателей. О нашей работе мы подробно рассказывали [в этой статье](https://habr.com/ru/company/iponweb/blog/437230). Сначала мы разрабатывали бизнес-логику наших платформ на C++, но быстро поняли, что это не лучший выбор. Для минимизации издержек важно быстродействие платформы, а также скорость разработки, и разработка на C++ оказалась для нас слишком медленной, сказалась и сложность добавления функциональности. Мы решили изолировать интерпретацию бизнес-логики от низкоуровневого серверного кода, стали искать подходящий для этого язык и остановились на Lua. Это было в 2008 году, подходящих нам реализаций JavaScript еще не существовало, Perl, Python и Ruby были слишком медленными и недостаточно легко встраивались. И был язык Lua, не слишком известный, но популярный в геймдеве, а то, чего хотели мы, оказалось схоже с потребностями разработчиков игр — нам нужен был быстрый движок для низкоуровневых операций и легко встраиваемый быстрый язык для бизнес-логики.
Lua действительно очень быстрый язык. Дополнительный прирост скорости может дать использование [LuaJIT](https://luajit.org/), среды исполнения для Lua 5.1, включающей в себя трассирующий JIT-компилятор (мы используем собственный форк, о котором уже [писали](https://habr.com/ru/company/iponweb/blog/465441/)). Поскольку мы пишем бизнес-логику для [RTB](http://rtb-media.ru/wiki/)-систем, скорость для нас критически важна: в RTB на обработку каждого входящего запроса есть в среднем 120 миллисекунд. При этом на исполнение кода отводится всего 10-15 миллисекунд, а остальное время занимает ожидание ответа от других сервисов. Если, например, задержку в полсекунды при загрузке сайта в сети пользователь даже не заметит, то для RTB эти 500 миллисекунд — огромный отрезок времени. Ответ на вопрос, насколько быстр язык Lua, таков: он достаточно быстр для того, чтобы мы могли много лет писать на нем бизнес-логику и оставаться в RTB-бизнесе. Будь выбранный нами язык недостаточно быстрым, писать платформу нам было бы не для кого. Означает ли это, что RTB нельзя писать на других языках? Не означает. Но мы пишем RTB на Lua и успешно справляемся со своими и клиентскими бизнес-задачами. Наглядным примером быстродействия Lua на сервере может служить и этот [бенчмарк](https://www.techempower.com/benchmarks/#section=data-r17&hw=ph&test=json) OpenResty.
Lua как встраиваемый язык имеет массу преимуществ: он минималистичный, компактный, с очень маленькой стандартной библиотекой. Его функциональность полностью дублируется на C, что обеспечивает легкое и «бесшовное» взаимодействие Lua и C. У Lua довольно низкий порог входа по сравнению со многими другими языками: большинство программистов, приходящих работать в IPONWEB, никогда раньше не писали на Lua, но им хватает нескольких дней, чтобы полноценно включиться в работу.
Вот простой пример таргетирования рекламной аудитории.
```
-- deal: Объект, задающий условия, на которых продавец готов показать
-- рекламу на своём ресурсе (на сайте, в приложении и т.п.)
-- imp: Рекламный объект (impression opportunity), который
-- покупатель хочет разместить на ресурсе продавца
local function can_be_shown(deal, imp)
local targeting = deal.targeting
-- Никаких ограничений нет
if not targeting then
return true
end
-- Со стороны продавца есть ограничения на тип рекламы
-- (например, можно показывать простые баннеры, а видео нельзя):
if targeting.media_type then
if not passes_targeting(targeting.media_type, imp.details.media_type) then
return false
end
end
-- Со стороны продавца есть ограничения на размер рекламы:
if targeting.size then
if not passes_targeting(targeting.size, imp.details.sizes) then
return false
end
end
return true
end
```
А так выглядит несложный хендлер (обработчик событий).
```
local adm_cache = require 'modules.adm_cache' -- adm = "ad markup"
local config = require 'modules.config'
local util = require 'modules.util'
local AbstractHandler = require 'handlers.abstract'
local ImpRenderHandler = AbstractHandler:new({is_server_request = false})
local IMP_RENDER_TEMPLATE = config.get('imp_render_template')
local IMP_RENDER_BILLING = {name = 'free', type = 'in'}
-- Показать рекламное объявление, выигравшее аукцион.
-- Все показы (как успешные, так и неуспешные) логируются.
-- В случае успешного показа стоимость показа учитывается в бюджетной подсистеме.
function ImpRenderHandler:handle(params)
local user_id = self.uuid
local cache_id = get_param('id')
if not cache_id or cache_id == '' then
return self:process_bad_request({reason = '"id" parameter is expected', user_id = user_id})
end
local adm = adm_cache.get(cache_id)
if not adm then
return self:process_bad_request({reason = 'No adm in cache', user_id = user_id})
end
update_billing(IMP_RENDER_BILLING)
self:log_request('imp_render', {adm = adm, user_id = user_id, cache_id = cache_id})
local content = util.expand_macro(IMP_RENDER_TEMPLATE, {ADM = adm})
return {200, content = content}
end
return ImpRenderHandler
```
Простота Lua не только обеспечивает быструю разработку, но и позволяет делать большую работу малыми силами. Платформа IPONWEB — это общее решение, подстраиваемое под нужды того или иного клиента, при этом проект могут вести один разработчик и один менеджер. Читать код на Lua могут не только сами разработчики, но и менеджеры проектов, а иногда и клиенты. Вместе мы быстрее обнаруживаем проблему, находим ее причину и решение. Зачастую менеджер проекта сообщает разработчику о проблеме и тут же подсказывает путь ее решения.
При этом простота Lua может быть обманчивой, а у минимализма и компактности есть обратная сторона. Если код пишется, например, на Perl или Python, в распоряжении разработчика есть огромные хранилища готовых модулей, у Ruby есть RubyGems, богатыми хранилищами располагают и многие другие языки. А у Lua есть [LuaRocks](https://luarocks.org/) и три тысячи модулей, которые там лежат. Кроме того, даже если на LuaRocks есть нужный модуль, велика вероятность того, что придется еще поработать, чтобы им можно было пользоваться в условиях той или иной компании. Lua дает хорошие средства для создания защищенной среды исполнения кода (песочниц), а при работе в песочницах некоторые функции могут быть отключены. Это означает, что модули LuaRocks могут оказаться нерабочими в случае использования ими функций, заблокированных безопасной средой компании. Такова цена компактности и встраиваемости, но эту цену стоит заплатить — языки “с батарейками”, такие, как, например, Python, встраиваются не в пример сложнее, чем Lua.
### Как это работает?
Основа нашей платформы — кастомизируемый HTTP-сервер с удобным и расширяемым API, предоставляющий Lua-разработчику набор функций и заточенный под задачи рекламного рынка. Этот сервер обрабатывает сотни миллионов запросов и пишет терабайты логов в день. Входящие запросы равномерно распределяются по системным тредам, а внутри системных тредов находятся песочницы.
Когда на сервер приходит запрос, внутри песочницы, в которую этот запрос попал, создается [корутина](https://lua-users.org/wiki/CoroutinesTutorial), которая осуществляет обработку запроса. Корутины работают независимо друг от друга, каждая создающаяся корутина ставится в очередь на исполнение. Время жизни каждой корутины (полное время обработки запроса с учетом ожидания ответа вовлеченных служб: базы данных, метрик, бюджетного сервера) не должно превышать 120 миллисекунд.
Вкратце процесс обработки запроса можно описать так:
1. Каждый полученный запрос парсится и проходит стандартную проверку на корректность.
2. Запускается корутина, отвечающая за обработку этого запроса. Внутри каждой песочницы работает множество корутин, находящихся в разном статусе.
3. Запускается обработка запроса, у которой может быть два результата:
* Обработка успешно завершается.
* Корутина передает управление серверу. Обычно это происходит, когда корутина ждет ответ от других сервисов. В таких случаях работа корутины приостанавливается до тех пор, пока не приходит ответ или не истекает время ожидания. При передаче управления сервер запускает обработку следующего запроса. Это может быть как новый запрос, так и запрос, получивший ответ от всех вовлеченных сервисов и готовый продолжить исполнение кода. Очередность обработки запросов определяется требованиями бизнес-логики.
Использование корутин — отдельная интересная тема, заслуживающая подробного разговора. Например, в [этой статье](https://habr.com/ru/post/427135/) подробно рассказано о том, как можно использовать корутины при создании катсцен в видеоиграх. А корутинам на сервере приложений стоит посвятить отдельную статью, и, возможно, в будущем мы это сделаем.
### Что дальше?
А дальше, возможно, применение Lua в IPONWEB будет расширено. У нас есть идеи о том, как еще можно использовать Lua в нашем бизнесе, и когда эти идеи будут воплощены в жизнь, мы обязательно поделимся новым опытом. Удобство и возможности Lua как встраиваемого скриптового языка могут помочь нам, в частности, ускорить обработку клиентских данных. Но это пока из области планов и перспектив.
Подводя итог, можно сказать, что наш выбор языка бизнес-логики, сделанный 11 лет назад, продолжает оправдывать себя, позволяя нам успешно справляться с собственными бизнес-задачами и помогать нам в решении задач наших клиентов. Легко читаемый, легко встраиваемый, быстрый и несложный в освоении, Lua был и остается одним из лучших скриптовых языков, сфера применения которого отнюдь не ограничивается разработкой игр. Написанная на нем бизнес-логика IPONWEB — только один из подтверждающих это примеров. | https://habr.com/ru/post/469049/ | null | ru | null |
# Логирование Git revision в Java с помощью Maven
Наша компания перешла с [mercurial](https://ru.wikipedia.org/wiki/Mercurial) на [Git](https://ru.wikipedia.org/wiki/Git), после чего мне пришлось разобраться как у нас до этого выводилась в лог информация о развертывающейся ветки и переписать это под git. Возможно, кто-то в будущем столкнется с такой же проблемой, так как Git набирает популярность и многие компании мигрируют на него.
Моя цель показать Вам, как с помощью нескольких maven plugin-ов можно сделать вывод в лог Вашей java программы названия ветки и хэш коммита из Git. Это полезно при анализе логов, если у Вас давно не было деплоя и история Вашего инструмента CI затерлась.
### Начало
В моем примере я буду использовать: java, maven, spring-core, git. Ссылка на [пример](https://github.com/scorpioa/gitrevision). Предположим, что у нас уже имеется проект, написанный на Java и для сборки используется Maven, также он хранится на [GitHub](https://github.com).
### Maven SCM
Для того чтобы maven мог получить доступ к Вашему репозиторию, нужно указать ему методы и пути подключения. Для этого нужно использовать [maven scm](https://maven.apache.org/scm/maven-scm-plugin/usage.html):
```
...
scm:git:https://github.com//.git
scm:git:https://github.com//.git
HEAD
https://github.com//.git
...
```
Ссылку для доступа формируется на веб-странице Git-а Вашего проекта в разделе Quick setup. Подробнее об использовании scm и вариантах получения доступа к репозиторию можно прочитать [здесь](https://maven.apache.org/scm/maven-scm-plugin/usage.html) и [здесь](https://maven.apache.org/scm/maven-scm-plugin/).
### Получение информации о текущей ветки git
Далее нам потребуется добавить maven plugin [buildnumber-maven-plugin](http://www.mojohaus.org/buildnumber-maven-plugin/usage.html), который будет формировать **buildNumber** — хэш коммита и **scmBranch** — название ветки.
```
org.codehaus.mojo
buildnumber-maven-plugin
1.4
validate
create
false
false
```
Формирование buildNumber и scmBranch происходит на этапе **validate**, который происходит после **clean** в Maven.
Параметры:
* doCheck — если true, то проект не скомпилируется пока в нем есть локальные изменения
* doUpdate — позволяет Maven обновить Вашу текущую ревизию
Больше информации об [этом](http://www.mojohaus.org/buildnumber-maven-plugin/usage.html).
### Работа с properties
После этого вы можете смело добавлять в Ваш **application.properties** файл следующие переменные: ${buildNumber} и ${scmBranch}
Например я в **application.properties** добавил следующие параметры:
```
branch.name=${scmBranch}
commit.hash=${buildNumber}
application.version=${project.version}
```
Чтобы наш **application.properties** был найдет, в тэг **build** нужно добавить:
```
src/main/resources
true
```
### Сборка проекта
Давайте теперь соберем наш проект командой:
```
mvn clean install -DskipTests
```
Если вы посмотрите лог, который Вам вывел maven при сборке, то заметите что он выполняет команду git для получения искомых данных:
```
[INFO] --- buildnumber-maven-plugin:1.4:create (default) @ GitRevision ---
[INFO] Executing: /bin/sh -c cd '/home//Development/GitRevision' && 'git' 'rev-parse' '--verify' 'HEAD'
[INFO] Working directory: /home//Development/GitRevision
[INFO] Storing buildNumber: 47c0d1df153b8610392d51d1a7fa0b7b39716e09 at timestamp: 1474375934082
[INFO] Storing buildScmBranch: master
```
Также Вы можете проверить корректность полученных данных в папке **target/classes** файл **application.properties**:
Содержимое:
```
branch.name=master
commit.hash=47c0d1df153b8610392d51d1a7fa0b7b39716e09
application.version=0.0.1-SNAPSHOT
```
### Добавление в лог
Для получения свойств в любом классе, с которым работает spring используется аннотация **@Value**.
Пример:
```
public class LoggerExampleImpl implements LoggerExample {
private static final Logger log = LoggerFactory.getLogger(LoggerExampleImpl.class);
@Value("${branch.name}")
private String branchName;
@Value("${commit.hash}")
private String commitHash;
@Value("${application.version}")
private String version;
public void printLog() {
log.info("Project version: {}, git branch: {}, commit hash: {}",
version, branchName, commitHash);
}
}
```
Пример класса с main методом:
```
public class GitRevisionApplication {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
LoggerExample loggerExample = context.getBean(LoggerExampleImpl.class);
loggerExample.printLog();
}
}
```
Если мы запустим наше программу, то получим:
```
2016-09-20 17:06:07 INFO [main] ClassPathXmlApplicationContext:581 - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@66cd51c3: startup date [Tue Sep 20 17:06:07 EEST 2016]; root of context hierarchy
2016-09-20 17:06:07 INFO [main] XmlBeanDefinitionReader:317 - Loading XML bean definitions from class path resource [spring.xml]
2016-09-20 17:06:07 INFO [main] PropertyPlaceholderConfigurer:172 - Loading properties file from URL [file:/home/rado/Development/GitRevision/target/classes/application.properties]
2016-09-20 17:06:08 INFO [main] LoggerExampleImpl:25 - Project version: 0.0.1-SNAPSHOT, git branch: master, commit hash: 52c05227fb27271314d80d39b5026193ff310f04
```
### Сокращение хэша
Хэш нашего коммита слишком длинный, чтобы его урезать нужно указать в **buildnumber-maven-plugin** максимальное количество символов, которые мы хотим вывести:
```
5
```
### Расширить git данными MANIFEST.MF
Есть возможность добавить эти данные в MANIFEST.MF. Для этого нам необходимо подключить еще один maven plugin: [maven-jar-plugin](https://maven.apache.org/plugins/maven-jar-plugin/).
```
org.apache.maven.plugins
maven-jar-plugin
2.3.1
true
true
${project.version}-${buildNumber}
${scmBranch}
com.habrahabr.example.GitRevisionApplication
```
После сборки нашего проекта мы сможем увидеть в **MANIFEST.MF**:
```
Manifest-Version: 1.0
Archiver-Version: Plexus Archiver
Created-By: Apache Maven
Built-By: rado
Build-Jdk: 1.8.0_102
Specification-Title: GitRevision
Specification-Version: 0.0.1-SNAPSHOT
Implementation-Title: GitRevision
Implementation-Vendor-Id: com.habrahabr.example
Implementation-Build: master
Implementation-Version: 0.0.1-SNAPSHOT-47c0d1df153b8610392d51d1a7fa0b7
b39716e09
Main-Class: com.habrahabr.example.GitRevisionApplication
```
Спасибо. Надеюсь, статья окажется полезна. | https://habr.com/ru/post/310738/ | null | ru | null |
# Java 14: записи (records preview)
В скором времени в [грядущей Java 14](https://openjdk.java.net/projects/jdk/14/) появится новая синтаксическая фича — *записи* (records). После изучения [превью](https://openjdk.java.net/jeps/359), в котором вкратце описано, как выглядят записи и с “чем их едят”, я осмелился адаптировать документ на русский для хабра. Кому интересно — добро пожаловать под кат.
### Резюме
Записи позволяют расширить возможности Java. Они обеспечивают лаконичный синтаксис для объявления тех классов, которые являются простыми носителями постоянных, неизменяемых наборов данных.
### Причины и цели
Жалобы на то, что “Java слишком многословен” и что с ним нужно много “церемониться” достаточно распространены. Причина тому классы, которые предназначены лишь для хранения некого набора данных. Чтобы правильно написать такой класс, нужно прописать много формального, повторяющегося и подверженного ошибкам кода: конструкторы, геттеры и сеттеры, equals (), hashCode (), toString () и т.д. Разработчики иногда халтурят и не переопределяют equals () и hashCode (), что в свою очередь может привести к нестандартному поведению или проблемам с отладкой. Либо, когда разработчики не хотят объявлять еще один класс, они прописывают альтернативный, но не совсем подходящий, только потому, что он имеет “правильную форму”.
Среды разработки помогут прописать большую часть кода в классе, но не помогут разработчику, читающему этот код, быстро сориентироваться среди десятков строк шаблонного кода и понять, что этот класс является обычным носителем данных. Java-код, моделирующий наборы стандартных данных, должен быть простым для написания, восприятия и проверки.
На первый взгляд может показаться, что записи предназначены для сокращения шаблонного кода. Мы же вкладываем в них семантическую цель: *“моделирование данных как данных”* (modeling data as data). Если семантика верна, то шаблонный код сделает все сам без участия разработчика. Ведь объявление постоянных наборов данных должно быть легким, ясным и лаконичным.
### Цели, которых не было
Мы не ставили перед собой цель “объявить войну” шаблонному коду. В частности, мы не намеревались решить проблему изменяемых классов c использованием соглашения о наименованиях JavaBean-компонентов. Несмотря на то что свойства, метапрограммирование и генерация кода на основе аннотаций часто предлагаются в качестве «решений» этой проблемы, добавлять эти фичи также не было нашей целью.
### Описание
Записи — это новый вид объявления типа в Java. Так же, как и enum, записи представляет собой ограниченный по функциональности класс. Он объявляет свое представление и предоставляет API, который основывается на этом представлении. Записи не отделяют API от представления и, в свою очередь, являются краткими.
Запись содержит имя и описание состояния. Описание состояния объявляет компоненты этой записи. Опционально, запись может иметь тело. Например:
```
record Point(int x, int y) { }
```
Поскольку семантически записи являются простыми носителями данных, они автоматически получают стандартные элементы:
* Приватное финальное поле для каждого компонента состояния;
* Публичный метод чтения для каждого компонента состояния с тем же именем и типом, что и у компонента;
* Публичный конструктор, совпадающий с сигнатурой записи; он инициализирует каждое поле из соответствующего аргумента;
* Реализации equals() и hashCode(), которые говорят, что две записи равны, если они одного типа и содержат одинаковое состояние;
* Реализация toString(), которая включает строковое представление всех компонентов записи с их именами.
Другими словами, представление записи полностью основано на описании состояния. Также на основе состояния записи происходит формирование equals(), hashCode() и toString().
### Ограничения
Записи не могут наследовать какой-либо другой класс и не могут объявлять поля объекта, кроме приватных финальных полей, которые соответствуют компонентам состояния. Любые другие объявленные поля должны быть статическими. Эти ограничения гарантируют, что описание состояния само по себе определяет представление.
Записи являются финальными и не могут быть абстрактными. Эти ограничения указывают на то, что API записи определяется только описанием состояния и его нельзя будет расширить позже при помощи другого класса или записи.
Компоненты записи являются финальными. Это ограничение реализует принцип “неизменный по умолчанию”, который широко применяется для наборов данных.
Помимо упомянутых выше ограничений, записи ведут себя как обычные классы: они могут быть объявлены как верхнеуровневые или вложенные, могут быть дженериками, могут реализовывать интерфейсы. Записи создаются с помощью вызова оператора new. Тело записи может объявлять статические методы, статические поля, статические блоки инициализации, конструкторы, методы экземпляров, блоки инициализации экземпляра и вложенные типы. Запись и отдельные компоненты состояния могут быть помечены аннотациями. Если запись является вложенной, значит она статична; это исключает ситуацию с вложенными экземплярами, которые могли бы автоматически добавлять состояние к записи.
### Явно объявляемые элементы записи
Хотя стандартная реализация геттеров, а также методов equals(), hashCode() и toString() является вполне приемлемой для большинства вариантов использования записей, у разработчика есть возможность переопределить стандартную реализацию. Однако, следует быть особенно осторожным при переопределении методов equals / hashCode.
Особое внимание уделяется явному объявлению канонического конструктора, сигнатура которого совпадает с описанием состояния записи. Конструктор может быть объявлен без формального списка параметров: в этом случае предполагается, что он совпадает с описанием состояния, а любые поля записи неявно инициализируются при стандартном закрытии тела конструктора из соответствующих формальных параметров (this. х = х) на выходе. Это позволяет каноническому конструктору выполнять только проверку и корректировку своих параметров, а также пропускать явную инициализацию полей. Например:
```
record Range(int lo, int hi) {
public Range {
if (lo > hi) /* referring here to the implicit constructor parameters */
throw new IllegalArgumentException(String.format("(%d,%d)", lo, hi));
}
}
```
### Грамматика
```
RecordDeclaration:
{ClassModifier} record TypeIdentifier [TypeParameters]
(RecordComponents) [SuperInterfaces] [RecordBody]
RecordComponents:
{RecordComponent {, RecordComponent}}
RecordComponent:
{Annotation} UnannType Identifier
RecordBody:
{ {RecordBodyDeclaration} }
RecordBodyDeclaration:
ClassBodyDeclaration
RecordConstructorDeclaration
RecordConstructorDeclaration:
{Annotation} {ConstructorModifier} [TypeParameters] SimpleTypeName
[Throws] ConstructorBody
```
### Аннотации для компонентов записи
Для компонентов записи можно применять аннотации объявлений, если они распространяются на компоненты, параметры, поля или методы. Аннотации объявлений, применимые к любому из этих компонентов, распространяются на неявные объявления любых обязательных элементов.
Аннотации типов, которые изменяют типы компонентов записи, распространяются на типы в неявных объявлениях обязательных элементов (например, параметров конструктора, объявлений полей и методов). Явные объявления обязательных элементов должны точно совпадать с типом соответствующего компонента записи, не включая аннотации типов.
### Рефлексия (Reflection API)
В *java.lang.Class* будут добавлены следующие публичные методы:
* *RecordComponent[] getRecordComponents()*
* *boolean isRecord()*
Метод *getRecordComponents()* возвращает массив *java.lang.reflect.RecordComponent*, где *java.lang.reflect.RecordComponent* — это новый класс.
Элементы этого массива соответствуют компонентам записи и идут в том же порядке, в котором объявлены в записи. Дополнительную информацию можно извлечь из каждого *RecordComponent* в массиве, включая имя, тип, дженерик, а также получить его значение.
Метод *isRecord()* возвращает *true* в случае, если данный класс объявлен в качестве записи. (Аналогично методу *isEnum()*).
### Альтернативы
Записи можно определить как условную форму кортежей. Вместо записей, мы можем использовать структурные кортежи. Несмотря на то, что кортежи предлагают более легковесные способы выражения некоторых наборов данных, результат часто является менее информативным:
* Главный принцип Java-философии состоит в том, что **имена имеют значение**. Классы и их элементы носят имена, релевантные их содержанию, в то время как кортежи и их компоненты — нет. То есть, класс *Person* со свойствами *firstName* и *lastName* более понятен и надежен, чем анонимный кортеж из *String* и *String*.
* Классы поддерживают валидацию состояния через свои конструкторы, кортежи — нет. Некоторые наборы данных, например числовые диапазоны, имеют инварианты, на которые впоследствии можно ссылаться, если они применяются конструктором;
* Классы могут обладать поведением, основанном на их состоянии; совмещение состояния и поведения делает само поведение более явным и доступным. Кортежи, представляя собой просто набор данных, не предлагают такой возможности.
### Зависимости
Записи хорошо сочетаются с [изолированными типами (JEP 360)](https://openjdk.java.net/jeps/360); вместе с изолированнами типами, записи образуют конструкцию, часто называемую [алгебраическими типами данных.](https://en.wikipedia.org/wiki/Algebraic_data_type) Кроме того, записи сами по себе допускают [pattern matching](https://cr.openjdk.java.net/~briangoetz/amber/pattern-match.html). Поскольку записи связывают свой API с описанием состояния, мы в конечном итоге можем также получать паттерны деконструкции (deconstruction patterns) для записей и использовать информацию изолированных классов в операторе *switch*. | https://habr.com/ru/post/484700/ | null | ru | null |
# Navigation Component-дзюцу, vol. 3 — Corner-кейсы
В этой части трилогии про Navigation Component разберем как организовать навигацию в многомодульных приложениях, как работается с диплинками, а также рассмотрим кейсы со встраиваемыми фрагментами и диалогами.
Это третья и заключительная статья в цикле про различные кейсы навигации с Navigation Component-ом. Вы также можете ознакомиться с [первой](https://habr.com/ru/company/hh/blog/518332/) и [второй](https://habr.com/ru/company/hh/blog/519162/) частями
---
**UPDATE 30.12.2020:**
Выводы по поводу крашей диплинков, сделанные в этой статье, некорректны, так как при настройке BottomNavigationView из первой статьи была допущена серьёзная ошибка, которая и привела к множеству крашей. Подробности — в [последней статье цикла](https://habr.com/ru/company/hh/blog/535534/).
---
Навигация в многомодульных приложениях
--------------------------------------
Если вы работаете с большим приложением, вероятно, вы уже разбили его на модули. Неважно, как именно. Может быть, вы создаёте отдельные модули для логики и UI, а может храните всю логику фичи (от взаимодействия с API до логики presentation-слоя) в одном модуле. Главное – у вас могут быть кейсы, когда требуется осуществить навигацию между двумя независимыми модулями.
**Где на схеме приложения кейсы с навигацией?**
На картинке мы видим, что у нас есть как минимум два модуля: модуль `:vacancy` с одним экраном и модуль `:company` с двумя экранами вложенного flow. В рамках моего примера я построил навигацию из модуля `:vacancy` в модуль `:company`, которые не связаны друг с другом.
Существует три способа как это сделать, разберём их один за другим.
### App-модуль + интерфейсы
[Первый способ](https://github.com/Android-Academy-Global/AAGlobal-NavigationComponentPlayground/commit/1fcecd07993e2aa9b207eafd485a788e790463df) – использовать ваш application-модуль в качестве хранилища всего графа навигации и определить в feature-модулях специальные интерфейсы для роутинга.
**Структура вашего приложения в этом способе**
Структура приложения будет стандартной: есть app-модуль, который знает обо всех feature-модулях, есть feature-модули, которые не знают друг о друге. В этом способе ваши feature-модули пребывают в священном неведении о Navigation Component, и для навигации они будут определять интерфейсы примерно вот такого вида:
```
// ::vacancy module
interface VacancyRouterSource {
fun openNextVacancy(vacancyId: String)
// For navigation to another module
fun openCompanyFlow()
}
```
А ваш app-модуль будет реализовывать эти интерфейсы, потому что он знает обо всех action-ах и навигации:
```
fun initVacancyDI(navController: NavController) {
VacancyDI.vacancyRouterSource = object : VacancyRouterSource {
override fun openNextVacancy(vacancyId: String) {
navController.navigate(
VacancyFragmentDirections
.actionVacancyFragmentToVacancyFragment(vacancyId = vacancyId)
)
}
override fun openCompanyFlow() {
initCompanyDI(navController)
navController.navigate(R.id.action__VacancyFragment__to__CompanyFlow)
}
}
}
```
Плюс этого способа – отсутствие дополнительных модулей, которые могут повлиять на скорость сборки приложения. Однако в минусах вы получаете:
* дополнительную работу в виде определения интерфейсов, реализаций, организации DI для проброса этих интерфейсов в ваши feature-модули;
* отсутствие возможности использовать использовать `Safe Args` плагин, делегат `navArgs`, сгенерированные `Directions`, и другие фишки Navigation Component-а в feature-модулях, потому что эти модули ничего не знают про библиотеку.
Сомнительный, в общем, способ.
### Графы навигации в feature-модулях + диплинки
[Второй способ](https://github.com/Android-Academy-Global/AAGlobal-NavigationComponentPlayground/commit/1bcbb70585e4d165a73b8496e362d0b482968808) – вынести отдельные графы навигации в feature-модули и использовать поддержку навигации по диплинкам (она же – навигация по URI, которую [добавили в Navigation Component 2.1](https://developer.android.com/jetpack/androidx/releases/navigation#version_210_3)).
**Структура вашего приложения в этом способе**
Структура приложения будет ровно такой же, как и в первом способе: есть app-модуль, который зависит от всех feature-модулей, и есть feature-модули, которые друг о друге ничего не знают.
Но теперь ваш app-модуль не обязан содержать весь граф навигации приложения, он может содержать только его часть. А остальные кусочки будут содержать именно feature-модули.
```
```
Feature-модули будут определять свои собственные графы навигации для роутинга между экранами, о которых они знают. А ещё они будут объявлять диплинки для тех экранов, на которые можно попасть из других модулей. В примере выше мы добавили тэг `deepLink`, чтобы на экран `CompanyFragment` можно было попасть из другого модуля.
После этого мы можем использовать этот диплинк для открытия экрана `CompanyFragment` из модуля `:vacancy` :
```
// ::vacancy module
fragment_vacancy__button__open_company_flow.setOnClickListener {
// Navigation through deep link
val companyFlowUri = "companyflow://company".toUri()
findNavController().navigate(companyFlowUri)
}
```
Плюс этого метода в том, что это самый простой способ навигации между двумя независимыми модулями. А минус – что вы не сможете использовать `Safe Args`, или «сложные» типы аргументов (`Enum`, `Serializable`, `Parcelable`) при навигации между фичами.
P.S. Есть, конечно, вариант сериализовать ваши сложные структуры в `JSON` и передавать их в качестве String-аргументов в диплинк, но это как-то… Странно.
### Общий модуль со всем графом навигации
[Третий способ](https://github.com/Android-Academy-Global/AAGlobal-NavigationComponentPlayground/commit/4933a9db4f900c972e1ecdf573e3a8a4252eb611) – ввести для хранения всего графа навигации специальный модуль, который будет подключаться к каждому feature-модулю.
**Структура вашего приложения в этом способе**
У нас по-прежнему есть app-модуль, но теперь его задача – просто подсоединить к себе все feature-модули; он больше не хранит в себе граф навигации. Весь граф навигации теперь располагается в специальном модуле, который ничего не знает о feature-модулях. Зато каждый feature-модуль знает про `common navigation`.
В чём соль? Несмотря на то, что common-модуль не знает о реализациях ваших destination-ов (фрагментах, диалогах, activity), он всё равно способен объявить граф навигации в XML-файлах! Да, Android Studio начинает сходить с ума: все имена классов в XML-е горят красным, но, несмотря на это, все нужные классы генерируются, `Safe Args` плагин работает как нужно. И так как ваши feature-модули подключают к себе common-модуль, они могут свободно использовать все сгенерированные классы и пользоваться любыми action-ами вашего графа навигации.
Плюс этого способа – наконец-то можно пользоваться всеми возможностями Navigation Component-а в любом feature-модуле. Из минусов:
* добавился ещё один модуль в critical path каждого feature-модуля, которому потребовалась навигация;
* отсутствует автоматический рефакторинг имён: если вы поменяете имя класса какого-нибудь destination-а, вам нужно будет не забыть, что надо поправить его в common-модуле.
### Выводы по навигации в многомодульных приложениях
* У вас на выбор целых три способа организации межмодульной навигации.
* Выбирайте тот, который вам нравится, понятен и, главное, который вам проще реализовать.
Работа с диплинками
-------------------
Практически каждое большое приложение должно уметь поддерживать диплинки. И практически каждый Android-разработчик мечтал о простом способе работы с этими «глубокими ссылками». Окей, я мечтал. И казалось, что Navigation Component – ровно то, что нужно.
По моей задумке кейсы с диплинками должны были занимать довольно большую часть переходов тестового приложения.
**Какую именно часть?**
У меня было три кейса с диплинками, которые я хотел реализовать с помощью Navigation Component.
* **Открытие определённой вкладки нижней навигации** – допустим, я хочу через диплинк открыть вторую вкладку на главном экране после Splash-экрана
**Посмотреть на картинке**
Допустим, я хочу через диплинк открыть вкладку Favorites нижней навигации на главном экране после Splash-экрана:
* **Открытие определённого экрана ViewPager-а внутри конкретной вкладки нижней навигации**
**Посмотреть на картинке**
Пусть я хочу открыть определённую вкладку ViewPager-а внутри вкладки Responses:
* **Открытие экрана, который требует авторизации пользователя** – пусть теперь для корректной работы вкладки нижней навигации требуется авторизация. И с помощью диплинка я хочу сначала показать Splash-экран, затем открыть флоу авторизации, а когда пользователь его пройдёт, открыть нужную вкладку
**Посмотреть на картинке**
Пусть вкладка Profile теперь требует авторизации. И с помощью диплинка я хочу сначала показать Splash-экран, затем открыть флоу авторизации, а когда пользователь его пройдёт – открыть вкладку Profile.
Сразу скажу, что у меня **не получилось** нормально реализовать ни один из этих кейсов. И работа с диплинками в Navigation Component стала для меня самым большим разочарованием.
### Диплинк для определённой вкладки нижней навигации
Прежде чем делать диплинк для второй вкладки, я решил настроить ссылку хотя бы для первой. Я решил, что для этого будет достаточно просто добавить диплинк на экран контейнера нижней навигации (не самой вкладки, а контейнера):
```
```
Затем я, следуя документации, добавил граф навигации с диплинком в Android Manifest:
```
```
А потом решил проверить, работает ли то, что я настроил при помощи простой adb-команды:
```
adb shell am start \
-a android.intent.action.VIEW \
-d "https://www.example.com/main" com.aaglobal.jnc_playground
```
И-и-и… нет. Ничего не завелось. Я получил [краш приложения](https://github.com/Android-Academy-Global/AAGlobal-NavigationComponentPlayground/commit/a61cf67793052f44d175c6084d04bceaf9d95f70) с уже знакомым исключением – IllegalStateException: FragmentManager is already executing transactions. Дебаггер указывал на код, связанный с настройкой нижней навигации, поэтому я решил просто обернуть эту настройку в очередной Handler.post:
```
// MainFragment.kt — fragment with BottomNavigationView
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
if (savedInstanceState == null) {
safeSetupBottomNavigationBar()
}
}
private fun safeSetupBottomNavigationBar() {
Handler().post {
setupBottomNavigationBar()
}
}
```
Это исправило краш, но приложение всё равно [работало неправильно](https://github.com/Android-Academy-Global/AAGlobal-NavigationComponentPlayground/commit/e5551159f179608041b2050d1f0c10fcdedf876f): запустив диплинк, мы пропустили Splash-экран, он просто не запускался. А это означает, что не отрабатывал код, который отвечал за инициализацию моего приложения.
Это произошло, потому что в нашем случае путь диплинка был таким: мы запустили приложение, запустилась его единственная Activity. В вёрстке этой activity мы инициализировали первый граф навигации. В этом графе оказался элемент, который удовлетворял `URI`, мы отправили его через adb-команду – вуаля, он сразу и открылся, проигнорировав указанный в графе `startDestination`.
Тогда я решил перенести диплинк в другой граф – внутрь вкладки нижней навигации.
```
```
И, запустив приложение, я получил ЭТО:
**Посмотреть на ЭТО**
На гифке видно, как приложение запустилось, и мы увидели Splash-экран. После этого на мгновение показался экран с нижней навигацией, а затем приложение словно запустилось заново! Мы снова увидели Splash-экран, и только после его повторного прохождения появилась нужная вкладка нижней навигации.
И что самое неприятное во всей этой истории – это не баг, а **фича**.
Если почитать внимательно [документацию про работу с диплинками](https://developer.android.com/guide/navigation/navigation-deep-link#explicit) в Navigation Component, можно найти следующий кусочек:
> When a user opens your app via an explicit deep link, the task back stack is cleared and replaced with the deep link destination.
>
>
То есть наш back stack специально очищается, чтобы Navigation Component-у было удобнее работать с диплинками. Говорят, что когда-то давно, в бета-версии библиотеки всё работало адекватнее.
Мы **можем** это исправить. Корень проблемы – в методе `handleDeepLink` NavController-а:
**Кусочек handleDeepLink**
```
public void handleDeepLink(@Nullable Intent intent) {
// ...
if ((flags & Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {
// Start with a cleared task starting at our root when we're on our own task
if (!mBackStack.isEmpty()) {
popBackStackInternal(mGraph.getId(), true);
}
int index = 0;
while (index < deepLink.length) {
int destinationId = deepLink[index++];
NavDestination node = findDestination(destinationId);
if (node == null) {
final String dest = NavDestination.getDisplayName(mContext, destinationId);
throw new IllegalStateException("Deep Linking failed:"
+ " destination " + dest
+ " cannot be found from the current destination "
+ getCurrentDestination());
}
navigate(node, bundle,
new NavOptions.Builder().setEnterAnim(0).setExitAnim(0).build(), null);
}
return true;
}
}
```
Чтобы переопределить это поведение, нам потребуется:
* почти полностью скопировать к себе исходный код Navigation Component;
* добавить свой собственный NavController с исправленной логикой (добавление исходного кода библиотеки необходимо, так как от NavController-а зависят практически все элементы библиотеки) – назовём его `FixedNavController`;
* заменить все использования исходного NavController-а на FixedNavController.
Несложно, правда? Но кажется, что это уже слишком. Подобные исправления заставляют нас в будущем тратить всё больше и больше времени на поддержку нашего кастомного решения, ведь нужно будет обновлять свой фикс при каждом обновлении библиотеки. Около года назад коллеги из Яндекса столкнулись с похожей проблемой, и им пришлось делать примерно то же самое. Сочувствую.
В этот невесёлый момент я заметил ещё один баг, который был добавлен при попытке исправить краш с диплинками: сломалась обратная навигация из auth-флоу.
**Покажи гифку**
На гифке видно, как мы переключаемся на вкладку Profile, затем переходим во флоу авторизации. Потом мы нажимаем на кнопку Back и получаем просто белый экран. Если переключиться на какую-нибудь другую вкладку и обратно, то мы снова увидим контент вкладки Profile.
Для этой проблемы я уже даже не стал искать решение, потому что чертовски устал от этих войн за каждый кейс навигации. Если знаете как исправить, отпишитесь в комментариях, пожалуйста.
### Диплинк на экран ViewPager-а внутри вкладки нижней навигации
Если у вас будет свой собственный NavController, корректно обрабатывающий диплинки, реализовать этот кейс будет просто.
В NavController-е есть специальный булевский флажок – `isDeepLinkHandled`, – который говорит нам, что текущий NavController успешно обработал диплинк. Вы могли бы добавить диплинк, ведущий на фрагмент, который содержит в себе ViewPager, затем написать примерно вот такой код, чтобы перейти на нужную вкладку:
```
if (findMyNavController().isDeepLinkHandled && requireActivity().intent.data != null) {
val uriString = requireActivity().intent.data?.toString()
val selectedPosition = when {
uriString == null -> 0
uriString.endsWith("favorites") -> 0
uriString.endsWith("subscribes") -> 1
else -> 2
}
fragment_favorites_container__view_pager.setCurrentItem(selectedPosition, true)
}
```
Но, опять же, это будет доступно только в случае, если вы уже добавили к себе в кодовую базу свою реализацию NavController-а, ведь флаг `isDeepLinkHandled` является private-полем. Ок, можно достучаться до него через механизм `reflection`-а, но это уже другая история.
### Диплинк на экран, требующий авторизацию
Navigation Component не поддерживает диплинки с условием из коробки. Если вы хотите поддержать такое поведение, Google предлагает действовать следующим образом:
* через диплинк открыть экран, который требует авторизацию;
* на этом экране проверить, авторизован ли пользователь, если нет – открыть флоу авторизации поверх нужного экрана;
* пройти auth flow, вернуть результат из вложенного графа и т.д., и т.п.
Возможности глобально решить мою задачу средствами Navigation Component-а я не нашёл.
### Выводы по работе с диплинками в Navigation Component
* Работать с ними больно, если требуется добавлять дополнительные действия или условия.
* Объявлять диплинки ближе к месту их назначения – классная идея, в разы удобнее AndroidManifest-а со списком поддерживаемых ссылок.
Бонус-секция – кейсы БЕЗ проблем
--------------------------------
Чтобы разбавить негатив от предыдущей секции, я покажу пару кейсов, с которыми вообще не было проблем. А я их ждал. Но их не было.
### Навигация с экрана в экран
Допустим, у вас есть экран вакансий, с которого вы можете перейти на другую вакансию.
**Где на схеме приложения этот кейс?**
По опыту предыдущих кейсов я ожидал проблем и здесь, но всё оказалось достаточно просто – я определил навигацию с экрана на экран:
```
```
И этого оказалось достаточно – новый экран открывался поверх старого, при нажатии на кнопку Back навигация была корректной. Если бы я захотел, чтобы каждый новый экран открывался вместо текущего, было бы достаточно добавить атрибут `popUpTo` к моему action-у.
### Навигация из встраиваемых фрагментов
В приложении hh есть специальный фрагмент для управления поисковыми выдачами. В нём мы инкапсулировали всю логику, связанную с отображением списка вакансий, чтобы можно было встраивать этот фрагмент в другие экраны. Пусть я задумал добавить подобный фрагмент на несколько вкладок моей нижней навигации так, чтобы при нажатии на элемент списка внутри этого фрагмента у меня открывался соответствующий экран.
**Где на схеме приложения этот кейс?**
Я добавил контейнер для будущего фрагмента со списком в вёрстку вкладки нижней навигации:
```
```
А затем в runtime-е добавил нужный мне фрагмент в этот контейнер:
```
class FavoritesContainerFragment : Fragment(R.layout.fragment_favorites_container) {
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
childFragmentManager.attachFragmentInto(
containerId = R.id.fragment_container_view,
fragment = createVacancyListFragment()
)
}
}
```
Метод `attachFragmentInfo` на `childFragmentManager` – это extension-метод, который просто оборачивает всю работу с транзакциями, не более того.
А вот как я создал фрагмент:
```
class FavoritesContainerFragment : Fragment(R.layout.fragment_favorites_container) {
// ...
private fun createVacancyListFragment(): Fragment {
return VacancyListFragment.newInstance(
vacancyType = "favorites_container",
vacancyListRouterSource = object : VacancyListRouterSource {
override fun navigateToVacancyScreen(item: VacancyItem) {
findNavController().navigate(
R.id.action__FavoritesContainerFragment__to__VacancyFragment,
VacancyFragmentArgs(vacancyId = "${item.name}|${item.id}").toBundle()
)
}
}
}
}
```
Вся соль в пробросе реализации интерфейса для навигации – я инициализирую нужный мне фрагмент правильным навигатором, который будет срабатывать при нажатии на элемент списка.
### Навигация между диалогами
Пусть у меня есть несколько BottomSheetDialog-ов, между которыми я хочу перемещаться с помощью Navigation Component.
**Где на схеме приложения этот кейс?**
Год назад с таким кейсом были какие-то проблемы, но сейчас всё работает как надо. Можно легко объявить какой-то `dialog` в качестве destination-а в вашем графе навигации, можно добавить action для открытия диалога из другого диалога.
```
```
Диалоги создавались как нужно, закрывались вовремя, навигация по кнопке Back отрабатывала как ожидалось.
### Выводы по бонус-секции
Кейсы без проблем – **существуют**.
Подведём итоги
--------------
На данный момент нет никакой причины переводить большое приложение на Navigation Component. Слишком много проблем, слишком много костылей, постоянно нужно выдумывать что-то для осуществления не самых сложных кейсов навигации. Сам факт, что я ухитрился написать так много текста про проблемы с Navigation Component-ом, что-то да говорит.
Если у вас маленькое приложение, надо внимательно посмотреть на то, какие кейсы навигации вы хотите поддержать. Если задумываетесь про нижнюю навигацию, про диплинки – пожалуй, лучше реализовать всё по-старинке: либо руками, либо на Cicerone. В остальных случаях, если вас не пугает необходимость постоянно искать фиксы, можно воспользоваться Navigation Component-ом.
Пример приложения на Github-е лежит [здесь](https://github.com/Android-Academy-Global/AAGlobal-NavigationComponentPlayground).
Полезные ссылки по теме
-----------------------
* Годичной давности [статья от коллег из Яндекса](https://habr.com/ru/company/yandex/blog/455479/) – про перевод приложения на Navigation Component; отдельно упоминают то, что если бы знали, сколько выхватят проблем, не стали бы ничего затаскивать.
* Хорошая статья про [недостатки Navigation Component](https://proandroiddev.com/why-i-will-not-use-architecture-navigation-component-97d2ad596b36)
* [Документация](https://developer.android.com/guide/navigation) по Navigation Component
* [Что новенького](https://android-developers.googleblog.com/2020/07/whats-new-in-navigation-2020.html) в Navigation Component в 2020 году.
* [Баг с BottomNavigationView](https://issuetracker.google.com/issues/80029773) | https://habr.com/ru/post/520198/ | null | ru | null |
# Сделаем код чище: Что можно исправить в ядре Linux
Наверняка многие хотели бы попробовать что-то изменить в ядре Linux к лучшему, но не знают с чего начать. Я хочу описать несколько проблем, исправить которые под силу каждому, и на примере показать путь от нахождения проблемы до опубликования её исправления в списке рассылки. По ходу повествования читатель познакомится с некоторыми вспомогательными утилитами.
Из года в год, из драйвера в драйвер кочуют одни и те же тривиальные проблемы, часто связанные с незнанием каких-то стандартных практик, утилит или расширений, существующих в ядре Linux.
Вот краткий список такого рода проблем:
* [опечатки и описки](#ExistsTypo) в документации и коментариях
* [собственная реализация вывода](#OwnP) содержимого структур или их полей на экран
* [собственная реализация алгоритмов](#OwnA), которые уже предоставлены в библиотеке ядра
* [определение существующих констант](#ExistsConstants) и типов данных
### Опечатки и описки
Опечатки и описки в документации и комментариях — дело не редкое. Один человек, а именно Lucas De Marchi, разработал специальную утилиту [codespell](https://github.com/lucasdemarchi/codespell), чтобы отлавливать такие опечатки.
Нижеследующий пример всё о себе расскажет сам.
Клонируем ядро:
```
mkdir ~/devel
cd ~/devel
git clone git://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git
cd ~/devel/linux-next
```
*Обратите внимание, что работать мы будем с самым свежим, то есть с деревом linux-next.*
Совершаем тестовый запуск `codespell`:
```
$ codespell.py drivers/staging/unisys
drivers/staging/unisys/include/guestlinuxdebug.h:138: doesnt ==> doesn't
```
Теперь исправляем:
```
$ codespell.py -w -i 3 drivers/staging/unisys
* doesnt show, so we
doesnt ==> doesn't (Y/n) y
FIXED: drivers/staging/unisys/include/guestlinuxdebug.h
```
Смотрим, что получилось:
```
--- a/drivers/staging/unisys/include/guestlinuxdebug.h
+++ b/drivers/staging/unisys/include/guestlinuxdebug.h
@@ -135,7 +135,7 @@ enum event_pc { /* POSTCODE event identifier tuples */
#define POSTCODE_SEVERITY_ERR DIAG_SEVERITY_ERR
#define POSTCODE_SEVERITY_WARNING DIAG_SEVERITY_WARNING
#define POSTCODE_SEVERITY_INFO DIAG_SEVERITY_PRINT /* TODO-> Info currently
- * doesnt show, so we
+ * doesn't show, so we
* set info=warning */
/* example call of POSTCODE_LINUX_2(VISOR_CHIPSET_PC, POSTCODE_SEVERITY_ERR);
* Please also note that the resulting postcode is in hex, so if you are
```
### Собственная реализация вывода
Не столько проблема, сколько улучшение читаемости кода и микрооптимизация: часто значительное уменьшение расходуемой памяти на стеке при вызове функции, уменьшение количества передаваемых спецификаторов в vsnprintf().
Ранее я описал [специальные расширения спецификатора %p](http://habrahabr.ru/post/252453/) в ядре, теперь очередь за применением полученных знаний.
В качестве простоты возьмём шаблон
**%02x[-: ]%02x[-: ]%02x**. Он позволяет находить передачу нескольких байт через стек, которую можно заменить расширением **%\*ph[CDN]**.
Поищем в коде:
```
$ git grep -n -i -e '%02x[-: ]%02x[-: ]%02x' drivers/staging/unisys
drivers/staging/unisys/virtpci/virtpci.c:1313: "[%d:%d] VNic:%02x:%02x:%02x:%02x:%02x:%02x num_rcv_bufs:%d mtu:%d",
```
Что будем делать далее, я опишу на [примере](#Example1) ниже. А пока переходим к следующим проблемным местам.
### Собственная реализация алгоритмов
Вот, возьмём, к примеру, drivers/staging/fbtft/fbtft-bus.c, строки 99-100:
```
for (i = 0; i < pad; i++)
*buf++ = 0x000;
```
pad определена как u16 и может быть в диапазоне от 0 до 3, то есть от 0 до 6 байт. Как мы знаем, memset() жутко оптимизированная функция, особенно на малых размерах. Почему не применить?
Или ещё пример из того же драйвера, а именно drivers/staging/fbtft/fbtft-core.c, строки 1091-1096:
```
/* make debug message */
msg[0] = '\0';
for (j = 0; j < i; j++) {
snprintf(str, 128, " %02X", buf[j]);
strcat(msg, str);
}
```
Вот не знали люди, что в ядре есть bin2hex(), не говоря уже о том, что strcat() совершенно лишний — snprintf() добавляет терминирующий '\0'.
Попробуйте модифицировать самостоятельно.
**Кто-то уже увидел как можно ещё упростить?**На самом деле буфер нужен для вывода дампа в шестнадцатиричном виде, поэтому удаляем цикл, переменную msg и заменяем это всё либо спецификатором **%\*ph** с передаваемой длиной i, либо вызовом print\_hex\_bytes().
Обратите внимание далее по коду есть подобное, можно за компанию и его оптимизировать: строки 1192-1202.
### Определение существующих констант и типов данных
Возвращаясь к драйверу unisys, запустим такую команду:
```
$ git grep -n MAX_MACADDR_LEN drivers/staging/unisys/
drivers/staging/unisys/common-spar/include/channels/iochannel.h:190:#ifndef MAX_MACADDR_LEN
drivers/staging/unisys/common-spar/include/channels/iochannel.h:191:#define MAX_MACADDR_LEN 6 /* number of bytes…
drivers/staging/unisys/common-spar/include/channels/iochannel.h:192:#endif
…и так далее…
```
Однако стоит отметить, что константа длины MAC адреса давным давно определена в ядре как ETH\_ALEN. Уверен, мейнтейнеры с радостью примут от вас патч, заменяющий их определение стандартным ядерным.
### Пример исправления
Переходим плавно к практике. [Выше](#ToPH) мы нашли место, где при выводе нескольких байт используется передача каждого из них через стек.
Если мы посмотрим в код, то увидим следующее:
```
str_pos += scnprintf(vbuf + str_pos, len - str_pos,
"[%d:%d] VNic:%02x:%02x:%02x:%02x:%02x:%02x num_rcv_bufs:%d mtu:%d",
tmpvpcidev->bus_no,
tmpvpcidev->device_no,
tmpvpcidev->net.mac_addr[0],
tmpvpcidev->net.mac_addr[1],
tmpvpcidev->net.mac_addr[2],
tmpvpcidev->net.mac_addr[3],
tmpvpcidev->net.mac_addr[4],
tmpvpcidev->net.mac_addr[5],
tmpvpcidev->net.num_rcv_bufs,
tmpvpcidev->net.mtu);
```
А это оказывается кто-то так выводит MAC адрес! Что ж, мы с лёгкостью можем использовать специальное расширение спецификатора — **%pM**.
Давайте заменим и посмотрим на результат:
```
--- a/drivers/staging/unisys/virtpci/virtpci.c
+++ b/drivers/staging/unisys/virtpci/virtpci.c
@@ -1310,15 +1310,10 @@ static ssize_t info_debugfs_read(struct file *file, char __user *buf,
tmpvpcidev->scsi.max.cmd_per_lun);
} else {
str_pos += scnprintf(vbuf + str_pos, len - str_pos,
- "[%d:%d] VNic:%02x:%02x:%02x:%02x:%02x:%02x num_rcv_bufs:%d mtu:%d",
+ "[%d:%d] VNic:%pM num_rcv_bufs:%d mtu:%d",
tmpvpcidev->bus_no,
tmpvpcidev->device_no,
- tmpvpcidev->net.mac_addr[0],
- tmpvpcidev->net.mac_addr[1],
- tmpvpcidev->net.mac_addr[2],
- tmpvpcidev->net.mac_addr[3],
- tmpvpcidev->net.mac_addr[4],
- tmpvpcidev->net.mac_addr[5],
+ tmpvpcidev->net.mac_addr,
tmpvpcidev->net.num_rcv_bufs,
tmpvpcidev->net.mtu);
}
```
Вроде бы неплохо — на 5 строк и переменных на стеке меньше. Стоит всё же откомпилировать результат. Подробно я не буду описывать как это делается, лишь укажу, что потребуется включить драйвер в конфигурации с помощью опций:
> CONFIG\_STAGING=y
>
> CONFIG\_UNISYSPAR=y
>
> CONFIG\_UNISYS\_VIRTPCI=m
>
>
Сохраняем наше изменение в дереве с помощью `git commit -a -s` и форматируем в виде патча.
```
$ git format-patch HEAD~1
0001-staging-unisys-print-MAC-address-via-pM.patch
```
Далее, воспользуемся замечательным скриптом `get_maintainter.pl`, чтобы узнать кого необходимо информировать персонально.
```
$ scripts/get_maintainer.pl --git-min-percent=67 --nor --norolestats 00*
Benjamin Romer
David Kershner
Greg Kroah-Hartman
sparmaintainer@unisys.com
devel@driverdev.osuosl.org
linux-kernel@vger.kernel.org
```
Отправляем наш патч по адресам:
```
$ git send-email --cc-cmd 'scripts/get_maintainer.pl --git-min-percent=67 --nor --nol --norolestats' 00*
0001-staging-unisys-print-MAC-address-via-pM.patch
Who should the emails be sent to (if any)? devel@driverdev.osuosl.org, sparmaintainer@unisys.com
Message-ID to be used as In-Reply-To for the first email (if any)?
…
Send this email? ([y]es|[n]o|[q]uit|[a]ll): y
```
Вот и [письмецо](http://driverdev.linuxdriverproject.org/pipermail/driverdev-devel/2015-March/066848.html).
UPDATE: Уже в ядре: [9a836c0a6310e6e9](https://git.kernel.org/cgit/linux/kernel/git/gregkh/staging.git/commit/?h=staging-next&id=9a836c0a6310e6e970ff63d030d7213c874ae7af). | https://habr.com/ru/post/253123/ | null | ru | null |
# Зачем студентам теория графов
**Информация об изображении**
(Здание кёнигсбергской биржи (построено в 1875 году, сохранилось до сих пор) и [Зелёный мост](https://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%B9%D0%BB:%D0%91%D0%B8%D1%80%D0%B6%D0%B0_%D0%B8_%D0%97%D0%B5%D0%BB%D1%91%D0%BD%D1%8B%D0%B9_%D0%BC%D0%BE%D1%81%D1%82_%D0%B2_%D0%9A%D1%91%D0%BD%D0%B8%D0%B3%D1%81%D0%B1%D0%B5%D1%80%D0%B3%D0%B5.jpg) (построен в 1322 году, не сохранился) — «решение Эйлером [задачи о кёнигсбергских мостах](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D0%B1%D0%BB%D0%B5%D0%BC%D0%B0_%D1%81%D0%B5%D0%BC%D0%B8_%D0%BC%D0%BE%D1%81%D1%82%D0%BE%D0%B2_%D0%9A%D1%91%D0%BD%D0%B8%D0%B3%D1%81%D0%B1%D0%B5%D1%80%D0%B3%D0%B0) явилось первым в истории применением теории графов»).
Ранее я уже писал про приложения теории графов: [тут](https://habr.com/ru/post/339752/) и [тут](https://habr.com/ru/post/338604/).
В этой статье хочу помочь коллеге в теории графов – он пожаловался в [комментарии](https://habr.com/ru/post/570612/#comment_23321460) к своей статье, что:
> Здесь я попытался в максимально доступной форме объяснить, как же это делать. И в первую очередь я делаю это для студентов, которые изучают данную тему и могут не понимать, зачем вообще графы нужны. Учась, я лично убедился, что для многих эта тема была «проходной» и они не извлекли из нее никакой ценной информации, а также так и не поняли, как работать с матрицами.
>
>
На это я [ответил](https://habr.com/ru/post/570612/#comment_23321652):
> ИМХО для IT-студентов нужно сразу сказать, что списки (стеки, очереди) и бинарные деревья это графы. И всякие схемы, типа схемы метро, автодорог, принципиальные в электронике можно рассматривать как графы. Приложения теории графов — это фундаментальные свойства всяких подобных схем.
Для студентов историков м.б. будет полезно узнать, что фамильные деревья — это графы. И проч. др. специальности. Где только нет графов, пусть на уровне тривиального списка. Возвращаясь к IT: строка символов — граф, и число — последовательность байт — граф, и файл — граф, не говоря о БД.
**Дисклеймер.** *Далее хочу высказать свое сугубо личное мнение, никого ни в чем, не пытаясь убедить или переубедить. Исключительно в порядке обсуждения. Т.о. я адресуюсь к читателям, уже знакомым с теорией графов. Нижеследующее — всего лишь мои предположения. Иногда я опираюсь на факты и на авторитеты (Харари, Зыков, Вирт, Адельсон –Вельский и, как ни странно, А. Дюма), но это не повод тотально засадить всех студентов за зубрежку теории графов в полном объеме.*
Вернемся к историкам. Предположим, что ими собрано достаточно документов о том, что у Хуана и Хуаниты, после того, как они сочетались законным браком, было пять детей. Но Хуанита изменяла Хуану и двоих родила внебрачно. А Хуан не остался в долгу и трижды изменил Хуаните – еще двое детей. Однако вопрос: от кого из любовников родила Хуанита?: От Филиппа или от кардинала Ришелье? А может от кого-то из четырех мушкетеров – он была общительной женщиной. Такой вопрос и про Хуана: он был знаком и пользовался расположением королевы Франции, но уделял внимание и ее дамам. (А. Дюма на многих сотнях страниц описывает подобные истории).
Как видим из этого модельного примера — граф (фамильное дерево) можно описать на естественном языке. Но для наглядности его лучше нарисовать, а как будет лучше?
Можно так:
Где черные ребра – документально подтвержденные факты, а красные – предположения.
А можно так:
Где красные ребра имеют надпись: "+любовница 1 или + любовница 2 или + любовница 3", т.е. предположения.
Синие и зеленые ребра имеют надпись: "+Хуанита", но синие — документально подтвержденные факты, а зеленые – предположения.
Сделаем определения:
**Путь** *— это результат обхода некоторых вершин графа по правилу: переходить можно только на вершну инцидентную (т.е. связанную ребром) текущей вершине. При этом нельзя возвращаться по уже пройденному ребру.*
**Цикл** – *это путь начало, которого и конец, которого в одной и той же вершине.*
Пример:
Это цикл:
И это цикл:
Еще определения:
**Дерево** *– это граф без циклов.*
[Пример](https://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%B9%D0%BB:Binary_tree.svg):
**Линейный список** *– дерево без ветвей.* Т.е. только предыдущий элемент списка всегда инцидентен следующему и никакой другой.
Пример:
т-о-л-ь-к-о- -п-р-е-д-ы-д-у-щ-и-й- -э-л-е-м-е-н-т- -с-п-и-с-к-а- -в-с-е-г-д-а- -и-н-ц-и-д-е-н-т-е-н- -с-л-е-д-у-ю-щ-е-м-у
Здесь буквы и пробел – вершины графа, а дефис “-” обозначает ребро.
Г.М. Адельсон-Вельский доказал, что время поиска по дереву зависит от высоты этого дерева. (Н.Вирт в своей знаменитой книге “Алгоритмы + структуры данных = программы” ссылается на эту работу.) Из доказательства Адельсона-Вельского следует, что наихудший случай для дерева – вырождение в линейный список, и, следовательно, превращение списка в достаточно развесистое дерево ускорит поиск.
Для иллюстрации возьмем рекурсивное определение Вирта бинарного дерева.
```
Type
link = ^node;
node = record
left, right : link; // левое и правое поддеревья
dat : // любой тип, допускающий сравнение: integer, string, real
// и т.д.
end; // record node
```
Рекурсивная процедура сортировки будет такая:
```
procedure add (var currNode : link; aDat :// любой тип, допускающий
// сравнение
);
begin
if currNode = nil then
begin
new ( currNode); // создать новое поддерево
currNode^.left := nil; // без ветвей
currNode^.right := nil;
currNode^.dat := aDat
end
else
if currNode^.dat> aDat then
add (currNode^. right, aDat) // добавить к правой ветви
else
if currNode^.dat< aDat then // if №2
add (currNode^. left, aDat) // добавить к левой ветви
else // currNode^.dat = aDat, здесь нужно доп.решение,
// но для простоты считаем, что все aDat уникальные, т.е. if №2 не нужно
end;// procedure add
```
Функция поиска в дереве:
```
function find (currNode : link; aDat ://любой тип, допускающий сравнение
) : link;
begin
if currNode= nil then
find := nil // вернуть: ничего не найдено
else
if currNode^.dat> aDat then
find := find (currNode^. right, aDat)
else
if currNode^.dat< aDat then
find := find (currNode^. left, aDat)
else
if currNode^.dat = aDat then
find := currNode //вернуть результат
end;// function find
```
Как сделать развесистое дерево из отсортированного списка – отдельная проблема. Может добавлять в дерево случайным образом, а может использовать алгоритмы балансировки деревьев.
Для гуманитариев может и не нужно вникать в приведенный код. Им важно понять, что список:
*Аня
Ваня
Иван Васильевич
и т.д.*
не всегда оптимальное решение. Не смогут сами — попросят помочь.
Я (с коллегами) продемонстрировал быстрый поиск при размерности ок.100 лимонов химических соединений (не все реально полученные – некоторые гипотетические). Тут мы встречаемся с важной задачей теории графов – задачей установления изоморфизма двух графов.
Классическая теория графов смотрит только на топологию: какая вершина с какой связаны ребром, а геометрию рисунка не учитывает. Такой подход оказался продуктивным для обобщений и теорем. Но проблема в том, что на листе бумаги мы можем произвольно отметить n точек или кружочков по числу вершин графа, произвольно пронумеровать эти вершины и соединить их линиями, обозначающими ребра. Рисунки одного и того же графа не обязательно совпадут в своей геометрии.
Пример не похожих рисунков:
[Кубан – кунеан](https://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%B9%D0%BB:CubaneToCun.png). Это химическая реакция перехода химического вещества кубан в вещество кунеан. Можно видеть, что структурные формулы органической химии не отличаются от графов.
И этот кунеан на другом [рисунке](https://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%B9%D0%BB:Cuneane.png):
Математически в общем случае задача изоморфизма сводится к поиску матрицы перестановки такой, чтобы
A1= TA2P,
где A1 – матрица смежности первого графа;
A2 – матрица смежности второго графа;
P — матрица перестановки;
T – обратная ( = транспонированная, для данного случая) матрица перестановки.
На словах понятно, что если удается найти для второго графа такую нумерацию, что смежность вершин совпадает с первым (говорят “найти биекцию” — см. Википедию)
к примеру, если в одном графе есть ребро между первой и второй вершинами и в другом графе такое ребро, и так для всех ребер, то графы изоморфны – фактически это один и тот же граф.
Нужно отметить, что для некоторых типов графов задача изоморфизма решается тривиально, для других легко, но для многих требует перебора со сложностью в экспоненту. Тривиально для полных графов – это графы, у которых каждая вершина связана со всеми остальными (инцидентна всем остальным). Понятно, что для любых n вершин существует только один полный граф. Поэтому проверка на изоморфизм сводится к проверке равенства числа вершин первого графа = числу вершин второго. Аналогично для безреберного графа (где только вершины).
Легко задача изоморфизма решается для случая, когда у всех вершин разные степени. Т.к. степени уникальны, то вычисление матрицы перестановки не требуется – простая перенумерация. Каждому номеру вершины второго графа присваиваете номер вершины первого той же степени и проверяете совпадение ребер.
Но не у всех графов степени вершин уникальны. Тут появляются идеи канонической нумерации, т.е. нумерации вершин по жестким однозначным правилам, и полного инварианта графа. Инвариант это обычно (но не обязательно) число, которое не меняется от перенумерации вершин графа. Примером инварианта может служить сумма степеней вершин.
Очевидно, что у двух неизоморфных графов эти инварианты могут совпадать. (Если инварианты не совпадают, то графы точно не изоморфны).
Полные инварианты это, которые, если равны, то графы изоморфны, а если не равны, то не изоморфны. Один из полных инвариантов описан у Зыкова. Матрицу смежности можно развернуть в вектор – нужно просто добавлять в вектор строку за строкой из матрицы. Этот вектор можно рассмотреть, как двоичное число. Можно перебрав все матрицы найти минимальное и максимальное числа. Далее если такие минимальные (или максимальные) числа для двух графов совпадают, то, очевидно, что их матрицы смежности после перестановки будут равны и графы будут изоморфны. К настоящему времени не известен ни один полный инвариант, который можно вычислить без перебора.
Отметим, что изоморфизм деревьев определяется (без полного перебора) с полиномиальной сложностью. А проблема изоморфизма графов остается по-прежнему открытой.
Выше мы затронули проблему отрисовки графов или, как говорят, визуализации. Было предложено много способов (я может, раскачаюсь написать про наиболее полезные), но ни один из них не универсальный. И поэтому графы все рисуют по разному и люди и компьютеры. Я рисую на сделанном мной инструменте.
Возвращаясь к студентам, с которых начал. Думаю, что каждый понимает, что в избранной им области есть структуры. Иногда очень сложные, иногда не очень. Надеюсь мне удалось показать, что теория графов – это теория структур, и учит общим методам обращения со структурами. Может не всем студентам нужно углубляться в эти методы, но понимание общих принципов полезно всем. При этом я не призываю грузить студентов-философов матричной алгеброй – им и так хватает, им положено Платона с Аристотелем читать. Но обзорные лекции будет полезно прослушать со сдачей не сложного зачета, чтобы не прогуливали.
В начале я сказал, что хочу высказать свое сугубо личное мнение, никого не в чем не пытаясь убедить или переубедить. Исключительно в порядке обсуждения. Надеюсь на интересное обсуждение, которое обещает мне много новых знаний о преподавании теории графов для различных специальностей, и о пользе этой теории для этих специальностей.
**Использованная литература:**
1. А.Дюма, Три мушкетера
2. Ф.Харари, Теория графов, М.: УРСС, 2003.
3. А.А.Зыков, Основы теории графов, М.: Вузовская книга, 2004.
4. Н.Вирт, Алгоритмы+структуры данных=программы, М.: Мир,1985.
5. П.Грогоно, Программирование на языке Паскаль, М.: Мир,1982
**Алгоритмы теории графов:**
1. Кристофидес, Теория графов. Алгоритмический подход, М.: Мир, 1978 (м.б. есть болеее новые переиздания).
2. В.Липский, Комбинаторика для программистов, М.: Мир, 1988.
3. В.Н.Касьянов, В.А.Евстигнеев, Графы в программтровании: обработка, визуализация и применение, Спб: БХВ-Петербург, 2003.
**Про достижения в решении проблемы изоморфизма графов можно посмотреть:**
1. Л.И.Малинин, Н.Л.Малинина, Изоморфизм графов в теоремах и алгоритмах, М.: URSS, 2009.
2. McKay, Brendan D. (1981), "[Practical graph isomorphism](http://users.cecs.anu.edu.au/~bdm/nauty/PGI/)", 10th. Manitoba Conference on Numerical Mathematics and Computing (Winnipeg, 1980), Congressus Numerantium, 30, pp. 45–87, MR 0635936.
3. [Пономаренко И. Н. Проблема изоморфизма графов: Алгоритмические аспекты](https://www.youtube.com/watch?v=zvXeuxUA98Q) | https://habr.com/ru/post/570970/ | null | ru | null |
# Настройка Guard для автоматизации Ruby on Rails разработки
Всем привет! По моему мнению, каждый программист должен стремиться к автоматизации и оптимизации всего, что движется и еще нет. В этой статье будет рассказано о том, как автоматизировать рабочий процесс Ruby on Rails разработчика с помощью Ruby гема под названием Guard. Эта статья в первую очередь полезна Ruby разработчикам, но может пригодиться и другим.
Что такое Guard?
=================
[Guard](https://github.com/guard/guard) – это инструмент, позволяющий автоматически выполнять какие-либо команды при изменении какого-либо файла. Например, при изменении файла настроек сервера Guard может автоматически перезапускать сервер. Или можно настроить автоматическую компиляцию LESS в CSS при сохранении файла. Всё зависит от того, как Guard будет настроен разработчиком.
У Guard есть специальный файл настроек Guardfile, где указывается, какие команды нужно запускать при изменении каких файлов. Все настройки можно указать самому, а можно использовать написанные сообществом Guard Plugins, в которых самые часто используемые настройки написаны заранее.
Установка и первый запуск
==========================
Лучший способ интегрировать Guard в проект – это добавить его в Gemfile.
```
group :development do
gem 'guard'
end
```
И затем установить его командой
```
$ bundle
```
После чего необходимо создать Guardfile командой
```
$ bundle exec guard init
```
Запустить Guard лучше всего используя Bundler командой
```
$ bundle exec guard
```
Настройка для Ruby on Rails приложения
=======================================
После установки рассмотрим использование Guard для стандартного RoR проекта. Предположим, что RoR приложение уже создано. Пусть Guard будет автоматически устанавливать все необходимые гемы при изменении Gemfile.
1. Добавление в проект
-----------------------
Для этого в Gemfile добавим в группу для разработки гем [guard-bundler](https://github.com/guard/guard-bundler)
```
group :development do
# And updates gems when needed
gem 'guard-bundler', require: false
end
```
Установим гем
```
$ bundle install
```
А затем инициализируем плагин командой
```
$ guard init bundler
```
Обратите внимание на Guardfile, расположенный в корне проекта. Теперь там есть строчки
```
guard :bundler do
watch('Gemfile')
end
```
В них написано, что Guard будет следить за файлом Gemfile и будет выполнять команду, заранее записанную в геме guard-bundler. В данном случае, это
```
$ bundle install
```
2. Проверка
------------
Проверим! Включим Guard в терминале командой
```
$ bundle exec guard
```
Добавим в Gemfile какой-нибудь гем. Например, [guard-rspec](https://github.com/guard/guard-rspec), который будет автоматом прогонять тесты для Rspec.
```
gem 'guard-rspec', require: false
```
Откроем терминал с процессом guard и увидим, что он там автоматически запустил bundler, в результате работы которого guard-rspec был автоматически установлен. Как видно, подобная настройка Guard позволяет разработчику автоматизировать одну из часто выполняемых задач.
3. Настройка
-------------
Инициализируем плагин для Rspec после его установки
```
$ guard init rspec
```
Теперь в Guardfile появились новые строчки. Рассмотрим их:
```
# Note: The cmd option is now required due to the increasing number of ways
# rspec may be run, below are examples of the most common uses.
# * bundler: 'bundle exec rspec'
# * bundler binstubs: 'bin/rspec'
# * spring: 'bin/rsspec' (This will use spring if running and you have
# installed the spring binstubs per the docs)
# * zeus: 'zeus rspec' (requires the server to be started separetly)
# * 'just' rspec: 'rspec'
guard :rspec, cmd: 'bundle exec rspec' do
watch(%r{^spec/.+_spec\.rb$})
watch(%r{^lib/(.+)\.rb$}) { |m| "spec/lib/#{m[1]}_spec.rb" }
watch('spec/spec_helper.rb') { "spec" }
# Rails example
watch(%r{^app/(.+)\.rb$}) { |m| "spec/#{m[1]}_spec.rb" }
watch(%r{^app/(.*)(\.erb|\.haml|\.slim)$}) { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
watch(%r{^app/controllers/(.+)_(controller)\.rb$}) { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
watch(%r{^spec/support/(.+)\.rb$}) { "spec" }
watch('config/routes.rb') { "spec/routing" }
watch('app/controllers/application_controller.rb') { "spec/controllers" }
watch('spec/rails_helper.rb') { "spec" }
# Capybara features specs
watch(%r{^app/views/(.+)/.*\.(erb|haml|slim)$}) { |m| "spec/features/#{m[1]}_spec.rb" }
# Turnip features and steps
watch(%r{^spec/acceptance/(.+)\.feature$})
watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
end
```
Эти строчки настраивают автоматический запуск тестов Rspec. Рассмотрим некоторые из них. Например, строка
```
ruby watch('spec/spec_helper.rb') { "spec” }
```
говорит о том, что Guard будет следить за файлом spec/spec\_helper.rb (путь относительно корня проекта — Guardfile файла) и при любом его изменении он будет запускать тестирование всей папки spec. Начало блока
```
ruby guard :rspec, cmd: 'bundle exec rspec’ do
```
говорит о том, что для любого правила все Rspec команды будут запускаться с параметрами bundle exec rspec. То есть, в рассмотренном случае при изменении ruby spec/spec\_helper.rb будет запускаться команда
```
$ bundle exec rspec spec
```
Строка
```
rubywatch(%r{^app/(.+)\.rb$}) { |m| "spec/#{m[1]}_spec.rb" }
```
говорит о том, что при изменении любого .rb файла будет запускаться тестирование теста, связанного с этим файлом. То есть при изменении app/models/user.rb автоматически запустится команда
```
$ bundle exec spec spec/models/user_spec.rb
```
Для создания и редактирования подобных действий используются регулярные выражения. Рекомендую использовать в Ruby консоли команду match для отладки, например
```
"app/views/units/index.html.slim".match(%r{^app/views/(.+)/(.*)\.(.*)\.(erb|haml|slim)$})
```
Больше примеров!
=================
Для Guard написано [большое количество плагинов](https://github.com/guard/guard/wiki/List-of-available-Guards) на все случаи жизни. Каждому разработчику стоит самостоятельно найти нужные для него и настроить их под себя. Я вкратце опишу те, которые используются у меня в данный момент. Я сам до сих пор не нашел идеальных решений, поэтому буду рад любым замечаниям и предложениям!
В Gemfile
----------
```
group :development, :test do
# Integrates jasmine js testing
gem 'jasmine-rails'
# With guard
gem 'guard-jasmine', git: "git://github.com/guard/guard-jasmine.git", branch: "jasmine-2"
# Checks ruby code grammar
gem 'rubocop', require: false
# With rspec
gem 'rubocop-rspec'
# With guard
gem 'guard-rubocop’
end
group :development do
# Automagically launches tests for changed files
gem 'guard'
gem 'guard-rspec', require: false
# And updates gems when needed
gem 'guard-bundler', require: false
# And auto starts rails server
gem 'guard-rails'
# And auto runs migrations
gem 'guard-migrate'
end
```
В Guardfile
------------
```
# More info at https://github.com/guard/guard#readme
# https://github.com/guard/guard-bundler
guard :bundler do
watch('Gemfile')
end
# https://github.com/guard/guard-rspec
guard :rspec, cmd: 'zeus rspec' do
watch(%r{^spec/.+_spec\.rb$})
watch(%r{^lib/(.+)\.rb$}) { |m| "spec/lib/#{m[1]}_spec.rb" }
# Run the model specs related to the changed model
watch(%r{^app/(.+)\.rb$}) { |m| "spec/#{m[1]}_spec.rb" }
# Controller changes
watch(%r{^app/controllers/(.+)_(controller)\.rb$}) { |m| ["spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
watch('config/routes.rb') { "spec/controllers" }
watch('app/controllers/application_controller.rb') { "spec/controllers" }
watch(%r{^spec/support/(.+)\.rb$}) { "spec" }
watch('spec/rails_helper.rb') { "spec" }
watch('spec/spec_helper.rb') { "spec" }
# Capybara features specs
watch(%r{^app/views/(.+)/.*\.(erb|haml|slim)$}) { |m| "spec/acceptance/#{m[1]}" }
watch(%r{^app/views/(.+)/(.*)\.(.*)\.(erb|haml|slim)$}) { |m| "spec/acceptance/#{m[1]}" }
watch(%r{^app/views/(.+)/_.*\.(erb|haml|slim)$}) { |m| "spec/acceptance/#{m[1].partition('/').first}/#{m[1].partition('/').last}_spec.rb" }
end
# Checks any changed ruby file for code grammar
# https://github.com/yujinakayama/guard-rubocop
guard :rubocop, all_on_start: false, cli: ['--out', 'log/rubocop.log'] do
watch(%r{^(.+)\.rb$}) { |m| "#{m[1]}.rb" }
end
# Restarts server on config changes
# https://github.com/ranmocy/guard-rails
guard :rails, zeus: true, daemon: true do
watch('Gemfile.lock')
watch(%r{^(config|lib)/.*})
end
# Restarts all jasmine tests on any js change
# https://github.com/guard/guard-jasmine
guard :jasmine, all_on_start: false, server_mount: '/specs' do
watch(%r{^app/(.+)\.(js\.coffee|js|coffee)}) { "spec/javascripts" }
watch(%r{^spec/javascripts/(.+)\.(js\.coffee|js|coffee)}) { "spec/javascripts" }
end
# Runs migrations on migrate files changes
# https://github.com/glanotte/guard-migrate
guard :migrate do
watch(%r{^db/migrate/(\d+).+\.rb})
watch('db/seeds.rb')
end
```
Немного о rubocop
------------------
[Rubocop](https://github.com/bbatsov/rubocop) — гем для Ruby, позволяющий проверить .rb файл на корректность синтаксиса. В данном примере он настроен вместе с Guard, благодаря чему при каждом изменении .rb файла Rubocop проверяет его и выводит результат в консоль и в log/rubocop.log файл.
У Rubocop огромное количество настроек, благодаря чему его можно адаптировать под любые требования к синтаксису. Можно даже сделать так, чтобы он автоматически корректировал код. Для настройки гема используется файл .rubocop.yml, например, rubocop обычно ругается на строки больше 90 символов, но благодаря файлу настроек можно сделать так, чтобы он указывал только на строки больше 140.
Чтобы увидеть все настройки, достаточно прогнать команду
```
$ rubocop --auto-gen-config
```
которая создаст файл со всеми отключенными настройками. Можно таким образом по одной включать и получить итоговый нужный .rubocop.yml файл.
Результаты
-----------
Что в итоге настроено? В данном проекте достаточно запустить отдельными процессами zeus и guard. После чего происходит следующее:
1. Автоматически поддерживается запущенный через zeus Rails сервер, который перезапускается при каждом изменении основных файлов настроек проекта
2. При каждом изменении Gemfile устанавливаются все гемы
3. При изменении любого файла с тестом прогоняется этот тест
4. При изменении любого файла контроллеров/моделей/либов/вьюх запускается связанный с ним тест, если такой имеется
5. Каждый измененный ruby файл проверяется на грамотность с помощью rubocop
6. При изменении любого javascript/coffeescript файла запускаются все jasmine тесты
7. При изменении любого файла миграции или seeds прогоняются все необходимые миграции
Таким образом, достаточно большое количество процессов удалось автоматизировать. Я бы хотел сделать так, чтобы у каждого проекта достаточно было бы лишь запустить guard и полностью сфокусироваться на творческом процессе.
Пример работы с Guard
======================
Теперь опишу текущий процесс работы с Guard. Ниже идут рекомендации, которые я дал остальным разработчикам, с которыми я сейчас работаю.
1. Откройте терминал и перейдите в папку проекта
2. Запустите zeus для ускоренной работы тестов/сервера
```
$ zeus start
```
3. Запустите Guard
```
$ bundle exec guard
```
Теперь Guard автоматически запустит и будет поддерживать включенным Rails server, включенный через Zeus.
4. Запустите все тесты, нажав в терминале Enter. После исправления всех тестов можно работать!
На что стоит обращать внимание: при изменении файлов тестов тесты будут прогоняться автоматически. То есть я рекомендую одновременно с окном IDE держать открытым окно терминала (в Rubymine, например, это можно сделать прямо в под окне), где тут же можно будет увидеть, обвалились ли тесты с внесенными изменениями.
Спасибо!
=========
Спасибо за чтение! Не утверждаю, что я специалист в Guard, поэтому буду рад любым замечаниям и предложениям. | https://habr.com/ru/post/238667/ | null | ru | null |
# Своя браузерка — путь мыши: Теория
Итак, вы решили поднять свою браузерку.
Вы понимаете все сопутствующие нюансы и принципы поведения Администратора браузерки: [habrahabr.ru/post/249625](https://habrahabr.ru/post/249625/)
Вы чётко осознаёте, что единственный разумный вариант, зачем в это стоит впрягаться — это саморазвитие, причем это не самый лучший путь: [habrahabr.ru/post/249705](https://habrahabr.ru/post/249705/)
Мыши кололись и плакали, но продолжали жрать кактус…
Окей. В ваши цепкие лапки попал какой-нибудь скачанный из инета движок браузерки. В лучшем случае — это будет опенсорс с хорошим количеством форков (т.е. свободный от «детских проблем»). Возможно это будет т.н. «дамп» — т.е. слитый с живого коммерческого сервера движок с дампом БД. Но вероятнее всего — это будет очередная «поделка на тему». Вот на последнем случае мы и остановимся — потому что минимально необходимые действия общие для всех трёх случаев.
Здесь я неявно предполагаю, что ваш движок базируется на PHP+MySQL. Именно для этой связки я и буду вести дальнейший рассказ. Если у вас ВДРУГ Python+PostgressSQL — ничего страшного. Фундаментальные принципы работы с такими движками идентичны — различается лишь реализация.
Что же вам нужно сделать в первую очередь с движком? Ответить на этот вопрос не так-то просто, не ознакомившись с основными принципами работы с данными внутри браузерного движка (да и вообще — любого сайта или даже любой программы). Принципов этих немного и они весьма просты.
Данные, пришедшие от пользователя — токсичны
============================================
НЕ ДОВЕРЯЙТЕ ПОЛЬЗОВАТЕЛЬСКОМУ ВВОДУ!
Все данные, исходящие от пользователя по определению считаются «токсичными» — т.е. неправильными, невалидными или даже злонамеренными до тех пор, пока не будет доказано обратное. Это значит, что все данные от пользователя нужно проверять на стороне сервера.
Вы думаете, что у вас есть чудесный валидатор на JavaScript, который не пропустит некорректные данные к бэкенду? ОШИБКА! Любой запрос от фронтенда (та часть, что непосредственно видна пользователю и отвечает за взаимодействие с ним) вашего движка можно фальсифицировать — поэтому бэкэнд (та часть, которая производит фактическую обработку данных на стороне сервера и записывает изменения в БД) ОБЯЗАН всегда повторять расчёты фронтенда, что бы быть уверенным, что вам не скормили туфту.
Нормализация данных
===================
Все операции внутри фронтенда и бэкэнда должны производиться над исходными данными с минимальным преобразованием. Чуточку непонятно?
Ну, например, у вас есть последовательность символов, которая по факту является многострочным текстом. Вроде бы ничего сложного и всё очевидно, так? ОШИБКА! Строка может быть получена из внешнего файла.
Тут сразу начинаются пляски с бубном по поводу символа перевода строки. Ведь в разных системах конец строки кодируется по-разному. Файлы Юникс-подобных систем отбивают новую строку символом LF (Line Feed, ASCII 0x0A). Старые системы (МакОСь до 9-й версии, Коммодор и ещё некоторые) обожали заканчивать строку символом CR (Carriage Return, ASCII 0x0D). Самая десктопная ОСь Винда (как наследник MS-DOS) обожают комбинацию CR+LF — и именно в таком порядке!
И тут появляется великий HTML, для которого всё, что за рамками тэга «pre» (и других подобных тегов) — суть одна строка. А разбивка на строки производится тегом . Который, конечно, правильно записывать как . Допускается так же и `,` итд
Проблема с нормализацией строк не зря упомянута первой. Обычно неправильная нормализация строк не даёт критичных ошибок — зато чаще всего видна игрокам. Кому приятно вместо отформатированного по параграфам текста увидеть что-то вроде
`Строка 1\r\nСтрока 2\r\nСтрока 3`? Или даже `Строка 1
Строка 2
Строка 3`, что случается при одновременной ошибке в нормализации данных и форматировании вывода.
Числа не лишены аналогичных проблем. Казалось бы — что может быть проще числа? intval() и floatval() (и их аналоги в JavaScript — впрочем, это отдельный разговор. JS позволяет выстрелить себе в ногу множеством изощрённых путей...) должны решить все проблемы, правда же? ОШИБКА!
Какое число получится в переменной, если в PHP-бэкэнде написать intval(0123)? Думаете — 123? Ну, тогда вперед, читать мануал: [php.net/manual/ru/language.types.integer.php](http://php.net/manual/ru/language.types.integer.php)
Отдельная песня — числа с плавающей точкой в PHP и их сравнение. Здесь не урок по PHP — поэтому опять же отошлю к документации: [php.net/manual/ru/language.types.float.php](http://php.net/manual/ru/language.types.float.php) Особенное внимание предлагаю уделить внимание вставке «Точность чисел с плавающей точкой» и подразделу «Сравнение чисел с плавающей точкой».
Вряд ли это будет актуально на первом этапе развития, но для понимания важности нормализации данных не могу не упомянуть об отдельном интересном вопросе идентификаторов в БД. Ну, это те самые веселые числа, объявленные как BIGINT(20) в БД и определяющие уникальность каждой записи.
Чтобы полностью понять суть проблемы — опять сошлюсь на документацию PHP [php.net/manual/ru/reserved.constants.php](http://php.net/manual/ru/reserved.constants.php) Искать в тексте ключевое слово PHP\_INT\_MAX. Посчитать количество символов. Сравнить с описанием структуры БД выше. Подсказка — в MySQL данное объявление означает число с 20 значащими символами до запятой. При неаккуратной работе с таким идентификатором в PHP- или JS-коде он легко может обратиться во float с потерей точности.
Какой вывод можно сделать из всего вышенаписанного? Данные должны быть НОРМАЛИЗИРОВАНЫ — т.е. приведены к некоей стандартизированной форме, которая будет восприниматься вашим движком отныне и везде. Обычно автор(ы) движка неявно выбирают какую-то одну форму нормализации. К сожалению — те же автор(ы) соблюдают её далеко не всегда и не везде.
Экранирование выводимых данных
==============================
Вы удивитесь, насколько часто игре надо будет выводить данные для игроков! Здесь нас так же поджидает куча интересных откровений.
Вывод в HTML
------------
Самое главное правило таково — ЛЮБОЙ вывод в HTML неконтролируемых данных должен производиться исключительно через функцию htmlentities() [php.net/manual/ru/function.htmlentities.php](http://php.net/manual/ru/function.htmlentities.php)! Еще раз подчеркну — ЛЮБОЙ! БЕЗ ИСКЛЮЧЕНИЙ!
Здесь нужно заметить, что данные в движке делятся на «контролируемые» и «неконтролируемые». К первым относятся такие сущности как простые строки локализации, гарантированно нормализованные целые числа, гарантированно нормализованные однострочные строки и… пожалуй — всё. Все остальные данные являются «неконтролируемыми» и должны проходить через мелкое сито htmlentities(). Да, это кажется излишним усложнением — но в будущем это как минимум убережет от порчи вида игры, а как максимум — в определенной мере гарантирует невозможность заражения компьютера игрока враждебными скриптами (100% гарантию даёт только «Госстрах»).
Здесь стоит сделать отступление и подробно поговорить о каждом типе контролируемых данных.
### Контролируемые данные в HTML
Начнём с самого простого — с гарантированно нормализованных целых чисел. К ним относятся переменные $variable, которые на проверку is\_int($variable) отвечают 'true'. Тупо. Прямо. В лоб. 100% гарантия, что данные переменные при выводе будут состоять только из десятичных цифр, не содержат ничего постороннего и одинаково красиво выглядят в HTML и JS.
Простые строки локализации — это строки из текущей локали, которые состоят из одной строки, не содержат HTML-тэгов, не содержат спецсимволов HTML типа < > " ', переводов строки, не являются регекспами и не являются шаблонами. Здесь тоже вроде всё понятно с первого взгляда. Вроде бы строки локализации полностью контролирует разработчик движка. Вроде бы никаких подводных камней быть не должно — и все эти уточнения излишни… WRONG!
Типичнейшая ошибка — использование шаблонов строк типа «Начало строки %s остальная строка» с последующим использованием функции sprintf(). Мы помним, что данные у нас — должны быть нормализированы, т.е. приведены к стандартному формату. Однако нигде не сказано, что нормальный формат хоть для чего-то является безопасным! Нормализация формата переменных всего лишь гарантирует единообразие вида данных, обрабатываемых в разных кусках кода — и не более того. Являются ли данные безопасными для вывода в HTML или (тем более!) для записи в БД — это нам неизвестно (вообще-то известно — по определению не являются). Поэтому прямой вывод данных в шаблон без указания дополнительных модификаторов — недопустим. Более того — не всякий модификатор гарантирует безопасный вывод данных.
Замечу — тут мы говорим именно о безопасности вывода, а не о корректности. Например, вывод переменной в шаблон "%d" является безопасным, но не является корректным — если, например, на вход будет подана строка, не сводимая к целому. Тут опять же не могу не отослать к документации: [php.net/manual/ru/function.sprintf.php](http://php.net/manual/ru/function.sprintf.php)
По нормальным делам все строки локализации должны быть гарантированно простыми. Однако идеал — это то, к чему нужно стремится, но и одновременно то, что является недостижимым в реальности.
Практические аспекты и расчёты трудозатрат говорят, что иногда приходится делать и не-простые строки локализации — например, добавлять HTML-форматирование сразу в строку. Я считаю — что это приемлемо до тех пор, пока разработчик осознаёт все риски и контролирует употребление неконвенциональных строк локализации.
Почему гарантированно нормированные строки должны содержать только одну строку/параграф — должно быть уже понятно из прочитанного выше. Но на всякий случай повторюсь — многострочные строки (даже нормированные) требуют разного отношение при выводе в HTML, JS или при сохранении в БД.
### Неконтролируемые данные в HTML
Выше мы рассмотрели три вида контролируемых данных, которые (с оговоркам) могут выводится напрямую в HTML минуя функцию htmlentities(). Все остальные данные В ОБЯЗАТЕЛЬНОМ ПОРЯДКЕ должны проходить через вышеупомянутую функцию! Однако здесь есть НЮАНСЫ.
Фактически, «неконтролируемыми данными» являются пользовательские данные, либо строки, не подходящие под вышеописанные критерии. Как работать с пользовательскими данными — будет подробно описано в следующей статье. А работа со строками движка (в частности — локализация) — достаточно деликатная тема.
В зависимости от качества исходного продукта, принципы работы со строками, источниками которых является сам движок, могут сильно отличаться. Я могу дать лишь рекомендации — которые ни в коем случае не должны являться догмой. Очень многое зависит от того, как движок описывает многострочные данные вообще и строки локализации — в частности.
1. Если движок использует для разделения строк в тексте символы CR, LF или комбинацию CR+LF — используйте сначала htmlentities(), а затем — PHP-функцию nl2br() [php.net/manual/ru/function.nl2br.php](http://php.net/manual/ru/function.nl2br.php)
2. Если движок использует для разделения строк тэг — выводите данные напрямую, если вы полностью проверили код и уверены в его безопасности
3. Весь вывод шаблонов с использованием форматирования "%s" и аналогичного — всегда ДОЛЖЕН проходить через htmlentities()!
В любом случае ВСЕГДА нужно помнить основополагающий принцип — лучше вывести игроку «некрасивую», но гарантированно безопасную строку, чем в 99,99% выводить «красоту», а в 0,01% — заражать компьютер игрока вредоносным скриптом.
В следующей статье:
— Вывод данных в JavaScript — особенности и приколы;
— Запись данных в БД — как не «попасть» на SQL-injection;
— Как убедится, что данные от пользователя не являются «токсичными»;
— … и многое другое | https://habr.com/ru/post/275767/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.