text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# ZBase32, Base32 и Base64 алгоритмы кодирования
Привет!
Многие используют Base64 кодирование, реже Base32 и еще реже **ZBase32** (вы знаете о таком?), но не все понимают их алгоритмы. В статье я описываю достоинства, недостатки данных кодировок, а также рассказываю о их реализации.
Не так давно у меня возникла необходимость использовать кодированные данные в адресе http-ссылки. Как известно, стандарт http подразумевает регистро**не**зависимые url-адреса и любой прокси-сервер или браузер мог испортить данные в случае использования регистрочувствительного кодирования.
Учитывая указанные требования в качестве алгоритма было выбрано ZBase32-кодирование.
Как оказалось, стандартной реализации в .net нет (в отличие от base64), поэтому пришлось писать самому. К своему удивлению, я столкнулся с трудностями при поиске внятного объяснения Base32 и ZBase32. Были найдены какие-то готовые решения, но я не мог, не разобравшись в алгоритме применять их, а читать магию больших формул, битовых сдвигов было тяжело без словесного описания. Теперь, когда для меня все позади, я хотел бы поделиться с вами небольшим знанием элементарного кодирования. Статья носит академический характер.
#### Плюсы и минусы
##### Base64
Позволяет кодировать информацию, представленную набором байтов, используя всего 64 символа: A-Z, a-z, 0-9, /, +. В конце кодированной последовательности может содержаться несколько спецсимволов (обычно “=”).
Преимущества:
* Позволяет представить последовательность любых байтов в печатных символах.
* В сравнении с другими Base-кодировками дает результат, который составляет только 133.(3)% от длины исходных данных.
Недостатки:
* Регистрозависимая кодировка.
##### Base32
Использует только 32 символа: A-Z (или a-z), 2-7. Может содержать в конце кодированной последовательности несколько спецсимволов (по аналогии с base64).
Преимущества:
* Последовательность любых байтов переводит в печатные символы.
* Регистронезависимая кодировка.
* Не используются цифры, слишком похожие на буквы (например, 0 похож на О, 1 на l).
Недостатки:
* Кодированные данные составляют 160% от исходных.
##### ZBase32
Кодировка аналогична Base32, но имеет следующие отличия.
* Человеко-ориентированный алфавит из 32 символов. Наиболее проработанная таблица символов для облегчения написания, произношения и запоминания кодированной информации. Авторы переставили наиболее удобные для человека символы на позиции, которые используются чаще всего. Как они это сделали я не знаю. Алфавит приводится ниже.
* Нет специальных символов в конце результата кодирования.
Подробнее про каждую из кодировок можно почитать в Википедии [здесь](http://en.wikipedia.org/wiki/Base32) и [здесь](http://en.wikipedia.org/wiki/Base64), а сейчас я хотел бы остановиться непосредственно на реализации ZBase32.
#### Описание алгоритма ZBase32 кодирования
*Позволю себе при описании алгоритма показывать выкладки на C# для большего понимания.*
Итак, имеем 32-х символьный алфавит следующего содержания:
```
static string EncodingTable = "ybndrfg8ejkmcpqxot1uwisza345h769";
```
На входе массив байтов (естественно, по 8 бит каждый), который хотелось бы перевести в символы из алфавита.
```
public static string Encode(byte[] data)
{
```
Алфавит представляет собой строку из 32-х элементов, а это означает, что каждый из его символов кодируется числом от 0 до 31 (индексы символов в строке). Как известно, любое число от 0 до 31 в бинарной системе счисления можно записать, используя 5 битов байта. Из этого следует, что если представить исходный набор байтов как единый массив битов и разбить его на кусочки по 5 битов (см. рисунок ниже), то мы получим набор координат символов из алфавита. Вот, собственно, и все.
*Алгоритмы Base32 и Base64 аналогичны ZBase32, только разные алфавиты (по составу в случае с Base32, по составу и размеру в случае Base64) и размеру “отщипываемых” кусочков бит (6 бит для Base64).*
Итак, я предлагаю перед тем, как начать разбиение исходных данных на кусочки по 5 бит, подготовить место куда будет записываться результат. Чтобы не задумываться об индексах в статических массивах, давайте использовать StringBuilder.
```
var encodedResult = new StringBuilder((int)Math.Ceiling(data.Length * 8.0 / 5.0));
```
При инициализации сразу задаем размер результирующей строки (чтобы не тратить время на расширение в процессе работы алгоритма).
Теперь осталось пробежать по исходному массиву байтов и разделить его на 5-и битовые кусочки. Для удобства я предлагаю работать с группой по 5 байтов, так как это 40 бит — число, кратное длине “кусочков”. Но не забываем, что исходные данные никто для нас не подгонял, поэтому учитываем возможность недостачи.
```
for (var i = 0; i < data.Length; i += 5)
{
var byteCount = Math.Min(5, data.Length - i);
```
Так как мы работаем с группой из 5 байтов, нам нужен буфер, где будет формироваться сплошной набор битов (всего 40 бит). Заведем переменную типа ulong (64 бита в нашем распоряжении) и поместим туда текущую партию байтов.
```
ulong buffer = 0;
for (var j = 0; j < byteCount; ++j)
{
buffer = (buffer << 8) | data[i + j];
}
```
И заключительный этап — это “отщипывание” из того, что получилось, кусочков по 5 бит и формирование результата.
```
var bitCount = byteCount * 8;
while (bitCount > 0)
{
var index = bitCount >= 5
? (int)(buffer >> (bitCount - 5)) & 0x1f
: (int)(buffer & (ulong)(0x1f >> (5 - bitCount))) << (5 - bitCount);
encodedResult.Append(EncodingTable[index]);
bitCount -= 5;
}
```
Возможно, в последнем примере кода с первого взгляда не все понятно, но если вы немного сосредоточитесь, то все станет на свои места.
Процесс декодирования происходит аналогично процессу кодирования, только в обратном направлении.
Вы можете посмотреть полную реализацию [ZBase32Encoder](https://github.com/denxc/ZBase32Encoder).
#### Заключение
И, конечно, в заключение хочется сказать следующее.
```
4nq7bcgosuemmwcq4gy7ddbcrdeadwcn4napdysttuea6egosmembwfhrdemdwcm4n77bcby4n97bxsozzea9wcn4n67bcby4nhnbwf94n9pbq6oszemxwf74nanhegow8em9wfo4gy7bqgos8emhegos9emyegosmem5wfa4n6pbcgozzemtwfirr
``` | https://habr.com/ru/post/190054/ | null | ru | null |
# Обновление Yota Access на модеме
Друзья! Вышел новый Yota Access v. 1.21
По словам представителей Yota, " В новой версии решена проблема с некорректно выставляемым значением MTU, из-за чего могли не открываться некоторые странички, в частности, [www.microsoft.com](http://www.microsoft.com).". И со слов пользователей, «стало на много быстрее».
[Скачать](http://www.yota.ru/downloads/YotaAccess_v.121_CF01.exe) можно тут.
Но! Как известно, на самом модеме существует память, в которую записывается дистрибутив Yota Access, чтобы устанавливать на новом компьютере. И с каждой перепрошивкой он там не обновляется.
Чтобы обновить версию дистрибутива на модеме, необходимо сделать следующее:
1. Скачать ISO-образ дистрибутива ([народ.ру](http://narod.ru/disk/10272022000/YotaAccess_v.121_CF01.iso.html))
2. Выполнить команду:
`FWUpdate.exe -language English -nvc -debug -loglevel 1 -mymodel SWC-U200 -leavefw -authkey "dhkdlqmfhakstp" -update i -binpath "%%%"`
FW Update.exe находится в папке “C:\Program Files\Samsung Electronics\mWiMAX U200\Firmware”
В кавычках вместо %%% указывается путь к папке с ISO файлом (без имени файла).
3. Дождаться окончания перепрошивки. | https://habr.com/ru/post/62932/ | null | ru | null |
# Хактивисты перешли к конкретике: атакован производитель слезоточивого газа и наручников
Группа анонимных хактивистов Anonymous, которую связывают с протестным движением «Захвати Уолл-стрит», во вторник выполнила дефейс и вывела из строя сайт пенсильванской компании [Combined Systems Inc.](http://www.combinedsystems.com/) (*не работает на данный момент*), являющейся производителем средств контроля массовых собраний людей — слезоточивого газа, аэрозольных, звуковых и световых гранат, наручников и т.п. Около года назад, во время массовых волнений в Египте, компания поставила местным властям более 46 тонн производимых ей товаров — именно это и стало причиной атаки, которая, к тому же, была приурочена к годовщине событий в Бахрейне. В результате атаки были украдены личные данные сотрудников компании и её клиентов. Владельцы компании пока никак не комментировали компрометацию своего сайта.
Вполне традиционно хактивисты разместили на PasteBin запись, поясняющую мотивы своих действий и, собственно, «слитые данные» — фамилии и имена сотрудников, клиентов, дистрибьюторов, их логины, пароли, письма, номера телефонов; также присутствуют дампы таблиц MySQL.
В довершение к этому хакеры не преминули поиздеваться над компанией sur-tec.com (*не работает на данный момент*), основанной бывшим директором ФБР [Кларенсом Келли](http://en.wikipedia.org/wiki/Clarence_M._Kelley) и специализирующейся на решениях компьютерной безопасности: паролем для доступа к административной части сайта был "*government*". В качестве примера того, как устроена система аутентификации таких сайтов, хактивисты приводят следующий код:
```
php
ob_start();
$skip_check = true;
$SKIP_OUTPUT = false;
include( "header.php" );
if ( $username == "sprint" && $password == "publicsector" ) {
$admin-setSession();
header( "Location: /sprint/downloads.php" );
exit;
}
else {
header( "Location: /sprint/" );
exit;
}
?>
```
[[PasteBin](http://pastebin.com/DaauwSzQ)] | https://habr.com/ru/post/138300/ | null | ru | null |
# Interprocess communication с использованием GRPC
Сегодня хочу рассказать о нашем пути реализации межпроцессного взаимодействия между приложениями на NET Core и NET Framework при помощи протокола GRPC. Ирония заключается в том, что GRPC, продвигаемый Microsoft как замена WCF на своих платформах NET Core и NET5, в нашем случае случился именно из-за неполноценной реализации WCF в NET Core.
Я надеюсь эта статья найдется поиском когда кто-то будет рассматривать варианты организации IPC и позволит посмотреть на такое высокоуровневаое решение как GRPC с этой, низкоуровневой, стороны.
Вот уже более 7 лет моя трудовая деятельность связана с тем, что называют "информатизация здравоохранения". Это довольно интересная сфера, хотя и имеющая свои особенности. Некоторыми из них явяляются зашкаливающее количество легаси технологий (консервативность) и определнная закрытость для интеграции у большинства существующих решений (вендор-лок на экосистеме одного производителя).
Контекст
========
С комбинацией этих двух особенностей мы и столкнулись на текущем проекте: нам понадобилось инициировать работу и получать данные из некоего программно-аппаратного комплекса. Поначалу все выглядело очень неплохо: софтовая часть комплекса поднимает WCF службу, которая принимает команды на выполнение и выплёвывает результаты в файл. Более того, производитель предоставляет SDK с примерами! Что может пойти не так? Всё вполне технологично и современно. Никакого ASTM с палочками-разеделителями, ни даже обмена файлами через общую папку.
Но по какой-то странной причине, WCF служба использует дуплексные каналы и привязку `WSDualHttpBinding`, которая недоступна под .NET Core 3.1, только в "большом" фреймворке (или уже в "старом"?). При этом дуплексность каналов никак не используется! Она просто есть в описании службы. Облом! Ведь остальной проект живет на NET Core и отказываться от этого нет никакого желания. Придется собирать этот "драйвер" в виде отдельного приложения на NET Framework 4.8 и каким то образом пытаться организовать хождение данных между процессами.
Межпроцессное взаимодействие
============================
В теме межпроцессного взаимодействия действительно есть из чего выбрать. Можно обмениваться файлами, кидать сигналы, использовать мьютексы, именованные каналы, поднять соединение через tcp-сокет, или даже воспользоваться каким-нибудь RPC протоколом верхнего уровня. Чтобы не потонуть в этом многообразии попробуем сформулировать требования к службе IPC:
* возможность передавать команды, в том числе параметризованные
* возможность получать ответы о результате выполнения команды
* возможность асинхронно получать ответы о ходе выполнения долгоиграющей задачи
* контроль получения сообщений второй стороной
* Поддержка в Windows (начиная с 7 версии)
* Поддержка в NET Framework и NET Core
* Строгая типизация сообщений
* Расширяемость
* Поменьше боли
Последний пункт самый важный, потому что всегда можно сгородить сколь угодно сложный и замороченный велосипед на базе самых низкоуровневых примитивов, например разделяемой памяти и мьютексов. Но зачем?
Именованные каналы
==================
Да, мы сделали это. В первой итерации были выбраны именно именованные каналы, по которым передавались команды и данные. У нас были абстракции для команды и для данных, и два однонаправленных канала в каждом "соединении". У нас не было контроля получения сообщений, зато была боль с поддержкой стейта — канал мог развалиться по каким то странным причинам. У нас не было связного асинхронного потока ответов о прогрессе долгоиграющей операци, зато были отдельные события получения сообщения и серверу надо было передавать исходную команду к которой относится ответ. У нас не было настоящей строгой типизации, а только надежда что на той стороне данные упаковали в правильную "команду" или "ответ". Боль? Боль была, постоянная: трудновоспроизводимые баги, никакущий дебаг, мрак и заброшенность.
На самом деле все было не так плохо. Это решение работало и проработало почти год. Мы потратили много времени на его тестирование, отлавливание багов, восстановление стейта, выработку workaround, чтобы его можно было использовать у конечных пользователей. Но мне кажется его никто не любил.
GRPC
====
Уныло поглядев на в очередной раз глюканувший софт, рассказывающий о сломанных трубах, было принято решение все переписать. И переписать на GRPC. Почему GRPC? Ну, мы используем его в хвост и гриву для взаимодействия между клиентом и основным сервером приложения. Он произвел впечатление достаточно быстрого и богатого возможностями решения.
Что касается чеклиста с требованиями, то получается примерно так:
* возможность передавать команды, в том числе параметризованные — да, это то что называется Unary call
* возможность получать ответы о результате выполнения команды — то же
* возможность асинхронно получать ответы о ходе выполнения долгоиграющей задачи — да, это server streaming rpc
* контроль получения сообщений второй стороной — обеспечивается транспортным уровнем HTTP/2
* Поддержка в Windows (начиная с 7 версии) — да, но в семёрке есть определённые ограничения
* Поддержка в NET Framework и NET Core — да
* Строгая типизация сообщений — да, обеспечивается форматом protobuf
* Расширяемость — и расширяемость
* Поменьше боли — больно почти не будет ~~, как комарик укусит~~
Затаскиваем GRPC за 5 минут
===========================
Я позволю себе написать очередной tutorial. Туториалов по GRPC много, но они все одинаковые и не об этом, а в начале своего пути по дороге IPC я бы хотел чтобы что-то такое попалось мне на глаза. Все примеры кода есть в репозитории [тут](https://github.com/zetroot/IpcGrpcSample).
Подготовка
----------
Наше решение будет состоять из трёх сборок:
* `IpcGrpcSample.CoreClient` — консольное приложение под NET Core 3.1, будет играть роль клиента RPC
* `IpcGrpcSample.NetServer` — консольное приложение под NET Framework 4.8, будет за сервер RPC
* `IpcGrpcSample.Protocol` — библиотека, нацеленная на NET Standard 2.0. В ней будет определен контракт RPC
Для удобства работы отредактируем формат файла проекта на NET Framework под новый лад и снесем `Properties\AssemblyInfo.cs`
```
net48
...
...
...
```
Настало время тащить NuGet!
* В проект `IpcGrpcSample.Protocol` подключаем пакеты `Google.Protobuf`, `Grpc` и `Grpc.Tools`
* В сервер затащим `Grpc`, `Grpc.Core`, `Microsoft.Extensions.Hosting` и `Microsoft.Extensions.Hosting.WindowsServices`.
* В клиента тащим `Grpc.Net.Client` и `OneOf` — он нам пригодится.
Описываем gRPC службу
---------------------
Наверно всем уже надоел пример с `GreeterService`? Давайте что-нибудь повеселее. Сделаем две службы. Одна будет управлять термоциклером-амплификатором, другая будет запускать протокол экстракции на автомтаизированной станции экстракции.
Службы описываются в виде `.proto` файлов в разделяемой сборке `IpcGrpcSample.Protocol`. Protobuf-компилятор потом соберет из них нужные нам классы и заготовки под сервисы и клиентов.
Описание службы работы с роботизированной станцией
```
//указание синтаксиса описания
syntax = "proto3";
// импорт типа Empty
import "google/protobuf/empty.proto";
// классы будут генерироваться в этом пространстве имен
option csharp_namespace = "IpcGrpcSample.Protocol.Extractor";
// описание методов RPC службы управления экстрактором
service ExtractorRpcService {
// унарный вызов "запускающий" операцию
rpc Start (google.protobuf.Empty) returns (StartResponse);
}
// ответ на старт
message StartResponse {
bool Success = 1;
}
```
Описание службы работы с термоциклером
```
//указание синтаксиса описания
syntax = "proto3";
// классы будут генерироваться в этом пространстве имен
option csharp_namespace = "IpcGrpcSample.Protocol.Thermocycler";
// описание методов RPC службы управления термоциклером
service ThermocyclerRpcService {
// server-streaming вызов "запускающий эксперимент". На один запрос отправит множество сообщений-ответов, которые будут доступны асинхронно
rpc Start (StartRequest) returns (stream StartResponse);
}
// описание сообщения - запроса на запуск эксперимента
message StartRequest {
// поля запроса - это поле будет названием эксперимента
string ExperimentName = 1;
// а числовое поле - количество циклов, в ходе которых прибор будет "снимать показания" и отправлять назад
int32 CycleCount = 2;
}
// сообщение из стрима после старта
message StartResponse {
// номер цикла
int32 CycleNumber = 1;
// поле в виде конструкции oneof - сообщение может содержать объект одного из типов.
// Что-то вроде discriminated union, но попроще
oneof Content {
// прочитанные данные реакционного блока
PlateRead plate = 2;
// сообщение статуса прибора
StatusMessage status = 3;
}
}
message PlateRead {
string ExperimentalData = 1;
}
message StatusMessage {
int32 PlateTemperature = 2;
}
```
Все proto-файлы надо пометить как компилируемые protobuf компилятором. Ручками по одному или добавить в csproj эти строки:
```
```
Строим сервер
-------------
На дворе 2020 год и поэтому сервер соберем на базе Hosting абстракций из NET Core. Сразу вставляем такой сниппет в Program.cs:
```
class Program
{
static Task Main(string[] args) => CreateHostBuilder(args).Build().RunAsync();
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.UseWindowsService()
.ConfigureServices(services =>
{
services.AddLogging(loggingBuilder =>
{
loggingBuilder.ClearProviders();
loggingBuilder.SetMinimumLevel(LogLevel.Trace);
loggingBuilder.AddConsole();
});
services.AddTransient(); // регистрация зависимостей - сервисов с логикой управления приборами
services.AddTransient();
services.AddHostedService(); // регистрация GRPC сервера как HostedService
});
}
```
Обойдемся в примере без конфигурации и логгирования. Реализация служб (контроллеров) будет внедряться в сервер через конструктор.
Код сервера достаточно прямолинеен — в методе старта службы сервер поднимается, в методе остановки — останавливается. Здесь можно определить будет ли сервер использовать TLS (тогда ему нужен сертификат для шифрования) или трафик будет ходить без шифрования — и тогда необходимо использовать `ServerCredentials.Insecure`. Зачем это может пригодиться и что еще необходимо сделать чтобы гонять голый http/2 трафик — в конце.
```
internal class GrpcServer : IHostedService
{
private readonly ILogger logger;
private readonly Server server;
private readonly ExtractorServiceImpl extractorService;
private readonly ThermocyclerServiceImpl thermocyclerService;
public GrpcServer(ExtractorServiceImpl extractorService, ThermocyclerServiceImpl thermocyclerService, ILogger logger)
{
this.logger = logger;
this.extractorService = extractorService;
this.thermocyclerService = thermocyclerService;
var credentials = BuildSSLCredentials(); // строим креды из сертификата и приватного ключа.
server = new Server //создаем объект сервера
{
Ports = { new ServerPort("localhost", 7001, credentials) }, // биндим сервер к адресу и порту
Services = // прописываем службы которые будут доступны на сервере
{
ExtractorRpcService.BindService(this.extractorService),
ThermocyclerRpcService.BindService(this.thermocyclerService)
}
};
}
///
/// Вспомогательный метод генерации серверных кредов из сертификата
///
private ServerCredentials BuildSSLCredentials()
{
var cert = File.ReadAllText("cert\\server.crt");
var key = File.ReadAllText("cert\\server.key");
var keyCertPair = new KeyCertificatePair(cert, key);
return new SslServerCredentials(new[] { keyCertPair });
}
public Task StartAsync(CancellationToken cancellationToken)
{
logger.LogInformation("Запуск GRPC сервера");
server.Start();
logger.LogInformation("GRPC сервер запущен");
return Task.CompletedTask;
}
public async Task StopAsync(CancellationToken cancellationToken)
{
logger.LogInformation("Останов GRPC сервера");
await server.ShutdownAsync();
logger.LogInformation("GRPC сервер остановлен");
}
}
```
Осталось закинуть какую нибудь логику в контроллеры и стартовать!
У экстрактора очень простой сервис. Будет через раз отвечать что все получилось или нет:
```
internal class ExtractorServiceImpl : ExtractorRpcService.ExtractorRpcServiceBase
{
private static bool success = true;
public override Task Start(Empty request, ServerCallContext context)
{
success = !success;
return Task.FromResult(new StartResponse { Success = success });
}
}
```
А у термоциклера организуем что-нибудь повеселее:
```
internal class ThermocyclerServiceImpl : ThermocyclerRpcService.ThermocyclerRpcServiceBase
{
private readonly ILogger logger;
public ThermocyclerServiceImpl(ILogger logger)
{
this.logger = logger;
}
public override async Task Start(StartRequest request, IServerStreamWriter responseStream, ServerCallContext context)
{
logger.LogInformation("Эксперимент начинается");
var rand = new Random(42);
for(int i = 1; i <= request.CycleCount; ++i)
{
logger.LogInformation($"Отправка цикла {i}");
var plate = new PlateRead { ExperimentalData = $"Эксперимент {request.ExperimentName}, шаг {i} из {request.CycleCount}: {rand.Next(100, 500000)}" };
await responseStream.WriteAsync(new StartResponse { CycleNumber = i, Plate = plate });
var status = new StatusMessage { PlateTemperature = rand.Next(25, 95) };
await responseStream.WriteAsync(new StartResponse { CycleNumber = i, Status = status });
await Task.Delay(500);
}
logger.LogInformation("Эксперимент завершен");
}
}
```
Сервер готов. Можно позапускать консольку и убедиться что GRPC сервер поднимается и останавливается по нажатию на `Ctrl-C`:
```
dbug: Microsoft.Extensions.Hosting.Internal.Host[1]
Hosting starting
info: IpcGrpcSample.NetServer.GrpcServer[0]
Запуск GRPC сервера
info: IpcGrpcSample.NetServer.GrpcServer[0]
GRPC сервер запущен
info: Microsoft.Hosting.Lifetime[0]
Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
Hosting environment: Production
info: Microsoft.Hosting.Lifetime[0]
Content root path: C:\Users\user\source\repos\IpcGrpcSample\IpcGrpcSample.NetServer\bin\Debug
dbug: Microsoft.Extensions.Hosting.Internal.Host[2]
Hosting started
info: Microsoft.Hosting.Lifetime[0]
Application is shutting down...
dbug: Microsoft.Extensions.Hosting.Internal.Host[3]
Hosting stopping
info: IpcGrpcSample.NetServer.GrpcServer[0]
Останов GRPC сервера
info: IpcGrpcSample.NetServer.GrpcServer[0]
GRPC сервер остановлен
dbug: Microsoft.Extensions.Hosting.Internal.Host[4]
Hosting stopped
```
Соответственно в контроллерах может быть все что угодно: маппинг с транспортной модели на модель бизнеслогики которую нужно дергать из NET Framework, вызов WCF etc. И не надо тащить никакого Kestrel!
Сервер без клиента можно подергать например при помощи [grpcurl](https://github.com/fullstorydev/grpcurl), но все городилось для межпроцессного взаимодействия. Нужен клиент на NET Core.
Клиентская часть на NET Core
----------------------------
Здесь все проще. Реализуем пару клиентов для сервисов и будем слушать ввод от пользователя.
Код сервиса экстрактора прямолинеен и тривиален. В конструкторе настраивается канал и создается gRPC клиент. Единственный метод дергает RPC метод и разворачивает результат.
```
class ExtractorClient
{
private readonly ExtractorRpcService.ExtractorRpcServiceClient client;
public ExtractorClient()
{
//AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true); //без этого кода невозможна коммуникация через http/2 без TLS
var httpClientHandler = new HttpClientHandler
{
ServerCertificateCustomValidationCallback = HttpClientHandler.DangerousAcceptAnyServerCertificateValidator // заглушка для самоподписанного сертификата
};
var httpClient = new HttpClient(httpClientHandler);
var channel = GrpcChannel.ForAddress("https://localhost:7001", new GrpcChannelOptions { HttpClient = httpClient });
client = new ExtractorRpcService.ExtractorRpcServiceClient(channel);
}
public async Task StartAsync()
{
var response = await client.StartAsync(new Empty());
return response.Success;
}
}
```
В клиенте термоциклера используем `IAsyncEnumerable<>` возвращающим последовательность из монад `OneOf<,>` — эмулируется асинхронная последовательность данных от прибора.
```
public async IAsyncEnumerable> StartAsync(string experimentName, int cycleCount)
{
var request = new StartRequest { ExperimentName = experimentName, CycleCount = cycleCount };
using var call = client.Start(request, new CallOptions().WithDeadline(DateTime.MaxValue)); // настройка времени ожидания
while (await call.ResponseStream.MoveNext())
{
var message = call.ResponseStream.Current;
switch (message.ContentCase)
{
case StartResponse.ContentOneofCase.Plate:
yield return message.Plate.ExperimentalData;
break;
case StartResponse.ContentOneofCase.Status:
yield return message.Status.PlateTemperature;
break;
default:
break;
};
}
}
```
Остальной код клиента тривиален и позволяет только позапускать клиентов в цикле и вывести результаты на консоль.
HTTP/2 и Windows 7
==================
Оказалось, что в седьмой версии Windows нет поддержки TLS в HTTP/2. Поэтому сервер надо бинить немного иначе, используя небезопасные креды:
```
server = new Server //создаем объект сервера
{
Ports = { new ServerPort("localhost", 7001, ServerCredentials.Insecure) }, // биндим сервер к адресу и порту
Services = // прописываем службы которые будут доступны на сервере
{
ExtractorRpcService.BindService(this.extractorService),
ThermocyclerRpcService.BindService(this.thermocyclerService)
}
};
```
И у клиентов необходимо указать в качестве протокола `http`, а не `https`. Но это не все. Необходимо так же сообщить среде, что будет осознанно использоваться небезопасное соединение по http/2:
```
AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
```
В коде проекта специально сделано много упрощений — не обрабатываются исключения, не ведется нормально логгирование, параметры захардкожены в код. Это не production-ready, а заготовка для решения проблем. Надеюсь, было интересно, задавайте вопросы! | https://habr.com/ru/post/523638/ | null | ru | null |
# [Перевод] Envoy модель потоков (Envoy threading model)
Привет, Хабр! Представляю вашему вниманию перевод статьи [«Envoy threading model»](https://blog.envoyproxy.io/envoy-threading-model-a8d44b922310) автора Matt Klein.
Данная статься показалась мне достаточно интересной, а так как Envoy чаще всего используется как часть «istio» или просто как «ingress controller» kubernetes, следовательно большинство людей не имеют с ним такого же прямого взаимодействия как например с типовыми установками Nginx или Haproxy. Однако если что-то ломается, было бы хорошо понимать как оно устроенно изнутри. Я постарался перевести как можно больше текста на русский в том числе и специальные слова, для тех кому больно на такое смотреть я оставил оригиналы в скобках. Добро пожаловать под кат.
Техническая документация низкого уровня по кодовой базе Envoy в настоящее время довольно скудная. Чтобы исправить это, я планирую сделать серию статей в блоге о различных подсистемах Envoy. Так как это первая статья, пожалуйста, дайте мне знать, что вы думаете и что вам могло быть интересно в следующих статьях.
Один из наиболее распространенных технических вопросов, которые я получаю о Envoy, это запрос на низкоуровневое описание используемой модели потоков (threading model). В этом посте я опишу как Envoy сопоставляет соединения с потоками, а также описание системы локального хранилища потоков (Thread Local Storage), которая используется внутри, чтобы сделать код более параллельным и высокопроизводительным.
Описание потоков (Threading overview)
=====================================
**Envoy использует три различных типа потоков:**
* **Основной (Main):** Этот поток управляет запуском и завершением процесса, всей обработкой XDS (xDiscovery Service) API, включая DNS, проверку работоспособности (health checking), общее управление кластером и процессом работы сервиса (runtime), сбросом статистики, администрирование и общее управление процессами — Linux сигналы, горячий перезапуск (hot restart) и т. д. Все, что происходит в этом потоке, является асинхронным и «неблокирующим». В целом основной поток координирует все критические процессы функциональности, для выполнения которых не требуется большого количества ЦПУ. Это позволяет большую часть кода управления писать так, как если бы он был однопоточным.
* **Рабочий (Worker):** По умолчанию Envoy создает рабочий поток(worker thread) для каждого аппаратного потока в системе, это можно контролировать с помощью опции `--concurrency`. Каждый рабочий поток запускает «неблокирующий» цикл событий (event loop), который отвечает за прослушивание (listening) каждого прослушивателя (listener), на момент написания статьи (29 июля 2017 г.) нет сегментирования (sharding) прослушивателя (listener), прием новых соединений, создание экземпляра стека фильтров для подключения и обработку всех операций ввода-вывода (IO) за время существования соединения. Опять же, это позволяет большую часть кода обработки соединений писать так, как если бы он был однопоточным.
* **Файловый (File flusher):** Каждый файл, который пишет Envoy, в основном журналы доступа (access logs), в настоящее время имеет независимый блокирующий поток. Это связано с тем, что запись в файлы кэшированные файловой системой даже при использовании `O_NONBLOCK` иногда может блокироваться (вздох). Когда рабочим потокам необходимо записать в файл, данные фактически перемещаются в буфер в памяти, где они в конечном итоге сбрасываются через поток **file flush**. Это одна из областей кода, в которой технически все рабочие потоки (worker threads) могут блокировать (block) одну и ту же блокировку (lock), пытаясь заполнить буфер памяти.
Обработка соединений (Connection handling)
==========================================
Как обсуждалось вкратце выше, все рабочие потоки прослушивают всех слушателей (listeners) без какого-либо сегментирования. Таким образом, ядро используется для грамотной отправки принятых сокетов в рабочие потоки. Современные ядра в целом очень хороши в этом, они используют такие функции, как повышение приоритета ввода-вывода (IO), чтобы попытаться заполнить поток работой, прежде чем начать использовать другие потоки, которые также прослушивают тот же сокет, а также не использовать циклическую блокировку (Spinlock) для обработки каждого запроса.
Как только соединение принято на рабочем потоке (worker thread), оно никогда не покидает этот поток (thread). Вся дальнейшая обработка соединения полностью обрабатывается в рабочем потоке (worker thread), включая любое поведение пересылки (forwarding behavior).
**Это имеет несколько важных последствий:**
* Все пулы соединений в Envoy относятся к рабочему потоку. Таким образом, хотя пулы соединений HTTP/2 делают только одно соединение с каждым вышестоящим хостом за раз, если есть четыре рабочих потока, будет четыре соединения HTTP/2 на вышестоящий хост в устойчивом состоянии.
* Причина, по которой Envoy работает таким образом, заключается в том, что, сохраняя все в одном рабочем потоке, почти весь код может быть написан без блокировок и как будто он однопоточный. Этот дизайн упрощает написание большого количества кода и невероятно хорошо масштабируется для почти неограниченного числа рабочих потоков.
* Однако, одним из основных выводов является то, что с точки зрения эффективности пула памяти и соединений на самом деле очень важно настроить параметр `--concurrency`. Наличие большего количества рабочих потоков, чем необходимо, приведет к потере памяти, созданию большего количества бездействующих соединений и снижению скорости попадания в пул соединений. В Lyft наши envoy sidecar контейнеры работают с очень низким параллелизмом, так что производительность примерно соответствует службам, рядом с которыми они сидят. Мы запускаем Envoy в качестве пограничного прокси-сервера (edge) только при максимальном параллелизме (concurrency).
Что означает не блокирующий режим (What non-blocking means)
===========================================================
Термин «неблокирующий» до сих пор использовался несколько раз при обсуждении того, как работают основной и рабочий потоки. Весь код написан при условии, что ничто никогда не блокируется. Однако, это не совсем верно (что не совсем верно?).
**Envoy использует несколько длительных блокировок процесса:**
* Как уже говорилось, при записи журналов доступа все рабочие потоки получают одинаковую блокировку перед заполнением буфера журнала в памяти. Время удержания блокировки должно быть очень низким, но возможно, что эта блокировка будет оспариваться при высоком параллелизме и высокой пропускной способности.
* Envoy использует очень сложную систему для обработки статистики, которая является локальной для потока. Это будет тема отдельного поста. Тем не менее, я кратко упомяну, что как часть локальной обработки статистики потока иногда требуется получить блокировку для центрального «хранилища статистики». Эта блокировка не должна когда-либо требоваться.
* Основной поток периодически нуждается в координации со всеми рабочими потоками. Это делается путем «публикации» из основного потока в рабочие потоки, а иногда и из рабочих потоков обратно в основной поток. Для отправки требуется блокировка, чтобы опубликованное сообщение можно было поместить в очередь для последующей доставки. Эти блокировки никогда не должны подвергаться серьезному соперничеству, но они все равно могут технически блокироваться.
* Когда Envoy пишет журнал в системный поток ошибок (standard error), он получает блокировку всего процесса. В целом, локальное ведение журнала Envoy считается ужасным с точки зрения производительности, поэтому его улучшению не уделяется много внимания.
* Есть несколько других случайных блокировок, но ни одна из них не является критической для производительности и никогда не должна оспариваться.
Локальное хранилище потока (Thread local storage)
=================================================
Из-за способа, которым Envoy отделяет обязанности основного потока от обязанностей рабочего потока, существует требование, что сложная обработка может быть выполнена в главном потоке, а затем предоставлена каждому рабочему потоку с высокой степенью параллелизма. В этом разделе описана система Envoy Thread Local Storage (TLS) на высоком уровне. В следующем разделе я опишу, как он используется для управления кластером.
Как уже было описано, основной поток обрабатывает практически все функции управления (management) и функциональность плоскости управления (control plane) в процессе Envoy. Плоскость управления здесь немного перегружена, но если рассматривать ее в рамках самого процесса Envoy и сравнивать с пересылкой, которую выполняют рабочие потоки, это представляется целесообразным. По общему правилу процесс основного потока выполняет некоторую работу, а затем ему необходимо обновлять каждый рабочий поток в соответствии с результатом этой работы, при этом рабочему потоку не нужно устанавливать блокировку при каждом доступе.
**Система TLS (Thread local storage) Envoy работает следующим образом:**
* Код, выполняющийся в основном потоке, может выделить слот TLS для всего процесса. Хотя это абстрагировано, на практике это индекс в векторе, обеспечивающий доступ O(1).
* Основной поток может устанавливать произвольные данные в свой слот. Когда это сделано, данные публикуются в каждом рабочем потоке как обычное событие цикла событий.
* Рабочие потоки могут читать из своего слота TLS и извлекать любые локальные данные потоков, доступные там.
Хотя это очень простая и невероятно мощная парадигма, которая очень похожа на концепцию блокировки RCU(Read-Copy-Update). По сути, рабочие потоки никогда не видят каких-либо изменений данных в слотах TLS во время выполнения работы. Изменение происходит только в период покоя между рабочими событиями.
**Envoy использует это двумя разными способами:**
* Сохраняя различные данные на каждом рабочем потоке, доступ к этим данным осуществляется без какой-либо блокировки.
* Сохраняя общий указатель на глобальные данные в режиме «только для чтения» на каждом рабочем потоке. Таким образом, каждый рабочий поток имеет счетчик ссылок на данные, который не может быть уменьшен во время выполнения работы. Только когда все работники успокоятся и загрузят новые общие данные, старые данные будут уничтожены. Это идентично RCU.
Поток обновления кластера (Cluster update threading)
====================================================
В этом разделе я опишу, как TLS (Thread local storage) используется для управления кластером. Управление кластером включает обработку API xDS и / или DNS, а также проверку работоспособности (health checking).
**Управление потоками кластера включает в себя следующие компоненты и этапы:**
1. Менеджер кластера — это компонент внутри Envoy, который управляет всеми известными апстримами (upstream) кластера, API-интерфейсом CDS (Cluster Discovery Service), API-интерфейсами SDS (Secret Discovery Service) и EDS (Endpoint Discovery Service), DNS и активными внешними проверками работоспособности (health checking). Он отвечает за создание в «конечном итоге согласованного» (eventually consistent) представления каждого апстрима (upstream) кластера, который включает обнаруженные хосты, а также состояние работоспособности (health status).
2. Средство проверки работоспособности (health checker) выполняет активную проверку работоспособности и сообщает об изменениях состояния работоспособности диспетчеру кластера.
3. CDS (Cluster Discovery Service) / SDS (Secret Discovery Service) / EDS (Endpoint Discovery Service) / DNS выполняются для определения принадлежности к кластеру. Изменение состояния возвращается менеджеру кластера.
4. Каждый рабочий поток постоянно выполняет цикл обработки событий.
5. Когда менеджер кластера определяет, что состояние для кластера изменилось, он создает новый снимок состояния кластера, доступный только для чтения, и отправляет его в каждый рабочий поток.
6. В течение следующего периода покоя рабочий поток обновит снимок в выделенном слоте TLS.
7. Во время события ввода-вывода, которое должно определить хост для балансировки нагрузки, балансировщик нагрузки будет запрашивать слот TLS (Thread local storage) для получения информации о хосте. Для этого не требуется блокировок. Обратите внимание также, что TLS может также инициировать события при обновлении, так что подсистемы балансировки нагрузки и другие компоненты могут пересчитывать кэши, структуры данных и т.д. Это выходит за рамки этого поста, но используется в различных местах кода.
Используя вышеописанную процедуру, Envoy может обрабатывать каждый запрос без каких-либо блокировок (кроме описанных ранее). Помимо сложности самого кода TLS, большей части кода не нужно понимать, как работает многопоточность, и он может быть написан в однопоточном режиме. Это облегчает написание большей части кода в дополнение к превосходной производительности.
Другие подсистемы, использующие TLS (Other subsystems that make use of TLS)
===========================================================================
TLS (Thread local storage) и RCU (Read Copy Update) широко используются в Envoy.
**Примеры использования:**
* **Механизм изменения функциональности в процессе выполнения:** Текущий список включенного функционала вычисляется в основном потоке. Затем каждому рабочему потоку предоставляется снимок только для чтения с использованием семантики RCU.
* **Замена таблиц маршрутов**: для таблиц маршрутов, предоставляемых RDS (Route Discovery Service), таблицы маршрутов создаются в основном потоке. Снимок только для чтения в дальнейшем будет предоставлен каждому рабочему потоку с использованием семантики RCU (Read Copy Update). Это делает изменение таблиц маршрутов атомарно эффективным.
* **Кэширование заголовков HTTP:** Как выясняется, вычисление заголовка HTTP для каждого запроса (при выполнении ~25K+ RPS на ядро) довольно дорого. Envoy централизованно вычисляет заголовок примерно каждые полсекунды и предоставляет его каждому работнику через TLS и RCU.
Есть и другие случаи, но предыдущие примеры должны обеспечить хорошее понимание того, для чего используется TLS.
Известные подводные камни производительности (Known performance pitfalls)
=========================================================================
Хотя в целом Envoy работает достаточно хорошо, есть несколько известных областей, которые требуют внимания, когда он используется с очень высоким параллелизмом и пропускной способностью:
* Как уже описано в этой статье, в настоящее время все рабочие потоки получают блокировку при записи в буфер памяти журнала доступа. При высоком параллелизме и высокой пропускной способности потребуется выполнить пакетирование журналов доступа для каждого рабочего потока за счет неупорядоченной доставки при записи в окончательный файл. Как альтернативу, можно создавать отдельный журнал доступа для каждого рабочего потока.
* Хотя статистика очень сильно оптимизирована, при очень высоком параллелизме и пропускной способности, вероятно, будет атомарная конкуренция на индивидуальной статистике. Решение этой проблемы — счетчики на один рабочий поток с периодическим сбросом центральных счетчиков. Это будет обсуждаться в последующем посте.
* Существующая архитектура не будет работать хорошо если Envoy развернут в сценарии, в котором очень мало соединений, требующих значительных ресурсов для обработки. Нет гарантии, что связи будут равномерно распределены между рабочими потоками. Это может быть решено путем реализации балансировки рабочих соединений, при которой будет реализована возможность обмена соединениями между рабочими потоками.
Заключение (Conclusion)
=======================
Модель потоков Envoy разработана для обеспечения простоты программирования и массового параллелизма за счет потенциально расточительного использования памяти и соединений, если они не настроены правильно. Эта модель позволяет ему очень хорошо работать при очень высоком количестве потоков и пропускной способности.
Как я кратко упомянул в Твиттере, дизайн также может работать поверх полнофункционального сетевого стека в режиме пользователя, такого как DPDK (Data Plane Development Kit), что может привести к тому, что обычные серверы будут обрабатывать миллионы запросов в секунду при полной обработке L7. Будет очень интересно посмотреть, что будет построено в ближайшие несколько лет.
Один последний быстрый комментарий: меня много раз спрашивали, почему мы выбрали C ++ для Envoy. Причина по-прежнему заключается в том, что это все еще единственный широко распространенный язык промышленного уровня, на котором можно построить архитектуру, описанную в этом посте. C ++ определенно не подходит для всех или даже для многих проектов, но для определенных случаев использования это все еще единственный инструмент для выполнения работы (to get the job done).
Ссылки на код (Links to code)
=============================
**Ссылки на файлы с интерфейсами и реализацией заголовков, обсуждаемые в этом посте:**
* [github.com/lyft/envoy/blob/master/include/envoy/thread\_local/thread\_local.h](https://github.com/lyft/envoy/blob/master/include/envoy/thread_local/thread_local.h)
* [github.com/lyft/envoy/blob/master/source/common/thread\_local/thread\_local\_impl.h](https://github.com/lyft/envoy/blob/master/source/common/thread_local/thread_local_impl.h)
* [github.com/lyft/envoy/blob/master/include/envoy/upstream/cluster\_manager.h](https://github.com/lyft/envoy/blob/master/include/envoy/upstream/cluster_manager.h)
* [github.com/lyft/envoy/blob/master/source/common/upstream/cluster\_manager\_impl.h](https://github.com/lyft/envoy/blob/master/source/common/upstream/cluster_manager_impl.h) | https://habr.com/ru/post/449826/ | null | ru | null |
# Аудио микшер из двух и более звуковых карт на realtime Linux и Reaper
Когда играешь в группе, надо где-то репетировать. Попробуем дома собрать свой микшер с эффектами из того, что есть под рукой. А под рукой у меня есть 2-х ядерный компьютер с встроенной и 2-мя дополнительными аудиокартами, ESI Juli@ и C-Media CM8738. Итого 6 каналов на запись.
Если достаточно 2-х каналов, то можно дальше не читать, потому как 2 канала можно смикшировать через Reaper под Windows с asio4all (или родными драйверами), будет играть без проблем. Вся сложность начинается, когда хочется из 3-х карточек сделать одну виртуальную и многоканальную. Через asio4all запись одновременно 6-ти каналов на приемлемом уровне качества (даже для репетиций) не получилась (из-за разного clock source на карточках, а также из-за редких подтормаживаний), поэтому и пришлось идти таким нелёгким путём.
Запускать мы всё будем под Linux-ом с realtime-ядром. Realtime-патч желателен, но не необходим, без него тоже будет работать, разве что с большей задержкой и не так стабильно. Дистрибутив будет Debian, а не RemixOS, потому что, во-первых, хочется понимать что происходит, можно ли что-нибудь покрутить и ничего не сломается, во-вторых нужно будет немного патчить wineasio, и в-третьих, в remixos ужасный рабочий стол. Как ставить Debian я рассказывать не буду, на эту тему уже много написано. Итак, мы имеем свежеустановленный Debian 6.0.3 с рабочим столом. Выглядеть это будет почти что так, разве что иконок на рабочем столе не будет:
Первым делом обновляем (если Debian устанавливался не с netinstall). В рутовой консоли (Приложения->Стандартные->Root Terminal)
```
#aptitude update && aptitude safe-upgrade
```
Теперь ставим уже скомпиленное realtime ядро pengutronix, опять же в рутовой консоли:
```
#wget -O /etc/apt/sources.list.d/pengutronix.list http://debian.pengutronix.de/debian/pengutronix.list
#aptitude update
#apt-get -q --allow-unauthenticated install pengutronix-archive-keyring
#aptitude update
#aptitude install linux-image-2.6-rt-osadl-686
```
Перезагружаемся на него, смотрим что скажет uname:
```
root@debian:/home/vasiliy# uname -a
Linux debian 2.6.33.7.2-rt30-1-686 #1 SMP PREEMPT RT Mon Jan 17 14:22:44 UTC 2011 i686 GNU/Linux
root@debian:/home/vasiliy#
```
Далее необязательно удаляем update-notifier (или как-нибудь выключаем):
```
#aptitude purge update-notifier update-notifier-common
```
Теперь ставим необходимые пакеты. Во-первых, это демон JACK. Именно к нему будут соединяться аудио приложения. А он, в свою очередь, через ALSA соединяется к звуковой карточке.
```
#aptitude install jackd2 qjackctl jackeq
```
Audacity, для проверок
```
#aptitude install audacity
```
Пакеты чтобы собрать wineasio
```
#aptitude install build-essential libjack-jackd2-dev libwine-dev
```
И Wine, чтобы запускать Reaper. Wine можно поставить из репозиториев, а можно и самому собрать с rt-патчем. Патч нужен для того, чтобы wine мог давать realtime приоритеты нужным потокам. Т.е. с обычным wine все потоки reaper-a будут в sched\_other, не зависимо от того, как хочет запускаемое приложение (или все в sched\_fifo, если весь wine запустить через schedtool), а с патчем рипер сам скажет какие потоки критичные (это которые звук обрабатывают), а какие потоки нет (это графический интерфейс и всё остальное). В кратце, у потока с точки зрения планировщика может быть определен класс и приоритет. Класс — это sched\_fifo, sched\_rr, sched\_other (он же sched\_normal), sched\_batch и еще какие-то. Интересных с точки зрения звука тут два, это обычный (sched\_other) и реального времени (sched\_fifo). Поток, который выполняется с классом sched\_fifo, не может быть прерван потоком с классом sched\_other. Т.е. все sched\_other не смогут выполнится, пока кому-то из sched\_fifo есть что делать. Хорошо что большую часть времени sched\_fifo-потоки чего-нибудь ждут, сигнала от оборудования, к примеру. В нашем случае звуковые потоки (sched\_fifo) будут ждать пока входящий аудио буфер заполнится, как поступит сигнал что буфер готов его быстро-быстро обработают, положат результат в исходящий буфер и снова будут ждать. А в эти перерывы будет рисоваться графический интерфейс итд.
Итак, вариант 1-й, ставим wine обычный (не желательно):
```
#aptitude install wine schedtool
```
И вариант 2-й, собираем wine 1.2.3 с патчем (скажу сразу что это не есть правильный debian-way, по-правильному нужно собирать пакет и его устанавливать, но это просто чуть сложней):
```
#aptitude build-dep wine
#exit
$wget http://ibiblio.org/pub/linux/system/emulators/wine/wine-1.2.3.tar.bz2 #Ссылка с официального сайта winehq.com
$tar xjvf wine-1.2.3.tar.bz2 #Ясно что, распаковываем
$cd wine-1.2.3
$wget http://dl.dropbox.com/u/879835/wine-rt-101107.patch #Собственно, сам патч. Ссылку взял с http://wiki.cockos.com/wiki/index.php/Installing_and_configuring_Wine
$patch -p1 -i wine-rt-101107.patch #Патчим
$./configure --prefix=/usr && make depend && make # make depend важен!
$su
#make install
```
Так как мы будем запускать Reaper, jackd и прочее не от рута, а от своего пользователя, то нужно поправить лимиты, иначе операционная система не даст запустить столько софта, съесть много памяти и получить realtime приоритеты. Правим /etc/security/limits.conf
```
#gedit /etc/security/limits.conf
```
и пишем там (естественно, вместо vasiliy надо поставить свой логин в системе)
```
vasiliy - memlock unlimited
vasiliy - rtprio 99
vasiliy - nice -20
```
Чтобы лимиты применились, нужно перелогинится или перезагрузится. Проверяем что с лимитами всё ок:
```
vasiliy@debian:~$ ulimit -a
core file size (blocks, -c) 0
data seg size (kbytes, -d) unlimited
scheduling priority (-e) 40
file size (blocks, -f) unlimited
pending signals (-i) 16382
max locked memory (kbytes, -l) unlimited
max memory size (kbytes, -m) unlimited
open files (-n) 1024
pipe size (512 bytes, -p) 8
POSIX message queues (bytes, -q) 819200
real-time priority (-r) 99
stack size (kbytes, -s) 8192
cpu time (seconds, -t) unlimited
max user processes (-u) unlimited
virtual memory (kbytes, -v) unlimited
file locks (-x) unlimited
vasiliy@debian:~$
```
Смотрим что max locked memory unlimited и идём дальше. Сейчас будем настраивать и проверять ALSA и JACK. Логично начать с ALSA, запускаем Audacity, идём в настройки:
Выбираем ALSA, пускаем Audacity на запись, смотрим что работает, слушаем что получилось (здесь я просто дотрагивался пальцем до джека):
Если что-то не работает, к примеру играет, но не пишет (можно в Audacity импортировать любую mp3-шку для проверки), или пишет с большими шумами, то нужно смотреть настройки ALSA, Система->Параметры->Звук. На моей Juli@ всё заработало сразу, а вот с встроенной и c-media карточками прошлось повозится:
C-Media Electronics Inc CM8738 (rev 10)
Встроенная Intel Corporation 82801JI (ICH10 Family) HD Audio Controller
Интересно, что даже встроенная карточка на линейных вход даёт достаточно неплохой сигнал. Единственное что он должен быть достаточно мощным, иначе шумит. Уровень громкости на «Захват», вкладка «Запись» HDA Intel специально стоит на 25%, так у меня шумело меньше всего. Электрогитару, к примеру, так писать не очень, а вот если эту же гитару пропустить через какой-нибудь предусилитель (в моём случае это ART Tube MP), то получается очень даже ничего, даже можно программый дисторшн включать.
Теперь настроим JACK. Запускаем qjackctl через Приложения->Аудио и видео->JACK Control (или в терминале qjackctl), жмем «Параметры»:
Выбираем основной интерфейс, у меня это juli@, она на hw:2 (список карточек и какие они получили номера можно посмотреть в /proc/asound/cards  Номер звуковой карточки не всегда сохраняется после перезагрузки, даже если все карточки pci). Включаем режим реального времени, выставляем размер буфера, дискретизацию, запускаем jackd,  и через Audacity проверяем что работает (в настройках Audacity не забываем переключится на JACK). Так же желательно проверить запись (и вывод звука) на других карточках через JACK.
А сейчас начинается интересная часть. Будем подключать остальные аудиоинтерфейсы к основному. Всё так же запускаем qjackctl, стартуем и пишем в отдельном терминале:
```
$alsa_in -d hw:0 -j hda-intel -p 512 -n 2
```
hw:0 — это встроенная карточка, hda-intel — это просто тэг, можно и без него, 512 — размер буфера, 2 — их количество. Размер буфера и количество подбираются минимально нормально работающие (под нормально работающими понимается что alsa\_in не выводит постоянно надпись «delay=<что-нибудь>»), в моём случае это получилось 512 (а потом и 128) сэмплов и два буфера, неплохо. Для остальных (остальной) звуковой тоже самое.
Проверить что всё работает можно через jackeq (Приложения->Аудио и видео->JackEq или, как я, в терминале jackeq). Выбираем порты входа, порты выхода, поднимаем громкость каналов, громкость master-а, смотрим и слушаем. На этом шаге можно поэкспериментировать с размерами буферов JACK и alsa\_in (jackeq придётся перезапускать).
Собственно, какой-то простой микшер уже есть. Но ведь хочется большего, много эффектов, vst-плагины и так далее. Можно поставить Ardour, можно ardour пересобрать с поддержкой windows VST плагинов, можно поставить Mixbus. Всё это DAW (Digital Audio Workstation), через них вполне можно микшировать для репетиций. Я предпочёл Reaper потому что, во-первых, он мне привычней, во-вторых в нем самом есть встроенные неплохие эффекты, в-третьих у него удобный микшер, можно ручки настройки эффектов вынести на главный микшер, в-четвёртых в микшере можно настроить хоткеи почти на всё, в-пятых он работает с VST, в-шестых Reaper это живой софт, постоянно развивающийся.
Скачиваем и устанавливаем с [reaper.fm](http://reaper.fm), можно триальную версию. Сам Reaper запускать еще рано, у нас нет связки jack-asio. Нужно скачать, пропатчить, скомпилировать и установить wineasio (http://sourceforge.net/projects/wineasio/). Можно скачать стабильную версию (0.9.0), а можно и development, с git-а. Версия, которая лежит в git, она немногим отличается от стабильной, но она у меня запустилась с JACK буфером в 32 сэмпла, так что лучше скачать её:
```
git clone git://wineasio.git.sourceforge.net/gitroot/wineasio/wineasio
```
Для того, чтобы собрать wineasio, нужен файл asio.h, который содержится в Steinberg ASIO SDK. К сожалению, Steinberg запрещает распространять этот файл, поэтому его самостоятельно скачиваем с сайта Steinberg (http://www.steinberg.net/en/company/developer.html), и кладем в папку с распакованным wineasio. Теперь нужно пропатчить asio.c:
```
/* Находим такую строчку */
This->jack_input_ports = jack_get_ports(This->jack_client, NULL, NULL, JackPortIsPhysical | JackPortIsOutput);
/* и заменяем её на такую: */
This->jack_input_ports = jack_get_ports(This->jack_client, NULL, NULL, JackPortIsOutput);
/* И с такой тоже самое, найти */
This->jack_output_ports = jack_get_ports(This->jack_client, NULL, NULL, JackPortIsPhysical | JackPortIsInput);
/* Заменить на */
This->jack_output_ports = jack_get_ports(This->jack_client, NULL, NULL, JackPortIsInput);
```
В этом патче мы убирам флаг JackPortIsPhysical, чтобы wineasio сразу соединялся со всеми портами JACK, в том числе и виртуальными, которые мы создали через alsa\_in.
Компилируем, устанавливаем:
```
$make
$su
#make install
#exit
$wine regsvr32 wineasio.dll
```
Тестовый запуск Reaper-а, проверяем что wineasio появился:
wineasio настраивается через реестр:
```
$wine regedit
```
Из интересных настроек тут только Number of inputs/ouputs, можно поставить какое-нибудь более похожее на реальность количество. Fixed buffersize желательно оставить в «1», чтобы размер буфера определял JACK.
Снова запускаем Reaper, в зависимости от того пропатченный wine или нет команда запуска будет разная:
```
$wine 'c:\program files\reaper\reaper.exe' # Это по обычному, с классом sched_other, приоритет 0 (обычный)
$nice -n -20 wine 'c:\program files\reaper\reaper.exe' # То же самый класс, только самый большой приоритет
$schedtool -F -p 10 -e wine 'C:\program files\reaper\reaper.exe' # Весь Reaper запускается в realtime. Может иногда предпочесть перерисовать интерфейс вместо того, чтобы обработать аудио.
$env WINE_RT=15 WINE_SRV_RT=10 wine 'C:\program files\reaper\reaper.exe' # Самый предпочтительный вариант, Reaper сам укажет что важно, а что не очень.
```
Настраиваем его для лучшей работы под wine:
Убираем галочку с «Preferences->Buffering->Use native events for syncronizing», и в «Preferences->Appearances->UI updates» выбираем «Lazy always».
Ну а теперь осталось только добавить в Reaper-е нужное количество дорожек, включить их на запись и мониторинг, добавить эффектов и играть:
Удачных Вам репетиций!
PS:
* Под этой версией wine 1.0.1 у меня запустился только 3-тий Guitar Rig, 4-й и 5-й не устанавливаются. Хотя порепетировать и 3-ей хватит. С GuitarRig-ом надо как-то поосторожней, если быстро пресеты переключать, то он вылетает вместе с рипером. Хотелось бы найти какую-нибудь более стабильно работающую под wine-ом альтернативу.
Под версией wine 1.2.3 Guitar Rig 5 поставится, работает нормально, не вылетает.
* С wineasio 0.9.0 задержки на основной карточке с буфером 256 получились около 20-ми мс, на дополнительных около 30-ти (поправил, спасибо [egorinsk](http://habrahabr.ru/users/egorinsk/)).
А вот на git версии wineasio и меньшие размеры работают, сейчас вот на основной карточке размер буфера 32, что даёт задержку в 1,4 мс, и на alsa\_in буфер 128, т.е. на дополнительных карточках получилось 6 мс.
* В четыре карточки тоже работает, подключал EMU-0202 USB.
* Не нашел VST подавителя обратной связи, давить свистящие частоты приходится вручную через эквалайзер.
* Не знаю как по-человечески поставить nvidia драйвер на realtime ядро.
* В Reaper-е есть особенность, что приоритеты на потоки он вешает не во время запуска, а как только начинается воспроизведение/запись. Т.е. если делать проект с микшером, после его открытия придётся жать play/stop. Посмотреть, что из потоков есть, какой у них класс и приоритет можно через
```
ps -emo pid,tid,class,rtprio,ni,pri,psr,pcpu,stat,wchan:14,comm
```
Тут видно, что у reaper.exe есть 3 FF (sched\_fifo) потока, один с приоритетом 5 (это тот, который ему создал jack, этот приоритет можно настроить через qjackctl), и два (у меня два ядра) с приоритетом 20, это потоки обработки эффектов, их Reaper запросил с приоритетом THREAD\_PRIORITY\_HIGHEST.
В общем не ленитесь поставить realtime ядро, wine с realtime патчем и wineasio версию с git. Результаты должны получится очень неплохие.
Ссылки:
[debian.org](http://debian.org)
[pengutronix.de/software/linux-rt/debian\_en.html](http://pengutronix.de/software/linux-rt/debian_en.html)
[reaper.fm](http://reaper.fm)
[sourceforge.net/projects/wineasio](http://sourceforge.net/projects/wineasio/)
[www.steinberg.net/en/company/developer.html](http://www.steinberg.net/en/company/developer.html)
[wiki.cockos.com/wiki/index.php/How\_to\_run\_Reaper\_in\_Wine\_on\_Linux](http://wiki.cockos.com/wiki/index.php/How_to_run_Reaper_in_Wine_on_Linux) | https://habr.com/ru/post/135835/ | null | ru | null |
# Retweet для Buzz: Reshare
То, о чем там много и настойчиво говорили ~~коммунисты~~ все пользователи Buzz, свершилось (Ура!). Корпорация добра оперативно прислушалась к мнению своих пользователей, что в случае с Buzz происходит уже второй раз (а в случае AdSense иногда не происходит вообще).
Reshare для Buzz:
При Reshare помимо цитируемого поста, можно что-то добавить от себя:
Как и в Google Reader, появляется счетчик людей передавших новость дальше.
Это последная «горящая» функциональность, которой не хватало. Довольно быстро Buzz для моей пользы догнал и перегнал твиттер. Обмен информацией (длинее 140 символов) с людьми, не просто чужими и незнакомыми, а друзьями, коллегами, единомышленниками, от которых получишь осмысленные комментарии — это очень здорово. Как и то, что для пользования им не надо ставить отдельный клиент, а закладка с Gmail и так открыта большую часть времени.
`Выдернув из Контекста` | https://habr.com/ru/post/94780/ | null | ru | null |
# Маленькая история о том, как я переустанавливал ОС из-за libexpat, или как не стоит обрабатывать ошибки
Альтернативный заголовок: "**В любой непонятной ситуации возвращай Out of memory"**.
Давеча решил я запустить свой самописный сервер веселья ради, как я делал это тысячу раз до этого, и каково же было моё удивление, когда я внезапно увидел следующую строчку в консоли: Error when parsing "example\_proj.xml": 1:0 out of memory.
Для парсинга конфигурационных файлов в проекте используется сторонняя библиотека (назовём её LibCustomConfig), которая в свою очередь использует широко распространённую libexpat.
Итак. Out of memory? На XML в 50 строчек? Сказать, что я был ошарашен - это не сказать ничего. "Но ведь раньше всё работало". Ни код сервера, ни так называемый LibCustomConfig никак не менялись.
Будучи абсолютно сбитым с толку, я решил свалить всю вину на последнее обновление последней Ubuntu, после которого проблема и появилась. А вместе с ней появились и другие проблемы: падения и подвисания разных приложений, как будто сам Chaos Monkey дотянулся до меня своими лапами. Может где-то в недрах поломался ABI?
Пересаживаюсь на свежую LTS версию Ubuntu, пересобираю сервер и... опять out of memory.
Пришло время расчехлять GDB. Кто-то скажет, что с этого и надо было начать, но дебажить сторонние либы очень не хотелось.
LibCustomConfig использует libexpat примерно так:
```
Parser::Parser(/*...,*/ char separator = ':')
{
if (separator)
/* Constructs a new parser and namespace processor. Element type
names and attribute names that belong to a namespace will be
expanded. */
parser_ = XML_ParserCreateNS(/*encoding = */ encoding_,
/*namespaceSeparator = */ separator);
else
{ /*...*/ }
}
```
Запоминаем, что сепаратор по умолчанию - *':'* (корректно это или нет, я не знаю). Далее файл вычитывается в буфер и парсится стандартным методом из libexpat - XML\_ParseBuffer:
```
XMLPARSEAPI(enum XML_Status)
XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
```
При ошибке парсинга возвращается ненулевой статус, а код ошибки можно получить с помощью XML\_GetErrorCode.
После получаса дебаггинга наконец нахожу, где же внутри libexpat фейлится парсинг ([смотреть на GitHub](https://github.com/libexpat/libexpat/blob/65a21f2b2a306d29b44e70264aca948aa0454219/expat/lib/xmlparse.c#L3771)):
Этот код был добавлен 12 февраля ([коммит](https://github.com/libexpat/libexpat/commit/a2fe525e660badd64b6c557c2b1ec26ddc07f6e4)).
В качестве подопытного XML-файла используется просто .
В данном случае *parser->m\_ns == 1* (root parser), *uri == "http://www.w3.org/XML/1998/namespace"* (автоматически устанавливается libexpat'ом), *parser->m\_namespaceSeparator == ':'* (установлено в LibCustomConfig). Получается любой простой файл не будет парситься, если сепаратором указать двоеточие, т.к. этот символ присутствует в URI.
Но почему же я получаю Out of memory error, если возвращается XML\_ERROR\_SYNTAX?? Смотрим call stack:
* сейчас мы находимся внутри функции addBinding, которая нам возвращает XML\_ERROR\_SYNTAX ([смотреть на GitHub](https://github.com/libexpat/libexpat/blob/65a21f2b2a306d29b44e70264aca948aa0454219/expat/lib/xmlparse.c#L3710))
* вызывается она внутри функции setContext, которая внезапно возвращает bool. В данном случае XML\_False ([смотреть на GitHub](https://github.com/libexpat/libexpat/blob/65a21f2b2a306d29b44e70264aca948aa0454219/expat/lib/xmlparse.c#L6525))
* далее startParsing, которая возвращает то же булевское значение ([смотреть на GitHub](https://github.com/libexpat/libexpat/blob/65a21f2b2a306d29b44e70264aca948aa0454219/expat/lib/xmlparse.c#L957))
* а затем знакомая XML\_ParseBuffer, которая по возвращенному XML\_False должна понять, что же произошло ([смотреть на GitHub](https://github.com/libexpat/libexpat/blob/65a21f2b2a306d29b44e70264aca948aa0454219/expat/lib/xmlparse.c#L957))
И как же XML\_ParseBuffer понимает, что произошло? А очень просто:
```
if (parser->m_parentParser == NULL && ! startParsing(parser)) {
parser->m_errorCode = XML_ERROR_NO_MEMORY;
return XML_STATUS_ERROR;
}
```
В любой непонятной ситуации возвращай XML\_ERROR\_NO\_MEMORY. Прикольно. | https://habr.com/ru/post/653151/ | null | ru | null |
# OTA обновление устройств с Linux
TL;DR:
------
OTA A/B обновление образа rootfs для IoT устройств с Linux при помощи проекта [Mender](https://mender.io/).
Вступление
----------
Недавно у меня возникла задача обновлять удалённо некоторое двузначное число IoT-устройств с Linux через интернет. Задачу нужно было решить быстро. Времени и желания изобретать что-то своё не было совсем. Устанавливать обновления вручную по ssh — нереально. Автоматизировать установку по ssh тоже, устройства могут неожиданно выключаться или терять сеть.
Поиск решений по обновлению IoT устройств показал, что, судя по всему, мне больше всего подходит Mender:
* end-to-end решение — клиент + сервер + инструменты
* A/B обновление rootfs — на устройстве есть два одинаковых раздела rootfs A и B. Система загружается с активного раздела A, устанавливает обновление на раздел B, загружается с раздела B и в случае успеха делает его активным. В случае неудачного обновления активным остаётся раздел A.
* работает с debian и yocto
* не использует контейнеры
* есть open-source версия под лицензией Apache v2
На сайте проекта можно почитать как всё это [работает](https://mender.io/how-it-works).
Кстати, Mender уже упоминался на хабре в [статье](https://habr.com/ru/company/deutschetelekomitsolutions/blog/520406/) [@MooooM](/users/moooom), но внедрить его тогда не получилось.
Workflow
--------
Я продемонстрирую процесс обновления системы на примере Raspberry Pi 3B c Raspberry Pi OS. Карта памяти от 8 ГБ и выше.
В качестве сервера Mender будем использовать бесплатный демо-сервер [hosted.mender.io](https://hosted.mender.io) (не более 10 устройств и 12 месяцев работы).
Подготовка образов будет производится на компьютере с Ubuntu 20.04.
В своей документации Mender рекомендуют примерно такой [подход](https://docs.mender.io/3.0/system-updates-debian-family/convert-a-mender-debian-image#recommended-workflow) для устройств с debian:
1. Установка чистой ОС
2. Подготовка эталонного образа
3. Копирование эталонного образа на ПК
4. Преобразование эталонного образа при помощи mender-convert
5. Подготовка устройства (provisioning)
6. Авторизация устройства
7. Подготовка пакета обновления (artifact)
8. Развёртывание обновления (deploy)
### 0. Сервер
Регистрируемся на [hosted.mender.io](https://hosted.mender.io).
### 1. Установка чистой ОС
Устанавливаем последнюю [Raspberry Pi OS Lite](https://www.raspberrypi.org/software/operating-systems/) по [инструкции](https://www.raspberrypi.org/documentation/computers/getting-started.html#installing-images-on-linux).
Включаем последовательную консоль `/boot/config.txt`: `enable_uart=1`
### 2. Подготовка эталонного (golden) образа
Вставляем SD-карту в устройство(Raspberry Pi 3B) и подключаемся по uart при помощи minicom.
Меняем стандартный пароль при помощи `raspi-config`.
Настройте и проверьте подключение к интернету. Я подключил свою Raspberry по ethernet (не совсем over-the-air, знаю).
Создадим директорию `/data`, в которой будут храниться данные, которые должны сохраняться при обновлении образа системы.
Положим туда текстовый файл `important_file.txt` содержащий одну строку `hello_habr`.
### 3. Копирование эталонного образа
Выключаем устройство и вставляем SD-карту в компьютер:
Выводим список разделов:
```
lsblk -p
/dev/sda 8:0 1 7,4G 0 disk
├─/dev/sda1 8:1 1 256M 0 part
└─/dev/sda2 8:2 1 7,1G 0 part
```
Размонтируем разделы:
```
umount /dev/sdX1
umount /dev/sdX2
```
Считываем образ с карты:
```
sudo dd if=/dev/sdX of=golden-image-1.img bs=4M status=progress
```
### 4. Преобразование эталонного образа при помощи mender-convert
Для подготовки образа нам понадобится [mender-convert](https://github.com/mendersoftware/mender-convert) и [Docker](https://docs.mender.io/system-updates-debian-family/convert-a-mender-debian-image#docker).
```
git clone -b 2.5.0 https://github.com/mendersoftware/mender-convert.git
cd mender-convert
./docker-build
```
Проверяем ёмкость SD-карты, на которую будем устанавливать систему:
```
sudo fdisk -l
Disk /dev/sda: 7,38 GiB, 7910457344 bytes, 15450112 sectors
```
Переводим байты в мегабайты: 7910457344 / 1024 / 1024 = 7544 MB
Создаём файл с конфигурацией mender-convert `./configs/raspberrypi3_custom_config` с вот таким содержимым:
```
RASPBERRYPI_CONFIG="raspberrypi3"
RASPBERRYPI_KERNEL_IMAGE="kernel7.img"
MENDER_KERNEL_IMAGETYPE="zImage"
MENDER_DEVICE_TYPE="raspberrypi3"
MENDER_STORAGE_TOTAL_SIZE_MB="7500"
MENDER_DATA_PART_SIZE_MB="1000"
IMAGE_ROOTFS_SIZE="-1"
MENDER_ADDON_CONNECT_INSTALL="y"
source configs/raspberrypi_config
```
`MENDER_STORAGE_TOTAL_SIZE_MB` — общий размер SD полученный ранее
`MENDER_DATA_PART_SIZE_MB` — размер раздела /data
`MENDER_ADDON_CONNECT_INSTALL` — флаг установки [mender-connect](https://docs.mender.io/add-ons/overview) (позволит запускать командную строку на удалённом устройстве и передавать файлы)
Создаём директорию `./rootfs_overlay/etc/mender`. Это оверлей файловой системы который будет записан на наш эталонный образ при запуске mender-convert.
Создаём файл конфигурации mender-client `./rootfs_overlay/etc/mender/mender.conf`:
```
{
"ServerURL": "https://hosted.mender.io/",
"TenantToken": "XXXX",
"UpdatePollIntervalSeconds": 300,
"InventoryPollIntervalSeconds": 300
}
```
`TenantToken` - токен который нужно [посмотреть](https://hosted.mender.io/ui/#/settings/organization-and-billing) в hosted.mender.io (Settings->Organization and billing->Organization token).
Создаём файл конфигурации mender-connect `./rootfs_overlay/etc/mender/mender-connect.conf`:
```
{
"ShellCommand": "/bin/bash",
"User": "pi"
}
```
Меняем владельца и группу оверлея:
```
sudo chown -R 0 ./rootfs_overlay/
sudo chgrp -R 0 ./rootfs_overlay/
```
Создаём директорию `./input` и кладём в неё образ `golden-image-1.img` полученный ранее.
Запускаем mender-convert.
```
MENDER_ARTIFACT_NAME=release-1 ./docker-mender-convert --disk-image input/golden-image-1.img --config configs/raspberrypi3_custom_config --overlay rootfs_overlay/
```
`MENDER_ARTIFACT_NAME` — название релиза, которое будет отображаться в hosted.mender.io.
Дальше происходит магия:
* в образ устанавливается U-Boot
* в Raspberry OS доустанавливается mender-client и mender-connect
* создаются A и B разделы rootfs исходя из общего размера SD-карты, а также размера раздела data
* данные из директории `/data` автоматически переносятся на новый раздел, который не будет перезаписываться при обновлении системы
Подробнее можно посмотреть в `./logs/convert.log.XXXX`.
На выходе получаем:
`./deploy/golden-image-1-raspberrypi3-mender.img` - преобразованный образ системы для записи на SD-карту
`./deploy/golden-image-1-raspberrypi3-mender.mender` - архив с обновлением, который загружается на сервер Mender(519МБ) и потом скачивается устройствами.
### 5. Подготовка устройства (provisioning)
Записываем образ `golden-image-1-raspberrypi3-mender.img` на SD-карту:
```
sudo dd if=./deploy/golden-image-1-raspberrypi3-mender.img of=/dev/sdX bs=4M oflag=sync status=progress
```
Теперь разделы выглядят так:
```
/dev/sda 8:0 1 7,4G 0 disk
├─/dev/sda1 8:1 1 256M 0 part
├─/dev/sda2 8:2 1 3G 0 part
├─/dev/sda3 8:3 1 3G 0 part
└─/dev/sda4 8:4 1 1000M 0 part
```
Вывод uart при загрузке (у нас теперь есть U-Boot):
```
U-Boot 2020.01-g83cf4883ec (Jul 09 2021 - 14:23:27 +0000)
DRAM: 948 MiB
RPI 3 Model B (0xa02082)
MMC: mmc@7e202000: 0, sdhci@7e300000: 1
Loading Environment from MMC... OK
In: serial
Out: serial
Err: serial
Net: No ethernet found.
Hit any key to stop autoboot: 0
switch to partitions #0, OK
mmc0 is current device
Scanning mmc 0:1...
Found U-Boot script /boot.scr
568 bytes read in 10 ms (54.7 KiB/s)
## Executing script at 02400000
switch to partitions #0, OK
mmc0 is current device
6320888 bytes read in 538 ms (11.2 MiB/s)
Kernel image @ 0x080000 [ 0x000000 - 0x6072f8 ]
## Flattened Device Tree blob at 2eff8c00
Booting using the fdt blob at 0x2eff8c00
Using Device Tree in place at 2eff8c00, end 2f002f2b
Starting kernel ...
[ 0.000000] Booting Linux on physical CPU 0x0
```
### 6. Авторизация устройства
Через пару минут после включения устройства на главной странице hosted.mender.io должно появиться сообщение о том, что новое устройство ожидает аутентификации. После подтверждения статус устройства поменяется с pending на accepted.
Через раздел Troubleshoot можно запустить удалённый терминал на устройстве (работает через mender-connect). При этом, на устройстве не включен ssh-сервер. Есть возможность передавать файлы через вкладку File transfer.
Теперь мы можем обновлять устройство по воздуху и физический доступ к нему больше не понадобится.
### 7. Подготовка пакета обновления (artifact)
Возвращаемся к нашему эталонному образу (golden-image-1.img). Загружаем ОС и вносим необходимые изменения. Я, например, сделаю MQTT-клиента, который шлёт на брокер температуру процессора (под спойлером).
MQTT-клиентУстанавливаем пакеты:
```
sudo apt-get update
sudo apt install -y mosquitto mosquitto-clients
```
Создаём systemd таймер: `/etc/systemd/system/mqtt.timer`
```
[Unit]
Description=run mqtt.service every minute
[Timer]
AccuracySec=1
OnCalendar=*:*:0/30
Unit=mqtt.service
[Install]
WantedBy=multi-user.target
```
Создаём сервис, который будет вызываться таймером mqtt.timer: `/etc/systemd/system/mqtt.service`
```
[Unit]
Description=mqtt publisher service
[Service]
Type=simple
ExecStart=/home/pi/mosquitto_pub.sh
[Install]
WantedBy=multi-user.target
```
Скрипт, который будет вызываться сервисом mqtt.service: `/home/pi/mosquitto_pub.sh`
```
#!/bin/bash
tcpu=$(
```
Делаем скрипт исполняемым:
```
chmod +x /home/pi/mosquitto_pub.sh
```
Запускаем таймер:
```
sudo systemctl enable mqtt.timer
sudo systemctl start mqtt.timer
```
После внесения изменений снова считываем образ с карты:
```
sudo dd if=/dev/sda of=golden-image-2.img bs=4M status=progress
```
Преобразовываем образ при помощи mender-convert:
```
sudo MENDER_ARTIFACT_NAME=release-2 ./docker-mender-convert --disk-image input/golden-image-2.img --config configs/raspberrypi3_custom_config --overlay rootfs_overlay/
```
Загружаем в hosted.mender.io новый релиз golden-image-2-raspberrypi3-mender.mender. Заодно можно загрузить первый релиз, если захотим откатиться.
### 8. Deploy
Развёртывание (deploy) можно создать для отдельного устройства, группы устройств или сразу для всех. После создания развёртывания в течении пяти минут устройство проверит есть ли для него доступное обновление и начнёт загрузку.
После обновления проверим, начало ли устройство отправлять сообщения по MQTT (под спойлером):
MQTT ExplorerУстановите [MQTT Explorer](http://mqtt-explorer.com/).
Создайте подключение к mqtt://test.mosquitto.org, порт: 1883.
Подпишитесь на топик habr/#
Наблюдаем, как устройство остывает после недавнего апдейта:
Выводы
------
Mender позволяет довольно легко добавить функцию обновления образа системы по воздуху в существующее устройство.
Внедрение Mender никак не повлияло на процесс разарботки эталонного образа и последующих обновлений. Эталонный образ служит лишь источником для создания пакетов обновления.
Open-source версия Mender позволяет делать намного больше, чем показано в этой статье, например, [state-scripts](https://docs.mender.io/artifact-creation/state-scripts), [identy](https://docs.mender.io/client-installation/identity) и [inventory](https://docs.mender.io/client-installation/inventory) устройств и т.д. Open-source версию сервера Mender можно самостоятельно развернуть в облаке используя [Kubernetes](https://docs.mender.io/3.0/server-installation/production-installation-with-kubernetes).
Рекомендую внимательно изучить [список фич](https://mender.io/plans/features) доступных в open-source и коммерческих версиях. Open-source версия вполне работоспособна, но её может не хватить для того чтобы закрыть все потребности крупного проекта (нет автоматического перезапуска процесса обновления, [дельта-апдейтов](https://docs.mender.io/3.0/overview/delta-update), мониторинга сервисов и т.д.).
Было бы интересно сравнить Mender c [RAUC](https://github.com/rauc/rauc) или [swupdate](https://github.com/sbabic/swupdate) в качестве клиента и [hawkBit](https://github.com/eclipse/hawkbit) в качестве бэкенда.
На этом все, спасибо за внимание. | https://habr.com/ru/post/582554/ | null | ru | null |
# 5 самых нужных дополнений к Laravel 4
Когда заходит речь о разработке, мы все пытаемся найти более эффективные и быстрые способы программирования, порой не замечая, что кто-то уже сталкивался с похожей задачей, и изящно её реализовал. Что вы скажете, если мы сократим на 3/4 наш [говнокод](http://govnokod.ru/), всего лишь добавив несколько простых и эффективных зависимостей?
Для тех, кто не знает что такое [Laravel 4](http://laravel.com/) — это PHP фреймворк для быстрой разработки. Этот фреймворк с открытым исходным кодом на [github](https://github.com/laravel/laravel), сделан для настоящих ремесленников веб-программирования такими же ремесленниками. Как говорится, «для программистов от программистов». Но статья не о прелестях Laravel, и не о его преимуществах перед другими фреймворками, об этом я с удовольствием расскажу в других статьях. Здесь я расскажу о пяти наиболее значимых и важных дополнений к Laravel 4, которые сэкономят вам драгоценные минуты кодинга.
1. [«cartalyst/sentinel»: «1.0.\*»](https://cartalyst.com/manual/sentinel/1.0#laravel-4) — На пути к безопасности.
------------------------------------------------------------------------------------------------------------------
Это невероятно простая, удобная в использовании, и в то же время масштабная по своим возможностям система аутентификации. Laravel 4 имеет встроенную систему, но её возможности скудны. Sentinel «из коробки» умеет управлять группами пользователей, ролями, сбросом пароля и напоминания, регистрация и авторизация, нативный (родной) фасад к Laravel 4.
В отличие от Sentry (предшествующая разработка Cartalyst'а) позволяет в качестве атрибутов логина передавать не только сам логин, но и любые другие поля, работать с несколькими системами разрешений сразу, и т.д. Мало того, модуль полностью кастомизируется, и легко дополняется, что делает его еще более гибким. Буду откровенным, я не понимаю, почему этот пакет не входит в базовый набор Laravel 4!
2. [«way/generators»: "~2.0"](https://github.com/JeffreyWay/Laravel-4-Generators) — Экономьте время с умом, проектируя схемы баз данных.
----------------------------------------------------------------------------------------------------------------------------------------
Jeffery Ways, если быть откровенным, икона php-кодеров. Он создал колоссальное количетсво open-source проектов, и кучу бесплатных видео курсов по использованию Laravel 4 и 5. Я не знаю кем был Jeffery до того, как я начал использовать Laravel, но сейчас я отслеживаю все его работы, мысли и идеи. Ways generators представляет собой целую библиотеку artisan команд, таких как, например, generate:migration которая создаёт файл миграции с уже кастомизированной схемой, generate:resource который создаёт контроллер, модель, и даже представления, по стандартам REST! Теперь быстрое проектирование REST контроллеров стало реальностью.
3. [«codesleeve/asset-pipeline»: «dev-master»](https://github.com/CodeSleeve/asset-pipeline) — Сохраняет кучу нервных клеток при работе с sass
----------------------------------------------------------------------------------------------------------------------------------------------
Codesleeve's Asset Pipeline придаёт всю мощь RoR (Ruby on Rails) в мир PHP. SaSS и ScSS очень популярны среди разработчиков, и уже стали обязательным стандартом для фронтэнда. Однако, и scss и sass нуждается в компиляции. Asset Pipeline не только компилирует ваш код, но и минифицирует его. Этот модуль работает также с javascript, и позволит избавиться от назойливых импортов многочисленных js файлов вашего проекта.
4. [«way/database»: «dev-master»](https://github.com/JeffreyWay/Laravel-Model-Validation) — Козырь в рукаве
-----------------------------------------------------------------------------------------------------------
Как уже было сказано, Jeffery Way настоящий мужик! Он перетащил валидацию из контроллера в модель, и теперь можно просто применять метод save() в модели. А этот модуль будет проверять, есть ли какие либо ошибки errors() в то же время. А код в контроллере становится чистым.
```
public function store()
{
$dog = new Dog(Input::all());
if ($dog->save())
{
return Redirect::route('dogs.index');
}
return Redirect::back()->withInput()->withErrors($dog->getErrors());
}
```
Продолжение идеи MVC, ведь если приглядеться внимательно, Laravel нарушает некоторые конвенции парадигмы, а с этим модулем жизнь становится лучше, а фреймворк обретает еще большую мощь по сравнению со многими другими.
5. [«codesleeve/laravel-stapler»](https://github.com/CodeSleeve/laravel-stapler) — Незаменимый помощник при загрузках файлов
----------------------------------------------------------------------------------------------------------------------------
Я убеждён, что все сталкивались с ситуацией, когда клиенты просили при загрузке файлов делать превью этих файлов. Ну конечно сталкивались. И не всегда используются изящные решения. Но что, если мы выкинем из головы необходимость манипуляций с изображениями, отслеживание местоположения файлов, удаление файлов с диска, когда запись удаляется из базы данных? Этот модуль позволит сохранить фокус на разработке, так как все вышеперечисленное он умеет делать действительно великолепно! Всё что нужно — запустить команду artisan, добавить параметры изображений, потом просто -> save(), и всё. Остальное сделает этот модуль.
Я надеюсь, что эта статья приоткрыла глаза на метод ленивого программирования, так я называю метод «неповторения изобретения велосипедов», а использование тех технологий, которые позволят не отвлекаясь на рутинные и однообразные долгие действия быстро разрабатывать прототипы, или даже продакшн. Спасибо за внимание, оставайтесь с нами!
*Вольный перевод статьи [revoltvisual.com/journal/5-must-have-laravel-4-packages](http://revoltvisual.com/journal/5-must-have-laravel-4-packages).
В оригинале первым пунктом у автора был обзор Sentry (https://cartalyst.com/manual/sentry/2.1#laravel-4), но на данный момент времени более актуальной разработкой всё-таки является Sentinel.* | https://habr.com/ru/post/244597/ | null | ru | null |
# Оптимизация производительности фронтенда. Часть 1. Critical Render Path
Здравствуйте. Меня зовут Ник, я фронтенд разработчик (жидкие аплодисменты). Кроме того, что я пишу код, я преподаю в [Школе программистов hh.ru.](https://school.hh.ru/)
Записи наших лекций от 2018-2019 учебного года можно [посмотреть на youtube](https://www.youtube.com/watch?v=eHWMtfqxjes&list=PLGn25JCaSSFQQOab_xMXI3vJ0tDUkFaCI)
В этом году у меня была лекция про оптимизацию производительности фронтенда, и я решил превратить ее в текстовый формат. Материал получился большим, так как лекция была длительностью 3 часа. Поэтому получился текстовый альманах.
[Вот презентация](https://slides.com/nikmostovoy/deck/fullscreen) для тех, кому неохота читать лонгрид, но при этом хочется иметь базовое представление о контенте.
Лонгридом можно пользоваться как справочником, чтобы не читать за один присест. Вот список тем, которые мы затронем:
1. Зачем думать о производительности
2. FMP, TTI + [подробнее в докладе](https://www.youtube.com/watch?v=4joeMk5v8Rw)
3. Critical render path, DOM, CSSOM, RenderTree
4. Шаги по улучшению производительности первой загрузки + [подробнее в докладе](https://www.youtube.com/watch?v=bZfULA8PPgE)
Для удобства восприятия я решил разделить статью на две части. Вторая часть будет о таких операциях, как layout, repaint, composite и их оптимизации. Вторая часть здесь: <https://habr.com/ru/company/hh/blog/517594/>
Зачем вообще думать о производительности? Мотивационная часть
-------------------------------------------------------------
**0.1 секунда** — это тот gap, который позволяет пользователю осознать, что именно его клик мышки, удар по клавиатуре побудил эти изменения в приложении\интерфейсе.
Кажется, у всех было то неловкое чувство, когда ты сочиняешь письмо\код\любой другой текст, а интерфейс "за тобой не успевает". Ты уже пишешь второе слово, а на экране всё еще песочные часы (если мы про windows) и еле-еле набирается первое. Аналогично и с кликами на кнопки. Я хочу, чтобы интерфейс мне подсказывал, мол, "окей, я тебя услышал, ща все будет".
За примером далеко ходить не нужно. Я пользуюсь веб-версией одного российского почтовика (не будем называть имен) и когда выделяю письма для их удаления, то бывают большие задержки. И я не понимаю: то ли я “не попал по кнопке", то ли сайт тормознутый. И обычно верно второе.
Почему 0.1 секунда? Дело в том, что мы замечаем и успеваем обработать даже куда более ограниченные по времени изменения и наш мозг находится "в контексте".
В качестве яркого примера посмотрите клип [“30 seconds to mars — hurricane”](https://www.youtube.com/watch?v=MjyvlD0TwiA). Там есть вставки на кадр-два с текстом не 9:30. Глаз успевает не только осознать вставку, но и частично определить контент.
**1 секунда** — идеальное время для загрузки сайта. В этому случае серфинг для пользователя воспринимается как что-то очень органичное. Если ваш ресурс готов к работе за 1 секунду — вы большой молодец. Как правило, реальность другая.
Давайте посчитаем, что для этого нужно: сетевые издержки, обработка запроса бекендами, походы по микросервисам, в базу данных, шаблонизация, обработка данных на клиенте (к этому мы еще вернемся), загрузка статики, инициализация скриптов. В общем — больно.
Поэтому обычно 1 секунда — это некий идеал, к которому нужно и можно стремиться, но и голову терять не нужно.
**10 секунд** — если погуглить, на всякую аналитику вроде "среднее время пользователя на сайте" мы увидем число: 30 секунд. Сайт загружающийся 5 секунд убивает 1/6 времени пользователя. 10 секунд — треть.
Дальше идут два числа — **1 минута и 10 минут**. первое — идеальное время для того, чтобы пользователь выполнил небольшую задачу на сайте — прочитал описание товара, зарегистрировался на сайте и т.д. Почему минута? В наши дни мы не так много тратим время на концентрацию на одной вещи. Как правило наше внимание очень быстро перескакивает с одного на другое. Открыл статью, прочитал десятую часть, дальше коллега мем в телегу отправил, тут триггер зажегся, новости про короновирус, верните мне мой 2007, вот это все. В общем к статье получится вернуться только через час.
Второе же число — это пользователь не только выполнил одну небольшую задачу на сайте, но и попытался или решил свою задачу с помощью вашего сайта. Сравнил тарифы, оформил заказ и т.п.
Большие компании даже хорошую аналитику для таких целей имеют:
* Walmart: 1 секунда ускорения + 2% конверсии
* Amazon: 0,1 секунды увеличивает выручку на 1%
* Что-то аналогичное есть у Яндекса (киньте в комментариях ссылку, я потерял)
И последний мотивационный пост в статье — от [википедии](https://twitter.com/wikipedia/status/585186967685619712):
Однако достаточно вводной, пора двигаться дальше.
Два извечных вопроса
--------------------
Давайте запустим lighthouse на hh.ru. Выглядит всё “очень не очень” (запуск на mobile, на desktop все сильно лучше):
Появляется два традиционных вопроса:
1. Кто в этом виноват?
2. Что с этим делать?
Хотя первый вопрос я бы заменил на "Как это расшифровать".
Сразу спойлер: картинки "как круто стало в конце” — не будет. Как “сделать лучше” мы знаем. Но есть определенные ограничения.
Давайте разбираться
-------------------
В первом приближении у нас есть 3 потенциальных сценария:
1. Отрисовка страницы (с html от сервера)
2. Работа загруженной страницы (клики пользователя и т.д.)
3. SPA — переходы между страницами без перезагрузки
У пользователя существует два этапа при отрисовке страницы, когда он может частично взаимодействовать с сайтом. И полноценно: FMP (First Meaningful Paint) и TTI (Time to interactive), когда ресурсы загружены, а скрипты проинициализированы:
Если судить о значении для пользователя: FMP == текст, есть верстка и пользователь может начать потреблять контент (конечно, если вы не инстаграмм). TTI == сайт готов к работе. Скрипты загружены, проинициализированны, ресурсы загружены.
Подробнее о расчетах FMP\TTI и как мониторить эту информацию на своем сайте, снимая данные с реальных людей, [я рассказывал на РИТ++](https://www.youtube.com/watch?v=4joeMk5v8Rw&feature=youtu.be). В этом же докладе я говорил и про эксперименты, которые мы проводили по ускорению и замедлению скорости работы сайта.
Наиболее важный показатель для нас — FMP. Соискатели открывают поиск, затем накликивают "открыть в новой вкладке" большое количество вакансий, а затем читают и принимают решение об отклике. C некоторыми оговорками (нюансы рендера браузера) FMP можно воспринимать как одну из основных метрик, которая описывает Critical render path. Critical render path — это набор действий и ресурсов, которые браузер должен совершить, загрузить и обработать, чтобы пользователь получил свой первый результат, пригодный для работы. То есть это минимальный набор — html, css и блокирующие скрипты (если так еще кто-то делает), без которых сайт не отобразится пользователю.
### Critical render path или что браузер делает для того, чтобы пользователь увидел тот самый текст?
#### TL&DR
1. Сделать запрос (DNS resolve, TCP поход и т.п.);
2. Получить HTML-документ;
3. Провести парсинг HTML на предмет включенных ресурсов;
4. Построить DOM tree (document object model);
5. Отправить запросы критических ресурсов. CSS, блокирующий JS (параллельно с предыдущим пунктом);
6. Получить весь CSS-код (также запускаем запросы на JS-файлы);
7. Построить CSSOM tree;
8. Выполнить весь полученный JS-код. Здесь могут вызываться layout, если из js кода происходит форсирование reflow;
9. Перестроить DOM tree (при необходимости);
10. Построить Render tree;
11. Отрисовать страницу (layout → paint → Composite).
Теперь пройдемся по пунктам отдельно:
#### Подробно:
**Request**
Формируем запрос, резолвим DNS, IP, TCP поход, передача запроса и т.п. Байтики бегают по сокетам, сервер получил запрос.
**Response**
Бекенды зашумели вентиляторами, обработали запрос, записали обратно данные в сокет и нам пришел ответ. Например, вот такой:
Мы получили байты, сформировали из нее строку, основываясь на данных text/html, и после пометки нашего запрос как "navigate" (кому интересно это можно посмотреть в ServiceWorker) браузер должен сформировать из этого html DOM.
Сказано, сделано:
#### Обработка DOM
**DOM**
Мы получаем строку или поток данных. На этом этапе браузер парсит и превращает полученную строку в объект:
Это только каркас. Сейчас браузер ничего не знает про стили и про то, каким образом всё это рендерить.
**Загрузка блокирующих ресурсов**
Браузер будет последовательно обрабатывать полученный html и каждый ресурс. CSS, JS может быть загружен как синхронно, блокируя дальнейшую обработку DOM, так и асинхронно (для css это способ с preload + сменой rel после загрузки на stylesheet). Поэтому каждый раз, когда браузер будет встречать блокирующую загрузку стилей или JS, он будет формировать запрос за этим ресурсом.
*Для каждого такого ресурса повторяем путь с запросом, ответом, парсингом ответа*. Здесь появляются ограничения, например, количество одновременных запросов на домен. Предположим, что все блокирующие запросы были описаны внутри тега head, браузер сделал запросы, получил нужные для рендера стили. После формирования DOM переходим к следующему этапу:
**CSSOM**
Предположим, что помимо meta и title был тег style (либо link). На данном этапе браузер берет DOM, берет CSS, собирает соответствия, и на выходе мы получаем объектную модель для CSS. Выглядит это примерно так:
Левая часть (head) для CSSOM практически не интересна, она не отображается пользователю. А для остальных узлов мы определили стили, которые браузеру нужно применить.
CSSOM важен, так как его понимание позволяет браузеру сформировать RenderTree.
**RenderTree**
Последний шаг на этапе от формирования деревьев к рендеру.
На этом этапе мы формируем дерево, которое будет рендериться. В нашем примере левая часть дерева, которая включает head, рендериться не будет. Так что эту часть можно опустить:
То есть, именно это дерево мы и отрендерим. Почему его? Если мы зайдем в DevTools там отображается “DOM". Дело в том, что, хоть в DevTools и присутствуют все DOM элементы, все расчеты и вычисленные свойства уже основаны на RenderTree.
Проверить крайне легко:
Здесь мы выделили кнопку во вкладке Elements. Мы получили всю "вычисленную" информацию. Её размеры, положение, стили, наследование стилей и т.д.
Когда мы получили RenderTree, наша следующая задача — выполнить Layout ⇒ Paint ⇒ Composite нашего приложения. После этих трех этапов пользователь и увидит наш сайт.
Layout ⇒ Paint ⇒ Composite могут быть болью не только во время первого рендера, но и при работе пользователя с сайтом. Поэтому мы разберем их во второй части статьи.
Что можно сделать, чтобы улучшить метрики FMP и TTI?
----------------------------------------------------
#### TL&DR
1) Работа с ресурсами:
1.1) Разнести блокирующие ресурсы по страницам. Как js, так и css. Хранить реиспользуемый между страницами код либо в отдельных бандлах, либо в отдельных небольших модулях.
1.2) Грузить то, что пользователю нужно в начале работы со страницей (очень спорный момент!)
1.3) Вынести third-party скрипты
1.4) Грузить картинки лениво
2) HTTP2.0 / HTTP3.0:
2.1) мультиплексинг
2.2) сжатие заголовков
2.3) Server push
3) Brotli
4) Кэш, ETag + Service worker
#### Подробно:
### Работа с ресурсами
#### Разносим блокирующие ресурсы. JS
Основной болью являются 2 вещи: блокирующие ресурсы и размер этих ресурсов.
Самый главный совет для больших сайтов — это разнести блокирующие стили, ресурсы по страницам. Реиспользумый код выносить в отдельные бандлы или модули. Для этого можно воспользоваться условным [loadable-components](https://github.com/gregberge/loadable-components) или [react-imported-component](https://github.com/theKashey/react-imported-component) для реакта и похожими решениями для vue и т.д. Если наши компоненты импортируют стили, то мы сможем также и разбить стили на отдельные страницы.
На выходе мы получаем:
1. бандлы с реиспользуемыми JS модулями
2. страничные бандлы.
Стратегией по разбиению кода можно легко управлять. Можно как создавать бандлы, которые объединяют код для нескольких страниц, так и просто “страничные” и “общие”. Лучше всего разницу можно посмотреть на схемах.
Изначальная расстановка:
**Стратегия 1**: делаем зависимость модуль → страницы, которые используют модуль
Так, чтобы загрузить главную страницу (index.html), нам нужно будет загрузить 2 бандла: `Common.JS` + `applicant+index.JS`, а для страницы /applicant нужно загрузить все 4 бандла. На больших сайтах таких модулей может быть очень много. В этом случае нам помогает решить эту проблему использование HTTP2.0.
Итого:
+: Данные распределены между страницами, мы грузим всегда только необходимое
+: Модули легко кэшируются, после релиза не обязательно обновлять все бандлы у пользователя
-: Много сетевых издержек для получения отдельных ресурсов. Фиксим с помощью мультиплексирования HTTP2.0.
**Стратегия 2**: реиспользуемые модули хранятся отдельно:
В данном случае каждый файл, который используется больше, чем на одной странице, мы отправляем отдельно. По сравнению с первой стратегией, на средних и больших сайтах мы получаем трагический рост отдельных небольших файлов. Многие из которых будут меньше 1 Кб? что не кэшируется тем же Chrome.
+: Во время релизов большая часть модулей останется в кэше у пользователя
-: Еще больший рост сетевых издержек, если у пользователя нет HTTP2.0
-: Кэши могут не работать, так как файлы будут меньше 1 Кб. Здесь нас может спасти Service worker. О нем будет ниже.
Эта стратегия имеет право на жизнь, так как минусы решаемы.
**Стратегия 3**: Иметь большой бандл реиспользуемого кода:
+: малое количество бандлов. Для загрузки страницы нужен страничный JS + Common.JS
-: При первой загрузке мы получаем очень много unused JS
-: При релизе скорее всего пользователю придется скачивать общий бандл заново, преимущество кэшей теряется.
Я бы рекомендовал либо не использовать этот вариант вообще, либо использовать его для небольших сайтов.
**Анти-Стратегия 1**: Каждая страница хранит весь список зависимостей, выносим только common:
В данном случае мы получаем большой оверхед. При переходе с одного ресурса на другой пользователь закачивает себе модули, которые уже у него были несколько раз. Например, пользователь заходит на главную и скачивает 2 бандла: Common.JS и Index.JS затем авторизуется и попадает на страницу соискателя. Итого, код для Dropdown.JS и Graph.JS будет скачан дважды.
Пожалуйста, не делайте так.
**Итого**
Для больших сайтов я бы рекомендовал использовать одну из первых двух стратегий. Скорее всего это улучшение положительно скажется на вашей TTI метрике. Если же у вас блокирующий JS, то стоит задаться вопросом почему. Должен ли он быть таким? Старайтесь держать как можно меньше блокирующего JS на странице.
**Оффтоп. Почему 30 Кб JS это больнее, чем 30 Кб картинки**
Предположим у нас есть JS код, который анимирует страницу, добавляет какие-то выпадающие элементы, и есть картинка того же размера.
Для того, чтобы запустить JS нам нужно скачать код, распарсить его, сериализовать в код для компилятора, исполнить.
Итого, на обработку JS кода мы тратим больше времени, чем на ту же картинку.
#### Разносим блокирующие ресурсы. CSS
Данное улучшение напрямую влияет на FMP, если у вас не асинхронный CSS.
Если вы используете react\vue\angular, то для стилей стоит сделать то же, что и в предыдущем пункте. Как правило, в том же react-коде мы имеем импорты вида:
```
import './styles.css'
```
Это значит, что во время бандлинга JS-кода мы можем разделить и CSS, воспользовавшись одной из стратегий выше. Это поможет вебпаку или другому бандлеру получить аналогичные `common.css`, `applicant-page.css` и `applicant+employer.css`.
Если разбить используемый CSS не получается, можно посмотреть в сторону [used-styles](https://github.com/theKashey/used-styles) и статью на эту тему: ["optimising css delivery"](https://dev.to/thekashey/optimising-css-delivery-57eh). [kashey](https://habr.com/ru/users/kashey/) спасибо за клевые инструменты :)
Это поможет ускорить загрузку, например в случае с hh.ru почти на секунду по эстимейтам lighthouse:
#### Грузим то, что увидит пользователь, а не всю страницу.
Скорее всего на странице пользователь увидит несколько экранов. Я имею в виду, что далеко не всё влезет в первый. Кроме того, часть возможностей будет скрыта под кликами на кнопки.
Идея данной оптимизации в том, чтобы управлять загрузкой ваших ресурсов. В начале загрузить блокирующим способом тот CSS, который жизненно необходим для открытия страницы. Весь CSS, который относится к всплывающим элементам, popup-ам, которые спрятаны под JS кодом можно будет грузить асинхронно, например, добавив `rel=stylesheet` уже из JS кода, либо воспользовавшись `prefetch` с `onload` колбеком.
В данном случае мы усложним разработку, но сможем улучшить наш FMP. Общего совета как это сделать нет, нужно индивидуально смотреть сайт и выяснять, какие элементы можно перевести в асинхронную загрузку.
#### Выносим third-party скрипты
У нас в hh их много. Очень много!
Например? здесь в ТОП-10 самых тяжелых скриптов 7 — third-party.
Что мы можем с этим сделать?
1. Убедиться, что все ресурсы грузятся асинхронно и не влияют на FMP.
2. Для рекламы и прочих вещей (излишней аналитики, popup-ов поддержки) — снизить их влияние на основной "полезный" код. Это можно сделать, начав их инициализировать из нашего кода по `requestIdleCallback`. Эта функция запланирует вызов колбека с низшим приоритетом, когда наш браузер будет простаивать.
Такой подход позволяет нам экономить на FMP, хотя в TTI мы по-прежнему будем наблюдать проблемы. Это также поможет нам отложить работу прожорливых third-part скриптов.
#### Грузим картинки лениво
Картинки влияют на ваш TTI. Если вы понимаете, что пользователи из-за лишней работы браузера могут страдать, попробуйте начать грузить картинки, которые не попадают на экран, лениво. То есть:
1. Картинки попадающие на первый экран, грузим как обычно
2. Оставшимся картинкам проставляем специальные атрибуты, чтобы изображение грузилось только по мере того, как пользователь проскроллит к нему
3. Используем любую библиотеку\велосипед для ленивой загрузки картинок. [Вот здесь](https://css-tricks.com/the-complete-guide-to-lazy-loading-images/) достаточно хорошо описан подход.
### HTTP2.0
Многие из пунктов HTTP2.0 могут не сэкономить заметного количества времени, но разобрать их стоит.
#### HTTP2.0 Мультиплексинг
В случае если сайт загружает большое количество ресурсов, HTTP2.0 с мультиплексингом может сильно помочь.
Предположим, у нас есть 6 блокирующих ресурсов на домене, которые нужно скачать, чтобы отобразить сайт. Это могут быть стили или блокирующий JS. Считаем, что пользователь уже загрузил HTML:
Для отображения контента браузер будет производить параллельные запросы к каждому ресурсу:
В какой-то момент мы можем столкнуться с проблемой: браузеры ограничивают количество одновременных запросов на домен в рамках одной вкладки. Поэтому часть ресурсов будет запрошена после получения ответа от предыдущих блокирующих ресурсов.
Кроме того, каждый из ресурсов будет проходить времязатратные этапы на TCP handshake и прочие издержки. Они небольшие, но все-таки присутствуют.
Именно поэтому совет “нужен бандлинг и отдавать пользователю один бандл с нужным ему на этой странице CSS \ JS картинками” — работает.
Что такое мультиплексирование?
Мультиплексирование позволяет нам грузить ресурсы внутри одного HTTP запроса:
Запросов может быть несколько, и каждый из них грузит небольшое количество ресурсов. Так мы экономим на установлении соединения и оптимизируем ограничение по количеству одновременных запросов.
#### HTTP2.0 Сжатие заголовков
До http2.0 сжатия заголовков не существовало. В HTTP2.0 был анонсирован HPACK, которые отвечает за сжатие. [Здесь](https://tools.ietf.org/html/rfc7541) можно почитать подробнее.
Иногда заголовки могут занимать значительный объем запроса. О том, как работает сжатие заголовков HPACK вкратце:
Используется два словаря:
1. Статический — для базовых заголовков
2. Динамический — для кастомных
Для префиксного кодирования используется Huffman coding. На практике эта экономия выходит не сильно высокой и малозаметной.
#### HTTP2.0 Server push
В базовом варианте server push реализовать несложно. Проще всего сделать такую штуку для статических сайтов. Идея простая: вместе с запросом html страницы, наш веб-сервер заранее знает, что пользователю нужно отдать такой-то css, такую-то картинку и такой-то JS.
Реализуется достаточно просто (nginx):
```
location = /index.html {
http2_push /style.css;
http2_push /bundle.JS;
http2_push /image.jpg;
}
```
Проверить, что все работает несложно:
Такой способ будет работать для небольших статических сайтов. Если у вас большой сайт, то придется настраивать сложный пайп-лайн. Когда после сборки имена ваших ресурсов записываются в какой-то словарь, который затем собирает конфиг для nginx, содержащий урлы и прописывает http2\_push правила.
### Сжатие данных
Наиболее популярными решениями сейчас являются gzip и brotli. [Вот сайт](https://tools.paulcalvano.com/compression.php), где есть хорошее сравнение степени сжатия двух алгоритмов:
Примерно полтора года назад мы в hh.ru перешли с gzip на бротли. Размер нашего основного бандла уменьшился с 736 КБ до 657. Выиграли почти 12%.
Главным недостатком Brotli можно назвать затраты на "упаковку" данных. В среднем она тяжелее, чем gzip. Поэтому на nginx можно указать правило, чтобы он паковал ресурс и складывал его рядом, дабы не делать сжатие на каждый запрос. Ну или при сборке сразу класть сжатый вариант. Аналогично можно делать и для gzip.
Но в любом случае Brotli — ваш бро! На сайтах среднего размера он позволяет сэкономить секунду-полторы загрузки на слабых 3G сетях, что сильно улучшает как пользовательские ощущения, так и метрики в том же lighthouse.
### КЭШ
*Примечание*: описанный здесь способ не поможет вам получить дополнительные баллы у lighthouse, но поможет при работе с реальными пользователями. Этот способ положительно сказывается как на FMP, так и на TTI.
Сам кэш можно включить либо с помощью заголовков у статики, либо с помощью Service Worker.
Если мы говорим о заголовках, для этого служит 3 основных параметра:
1. last-modified или expires
2. ETag
3. Cache-control
Первые два (last-modified и expires) работают по дате, второй ETag — это ключ, который используется при запросе и если ключи совпадают, сервер ответит 304 кодом. Если не совпадут, то сервер отправит нужный ресурс. Включается на Nginx очень просто:
```
location ~* ^.+\.(js|css)$ {
...
etag on;
}
```
Disk cache проверяется очень просто через dev tools:
Cache-control — это стратегия того, как мы будем кэшировать информацию. Мы можем или отключить его вовсе, установив cache-control: no-cache, что может быть полезным для html запросов, которые часто меняются. Либо мы можем указать очень большой max-age, чтобы данные хранились как можно дольше. Для нашей статики, мы устанавливаем вот такой Cache-control:
```
cache-control: max-age=315360000, public
```
У нас частые релизы (несколько раз в день релизим каждый сервис), поэтому код в основном бандле меняется часто. Это приводит к тому, что пользователям приходится часто скачивать наши бандлы, парсить код и т.д.
Чтобы больше разобраться в том, как современные браузеры исполняют код и используют кэши, можно почитать прекрасную статью в блоге [v8](https://v8.dev/blog/code-caching-for-devs)
Нам интересна вот эта иллюстрация:
У нас есть "три способа" запуска нашего приложения: cold\warm и hot run. Идеально, если мы будем запускать приложение в режиме hot run, потому что на этом этапе мы не тратим время на компиляцию нашего года. Его достаточно только десериализовать.
Для того, чтобы получить hot run, пользователю нужно зайти на сайт в третий раз (за одними и теми же ресурсами) в таймслоте в 72 часа. В третий — потому что во второй раз будет выполнен warm run, который будет компилировать и сериализовать данные в дисковый кэш.
Мы на самом деле можем зафорсить hot run, использовав Service Worker. Механизм следующий:
1. Устанавливаем пользователю Service Worker;
2. Service worker подписывается на fetch;
3. Если происходит fetch за статикой, то сохраняем результат в кэш;
4. Добавляем перед отправкой запроса проверку на наличие ресурса в кэше.
Этот подход позволяет нам забустить дисковый кэш и использовать hot run уже со второй загрузки сайта. Дополнительное улучшение перфоманса мы получаем для мобильных устройств, которые чаще сбрасывают свой обычный кэш.
Минимальный вариант кода для данного случая:
```
self.addEventListener('fetch', function(event) {
// Кешируем статику, но не картинки
if (event.request.url.indexOf(staticHost) !== -1 && event.request.url.search(/\.(svg|png|jpeg|jpg|gif)/) === -1) {
return event.respondWith(
// проверяем наличие данных в кеше
caches.match(event.request).then(function(response) {
if (response) {
return response;
}
// Если данных в кеше нет, делаем запрос и сохраняем данные в кеш, который наызываем cacheStatic
return fetch(event.request).then(function(response) {
caches.open(cacheStatic).then(function(cache) {
cache.add(event.request.url);
});
return response;
});
})
);
}
});
```
Итого
-----
Мы рассмотрели наш Critical render path с точки зрения клиента (не углубляясь в такие вещи, как резолв DNS, handshake, запросы в БД и т.п.). Определили те шаги, которые делает браузер, чтобы сформировать первую страницу для пользователя. Поверхностно посмотрели на сложные способы оптимизации (разделения контента и т.д.)/ И разобрали более простые способы оптимизации: бандлинг, кэш, сжатие, транспорт.
Во второй части мы разберем работу сайта после загрузки, остановившись подробнее на механизмах перерисовки страницы.
Небольшое уточнение: здесь рассмотрены не все способы оптимизации, их заметно больше и появляются новые. Например, в [chrome 85](https://web.dev/content-visibility/) появится свойство `content-visibility`, которое позволит сократить время на рендеринг за счет отложенных вычислений. | https://habr.com/ru/post/513940/ | null | ru | null |
# Диаграмма воронки в Python
Диаграммы воронки зачастую используются для представления последовательного процесса. Они помогают смотрящему сравнивать и видеть, как цифры меняются от этапа к этапу.
В этой статье мы рассмотрим, как построить воронку с нуля с помощью Matplotlib, а затем рассмотрим более простую реализацию с помощью Plotly.
Диаграмма воронки. Иллюстрация автора **Matplotlib**
В Matplotlib нет способа мгновенно создать воронку, поэтому будем исходить из простой горизонтальной линейчатой диаграммы, и построим воронку из нее.
```
import matplotlib.pyplot as plt
y = [5,4,3,2,1]
x = [80,73,58,42,23]
plt.barh(y, x)
```
Выглядит довольно близко к тому, чего мы добиваемся, так почему бы не остаться здесь и не отделаться простой гистограммой?
Возможно, сравнивать значения с помощью простенькой гистограммы и легче, но выбор диаграммы-воронки может сделать взаимосвязь между столбцами более явной и превратить нашу визуализацию в более привлекательную.
Хорошо, теперь нужно выстраивать по одному столбцу за раз и использовать параметр «*left*», чтобы отрегулировать их положение на диаграмме. Давайте проверим, как это будет работать.
```
y = [5,4,3,2,1]
x = [80,73,58,42,23]
x_max = 100
x_min = 0
for idx, val in enumerate(x):
plt.barh(y[idx], x[idx], left = idx+5)
plt.xlim(x_min, x_max)
```
Теперь у нас есть размер горизонтальных столбцов, который равен x, и диапазон оси x, который равен 100.
Разница между этими значениями – это пустое пространство. Чтобы отцентрировать столбцы нам нужно одинаковое количество пустого пространства с каждой из сторон.
Итак, получается, что:
*left = (размер столбца – диапазон оси x) / 2*
Давайте посмотрим, как это выглядит:
```
y = [5,4,3,2,1]
x = [80,73,58,42,23]
x_max = 100
x_min = 0
for idx, val in enumerate(x):
left = (x_max - val)/2
plt.barh(y[idx], x[idx], left = left, color='grey')
plt.xlim(x_min, x_max)
```
Отлично! Однако теперь информация об осях какая-то бесполезная, поскольку у столбцов не одна и та же начальная точка. Нужно вывести эти значения на столбцах и соединить их.
```
y = [5,4,3,2,1]
x = [80,73,58,42,23]
x_max = 100
x_min = 0
fig, ax = plt.subplots(1, figsize=(12,6))
for idx, val in enumerate(x):
left = (x_max - val)/2
plt.barh(y[idx], x[idx], left = left, color='grey', height=1, edgecolor='black')
# value
plt.text(50, y[idx], x[idx], ha='center', fontproperties=font,
fontsize=16, color='#2A2A2A')
plt.axis('off')
plt.xlim(x_min, x_max)
```
Хорошо, мы могли бы добавить заголовок, несколько ярлыков на столбцах и закончить на этом.
Но давайте же добавим услады для глаз смотрящего и сделаем тень, соединяющую столбцы, вместо того чтобы просто склеивать их вместе. Так ваша диаграмма станет качественнее и связь между столбцами станет более четкой.
Во-первых, давайте определим все необходимые нам переменные:
```
from matplotlib import font_manager as fm
# funnel chart
y = [5,4,3,2,1]
x = [80,73,58,42,23]
labels = ['Hot Leads', 'Samples Sent', 'Quotes', 'Negotiations', 'Sales']
x_max = 100
x_min = 0
x_range = x_max - x_min
fpath = "fonts/NotoSans-Regular.ttf"
font = fm.FontProperties(fname=fpath)
```
И добавим немного деталей.
```
fig, ax = plt.subplots(1, figsize=(12,6))
for idx, val in enumerate(x):
left = (x_range - val)/2
plt.barh(y[idx], x[idx], left = left, color='#808B96',
height=.8, edgecolor='black')
# label
plt.text(50, y[idx]+0.1, labels[idx], ha='center',
fontproperties=font, fontsize=16, color='#2A2A2A')
# value
plt.text(50, y[idx]-0.3, x[idx], ha='center',
fontproperties=font, fontsize=16, color='#2A2A2A')
plt.xlim(x_min, x_max)
plt.axis('off')
plt.title('Beskar Forging Services Inc.', fontproperties=font, loc='center', fontsize=24, color='#2A2A2A')
plt.show()
```
*\*Шрифт взят отсюда:* [*https://fonts.google.com/specimen/Noto+Sans*](https://fonts.google.com/specimen/Noto+Sans)
Проведем линию от одной стороны столбца к другой. Мы можем использовать значение *left*, чтобы найти начало и конец столбца, а значение *y*, чтобы найти его центр.
```
fig, ax = plt.subplots(1, figsize=(12,6))
for idx, val in enumerate(x):
left = (x_range - val)/2
plt.barh(y[idx], x[idx], left = left, color='#808B96', height=.8, edgecolor='black')
# label
plt.text(50, y[idx]+0.1, labels[idx], ha='center',
fontproperties=font, fontsize=16, color='#2A2A2A')
# value
plt.text(50, y[idx]-0.3, x[idx], ha='center',
fontproperties=font, fontsize=16, color='#2A2A2A')
plt.plot([left, 100-left], [y[idx], y[idx]])
plt.xlim(x_min, x_max)
plt.axis('off')
plt.title('Beskar Forging Services Inc.', fontproperties=font, loc='center', fontsize=24, color='#2A2A2A')
plt.show()
```
А теперь подвинем эту линию в нижнюю часть столбца, а для последнего – ее не будем рисовать вовсе, поскольку там соединения не будет.
Высота столбца будет равна 0.8, поэтому, чтобы переместить линию вниз, нужно уменьшить *y* до 0.4.
Также нам понадобятся координаты вершины следующего горизонтального столбца.
```
fig, ax = plt.subplots(1, figsize=(12,6))
for idx, val in enumerate(x):
left = (x_range - val)/2
plt.barh(y[idx], x[idx], left = left, color='#808B96', height=.8, edgecolor='black')
# label
plt.text(50, y[idx]+0.1, labels[idx], ha='center',
fontproperties=font, fontsize=16, color='#2A2A2A')
# value
plt.text(50, y[idx]-0.3, x[idx], ha='center',
fontproperties=font, fontsize=16, color='#2A2A2A')
if idx != len(x)-1:
next_left = (x_range - x[idx+1])/2
plt.plot([left, 100-left],
[y[idx]-0.4, y[idx]-0.4])
plt.plot([next_left, 100-next_left],
[y[idx+1]+0.4, y[idx+1]+0.4])
plt.xlim(x_min, x_max)
plt.axis('off')
plt.title('Beskar Forging Services Inc.', fontproperties=font, loc='center', fontsize=24, color='#2A2A2A')
plt.show()
```
Мы нашли все точки, которые нужно отрисовать. Теперь можно соединить эти точки и посмотреть, получим ли мы нужную форму.
Не забудьте продублировать первую точку в самом конце, чтобы замкнуть многоугольник.
```
fig, ax = plt.subplots(1, figsize=(12,6))
for idx, val in enumerate(x):
left = (x_range - val)/2
plt.barh(y[idx], x[idx], left = left, color='#808B96', height=.8, edgecolor='black')
# label
plt.text(50, y[idx]+0.1, labels[idx], ha='center',
fontproperties=font, fontsize=16, color='#2A2A2A')
# value
plt.text(50, y[idx]-0.3, x[idx], ha='center',
fontproperties=font, fontsize=16, color='#2A2A2A')
if idx != len(x)-1:
next_left = (x_range - x[idx+1])/2
shadow_x = [left, next_left,
100-next_left, 100-left, left]
shadow_y = [y[idx]-0.4, y[idx+1]+0.4,
y[idx+1]+0.4, y[idx]-0.4, y[idx]-0.4]
plt.plot(shadow_x, shadow_y)
plt.xlim(x_min, x_max)
plt.axis('off')
plt.title('Beskar Forging Services Inc.', fontproperties=font, loc='center', fontsize=24, color='#2A2A2A')
plt.show()
```
Идеально. Осталось поменять `.plot` на `.fill` и диаграмма готова.
```
fig, ax = plt.subplots(1, figsize=(12,6))
for idx, val in enumerate(x):
left = (x_range - val)/2
plt.barh(y[idx], x[idx], left = left,
color='#808B96', height=.8)
# label
plt.text(50, y[idx]+0.1, labels[idx], ha='center',
fontproperties=font, fontsize=16, color='#2A2A2A')
# value
plt.text(50, y[idx]-0.3, x[idx], ha='center',
fontproperties=font, fontsize=16, color='#2A2A2A')
if idx != len(x)-1:
next_left = (x_range - x[idx+1])/2
shadow_x = [left, next_left,
100-next_left, 100-left, left]
shadow_y = [y[idx]-0.4, y[idx+1]+0.4,
y[idx+1]+0.4, y[idx]-0.4, y[idx]-0.4]
plt.fill(shadow_x, shadow_y, color='grey', alpha=0.6)
plt.xlim(x_min, x_max)
plt.axis('off')
plt.title('Beskar Forging Services Inc.', fontproperties=font, loc='center', fontsize=24, color='#2A2A2A')
plt.show()
```
Вот и оно!
Рисование воронки с Matplotlib может очень быстро перерасти из простой задачи в сложную.
Но в этом и есть особая прелесть Matplotlib, ведь мы можем нарисовать практически все, что душе угодно.
**Plotly**
А теперь перейдем к более простому способу достичь тех же результатов, и нарисуем воронку с помощью Plotly.
```
import plotly.express as px
data = dict(values=[80,73,58,42,23],
labels=['Hot Leads', 'Samples Sent',
'Quotes', 'Negotiations', 'Sales'])
fig = px.funnel(data, y='labels', x='values')
fig.show()
```
Потрясающе. У Plotly есть метод для построения диаграмм-воронок, поэтому нам нужны лишь данные, все остальное сделают за нас.
Также у Plotly есть множество опций для кастомизации диаграмм.
Возможно, здесь вы не так хорошо контролируете визуализацию, как до этого, но строить воронку так гораздо удобнее.
```
data = dict(Quantity=[80, 73, 58, 42, 23,
180, 120, 82, 51, 33,
109, 78, 62, 44, 22],
Stage=['Hot Leads', 'Samples Sent', 'Quotes',
'Negotiations', 'Sales']*3,
Location=['Tatooine']*5 + ['Mandalore']*5 + ['Nevarro']*5)
fig = px.funnel(data, y='Stage', x='Quantity', color='Location',
color_discrete_map={"Tatooine": "#374B53",
"Mandalore": "#617588",
"Nevarro": "#A4B7C8"},
template="simple_white",
title='Beskar Forging Services Inc.',
labels={"Stage": ""})
fig.show()
```
И все! Мы посмотрели, как построить воронку с нуля с помощью Matplotlib, и увидели насколько можно усложнить простую визуализацию. А еще мы проверили более удобный способ построения диаграммы-воронки с помощью Plotly и познакомились с некоторыми вариациями ее кастомизации.
Спасибо, что прочитали. Надеюсь, вам понравилось.
---
> Материал подготовлен в рамках курса [«Python для аналитики».](https://otus.pw/G8z8/)
>
> Всех желающих приглашаем на demo-занятие **«Построение графиков при помощи популярных Python библиотек»**. Чтобы построить наиболее информативный аналитический отчет, иногда требуются использование множества графиков. На открытом уроке мы рассмотрим построение различных видов графиков на python с использованием популярных библиотек.
> [>> РЕГИСТРАЦИЯ](https://otus.pw/ZLWa/)
>
> | https://habr.com/ru/post/589593/ | null | ru | null |
# Видео с камеры наблюдения на сайте бесплатно и без смс
Появилась необходимость показывать видео с камеры на сайте в режиме онлайн. Виделось несколько вариантов (дополню вариантами из комментов, если будут):
* Дать доступ к камере. Просто доступ к камере давать не стоит по соображениям безопасности. Камера ляжет уже при очень небольшой нагрузке.
* Коммерческая услуга. Мы им доступ к камере и деньги, они нам ссылку для размещения на сайте. Они же решают проблему совместимости камеры и браузеров пользователей, производительности канала и доступности
* На своих мощностях. Между пользователем и камерой ставится нечто, что отвечает за совместимость с браузерами, производительность и доступность. Проблемы решаем сами.
Этот вариант рассмотрим ниже. Т.к. "*flash умер*" или "*flash вот-вот умрет*", вариант с размещением flash плейера на сайте не рассматривался. Тернистый путь поисков решений в интернетах не привел к готовому решению. Пришлось изобрести велосипед.
Подробнее изобретения под катом.
Описание полученного велосипеда подробнее:
------------------------------------------
* камера видеонаблюдения отдает поток по протоколу [rtsp](https://ru.wikipedia.org/wiki/RTSP).
* [ffmpeg](https://ffmpeg.org) берет видео поток с камеры и создает видео для показа через тег [video стандарта html5](http://htmlbook.ru/html/video).
* [nginx](http://nginx) отдает созданные файлы пользователям
* видео на странице показываем с помощью [hls](https://ru.wikipedia.org/wiki/HLS), точнее вот эта [реализация](https://github.com/dailymotion/hls.js/tree/master)
### Подробнее о настройках
На каждый поток с камеры надо запустить [ffmpeg](https://ffmpeg.org) для преобразования [rtsp](https://ru.wikipedia.org/wiki/RTSP) в файлы который поймет [hls](https://ru.wikipedia.org/wiki/HLS).
#### ffmpeg и поток со звуком
```
/usr/bin/ffmpeg \
-i rtsp://<этот путь можно найти через ONVIF Device Manager> \
-ar 44100 \
-acodec aac -ac 1 -strict -2 -crf 18 \
-c:v copy -preset ultrafast \
-flags -global_header \
-fflags flush_packets -tune zerolatency \
-hls_time 1 -hls_list_size 3 -hls_wrap 4 -hls_flags delete_segments -start_number 0 \
/tmp/www/index1.m3u8
```
**ffmpeg при старте пишет 25 fps при FullHD**
```
Guessed Channel Layout for Input Stream #0.1 : mono
Input #0, rtsp, from 'rtsp://192.168.X.X:554/user=admin_password=tlJwpbo6_channel=1_stream=0.sdp?':
Metadata:
title : RTSP Session
Duration: N/A, start: 0.000000, bitrate: N/A
Stream #0:0: Video: h264 (Baseline), yuv420p, 1920x1080, 25 fps, 9 tbr, 90k tbn, 50 tbc
Stream #0:1: Audio: pcm_alaw, 8000 Hz, 1 channels, s16, 64 kb/s
Output #0, hls, to '/tmp/www/index1.m3u8':
Metadata:
title : RTSP Session
encoder : Lavf56.25.101
Stream #0:0: Video: h264, yuv420p, 1920x1080, q=2-31, 25 fps, 9 tbr, 90k tbn, 25 tbc
Stream #0:1: Audio: aac, 44100 Hz, mono, fltp, 128 kb/s
Metadata:
encoder : Lavc56.26.100 aac
Stream mapping:
Stream #0:0 -> #0:0 (copy)
Stream #0:1 -> #0:1 (pcm_alaw (native) -> aac (native))
```
Видео просто копируется, аудио пришлось перекодировать иначе тишина.
Камера noname.#### Как работает:
Берем поток, без перекодирования создаем файлы и список для воспроизведения в папке */tmp/www/*.
#### nginx
Сокращаем стандартный для пакета [debian](https://www.debian.org/index.ru.html) файл *default* до, например, такого:
**/etc/nginx/sites-enabled/default**
```
server {
listen 80 default_server;
listen [::]:80 default_server;
access_log off;
error_log /dev/null;
root /tmp/www;
index index.html;
server_name _;
location / {
# First attempt to serve request as file, then
# as directory, then fall back to displaying a 404.
try_files $uri $uri/ =404;
}
}
```
Пример страницы с видео:
**/tmp/www/index.html**
```
Заголовок
if(Hls.isSupported()) {
var video = document.getElementById('video');
var hls = new Hls();
hls.loadSource('/index1.m3u8');
hls.attachMedia(video);
hls.on(Hls.Events.MANIFEST\_PARSED,function() {
video.play();
});
}
```
Скрипт стоит разместить локально, он не имеет внешних зависимостей. [Подробнее о настройках hls](https://github.com/dailymotion/hls.js/tree/master#getting-started).
#### Как работает:
на странице подключается hls и воспроизводит файлы из списка index1.m3u8. Список и файлы обновляются ffmpeg.
#### Что получилось:
* Работает;
* Самую большую нагрузку создает ffmpeg, на процессоре Atom трехлетней давности;
+ Разрешение камеры Full HD без звука — 1%;
+ Разрешение камеры Full HD со звуком — 5%;
* Количество процессов nginx — смотреть по нагрузке и доступному каналу. Нагрузку на процессор увидеть не удалось — не очень много надо на просто отдачу небольших файлов.;
* Сервер с ffmpeg и nginx можно разместить где угодно, не обязательно на хостинге или в месте расположения камер;
* Отставание от потока зависит от количества файлов в списке и размера(в секундах) файла. Например отставание в 10 секунд не очень влияет на просмотр процесса строительства многоэтажки;
* Видеофайлы лучше размещать на tmpfs, они имеют небольшие размеры и часто они перезаписываются;
* Весь сервис стоит поместить в контейнер. Все пакеты стандартные для `FROM debian:jessie`;
* По итогам эксплуатации ffmpeg иногда падает, за ним нужно следить и перезапускать если упал.
**Вывод top из контейнера:**
```
top - 11:05:20 up 6 days, 12:15, 0 users, load average: 1.29, 1.09, 1.03
Tasks: 17 total, 1 running, 16 sleeping, 0 stopped, 0 zombie
%Cpu(s): 38.8 us, 1.0 sy, 0.0 ni, 59.6 id, 0.0 wa, 0.0 hi, 0.5 si, 0.0 st
KiB Mem: 16359132 total, 16027988 used, 331144 free, 782968 buffers
KiB Swap: 6369276 total, 3776 used, 6365500 free. 12784916 cached Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
281 root 20 0 341040 29192 19632 S 4.7 0.2 10:08.39 ffmpeg
16 root 20 0 315888 27944 18984 S 1.0 0.2 2:50.95 ffmpeg
9 root 20 0 46916 15128 6408 S 0.3 0.1 0:58.04 supervisord
```
* Смотреть можно на десктопах и мобильных устройствах с современными браузерами;
* В обозримом будущем не потребует вмешательства.
#### Ссылки:
» [Реализация hls](https://github.com/dailymotion/hls.js/tree/master)
» [Демо работы hls](http://dailymotion.github.io/hls.js/demo/)
» [ffmpeg](https://ffmpeg.org/)
» [nginx](https://nginx.org/ru/)
» [Дополненный и расширенный текст статьи на моём блоге](https://blog.erchov.ru/2017/01/%D0%B2%D0%B8%D0%B4%D0%B5%D0%BE-%D1%81-%D0%BA%D0%B0%D0%BC%D0%B5%D1%80%D1%8B-%D0%BD%D0%B0%D0%B1%D0%BB%D1%8E%D0%B4%D0%B5%D0%BD%D0%B8%D1%8F-%D0%BD%D0%B0-%D1%81%D0%B0%D0%B9%D1%82%D0%B5-%D0%B1%D0%B5%D1%81/) | https://habr.com/ru/post/401107/ | null | ru | null |
# PostgreSQL 16: Part 3 or CommitFest 2022-11
We continue to follow the news of the upcoming PostgreSQL 16. The third CommitFest concluded in early December. Let's look at the results.
If you missed the previous CommitFests, check out our reviews: [2022-07](https://habr.com/ru/company/postgrespro/blog/699610/), [2022-09](https://habr.com/ru/company/postgrespro/blog/696816/).
Here are the patches I want to talk about:
[meson: a new source code build system](#commit_e6927270)
[Documentation: a new chapter on transaction processing](#commit_66bc9d2d)
[psql: \d+ indicates foreign partitions in a partitioned table](#commit_bd95816f)
[psql: extended query protocol support](#commit_5b66de34)
[Predicate locks on materialized views](#commit_43351557)
[Tracking last scan time of indexes and tables](#commit_c0374718)
[pg\_buffercache: a new function pg\_buffercache\_summary](#commit_2589434a)
[walsender displays the database name in the process status](#commit_af205152)
[Reducing the WAL overhead of freezing tuples](#commit_9e540599)
[Reduced power consumption when idle](#commit_cd4329d9)
[postgres\_fdw: batch mode for COPY](#commit_97da4824)
[Modernizing the GUC infrastructure](#commit_f13b2088)
[Hash index build optimization](#commit_e09d7a12)
[MAINTAIN ― a new privilege for table maintenance](#commit_60684dd8)
[SET ROLE: better role change management](#commit_3d14e171)
[Support for file inclusion directives in pg\_hba.conf and pg\_ident.conf](#commit_a54b658c)
[Regular expressions support in pg\_hba.conf](#commit_8fea8683)
**[meson: a new source code build system](https://commitfest.postgresql.org/39/3395/)**
commit: [e6927270](https://github.com/postgres/postgres/commit/e6927270), [4c72102e](https://github.com/postgres/postgres/commit/4c72102e)
Meson support was first introduced in a commit way back in September. Several dozen more commits followed. Several dozens more followed. In early December, a [documentation section](https://www.postgresql.org/docs/devel/install-meson.html) describing the new build process was committed. There is also a [wiki page](https://wiki.postgresql.org/wiki/Meson) that explains, among other things, what was behind the decision to introduce the new building tool. One of the reasons is to simplify building the server for Windows systems and to be able to eventually stop supporting the PostgreSQL's own build tools from the /src/tools/msvc entirely.
The new build system will be available alongside with autoconf and make, there is no plans to replace the good old tools.
However, I specifically used Meson to build the fresh PostgreSQL 16 testing environment for this article. On Ubuntu, the building went as follows:
```
$ git clone git://git.postgresql.org/git/postgresql.git
$ cd postgresql
$ meson setup build --prefix=/home/pal/pg16 -Dpgport=5416
$ cd build
$ ninja
$ ninja install
```
I left everything on default, except for the installation location and the server port.
All what's left is to initialize the cluster and start the server, which you do the same way regardless of the build tool used.
**[Documentation: a new chapter on transaction processing](https://commitfest.postgresql.org/40/3899/)**
commit: [66bc9d2d](https://github.com/postgres/postgres/commit/66bc9d2d)
A new chapter has been added to the documentation: [74. Transaction processing](https://www.postgresql.org/docs/devel/transactions.html). It lives in the Internals section and gives a brief overview of what virtual and real transaction identifiers are, how they are shown in pg\_locks, and how subtransactions and two-phase transactions work.
**[psql: \d+ indicates foreign partitions in a partitioned table](https://commitfest.postgresql.org/40/3972/)**
commit: [bd95816f](https://github.com/postgres/postgres/commit/bd95816f)
For a partitioned table, the \d+ command will mark sections that are foreign tables with the word FOREIGN.
```
\d+ data
```
```
Partitioned table "public.data"
Column | Type | Collation | Nullable | Default | Storage | Compression | Stats target | Description
-----------+------+-----------+----------+---------+----------+-------------+--------------+-------------
data_year | text | | | | extended | | |
Partition key: LIST (data_year)
Partitions: data_2020 FOR VALUES IN ('2020'), FOREIGN,
data_2021 FOR VALUES IN ('2021'), FOREIGN,
data_2022 FOR VALUES IN ('2022')
```
**[psql: extended query protocol support](https://commitfest.postgresql.org/40/3974/)**
commit: [5b66de34](https://github.com/postgres/postgres/commit/5b66de34)
Until now, psql has not directly supported the [extended query protocol](https://www.postgresql.org/docs/current/protocol-overview.html#PROTOCOL-QUERY-CONCEPTS). Therefore, parameterized queries could only be performed indirectly, such as with the PREPARE statement.
Now the \bind command has been added to psql to bind values to the parameters of the next query. Here's how it works:
```
SET log_statement='all';
\bind 42 'Answer: '
SELECT $2||$1;
```
```
?column?
------------
Answer: 42
(1 row)
```
```
\! tail -2 logfile
```
```
2022-12-05 12:58:05.924 MSK [16566] LOG: execute : SELECT $2||$1;
2022-12-05 12:58:05.924 MSK [16566] DETAIL: parameters: $1 = '42', $2 = 'Answer: '
```
Only a fraction of the capabilities of the extended query protocol has been implemented, but the initiative is very welcome.
**[Predicate locks on materialized views](https://commitfest.postgresql.org/40/3804/)**
commit: [43351557](https://github.com/postgres/postgres/commit/43351557)
Predicate locks are used to ensure consistency for transactions with the SERIALIZABLE isolation level. They were never designed to update materialized views with the REFRESH MATERIALIZED VIEW command, because it exclusively locks the view in order to prevent any concurrent access anomalies.
But when updating with the CONCURRENTLY parameter and without predicate locks, transactions with the SERIALIZABLE isolation level could experience write skew. Now the problem is fixed.
**[Tracking last scan time of indexes and tables](https://commitfest.postgresql.org/40/3836/)**
commit: [c0374718](https://github.com/postgres/postgres/commit/c0374718)
In addition to counting table and index scans, the cumulative statistics system now records time and date of the last recorded scan. This data is stored in the last\_seq\_scan and last\_idx\_scan columns in pg\_stat\_all\_tables and the last\_idx\_scan column in pg\_stat\_all\_indexes.
```
SELECT seq_scan, last_seq_scan, idx_scan, last_idx_scan
FROM pg_stat_all_tables
WHERE relid = 'tickets'::regclass;
```
```
seq_scan | last_seq_scan | idx_scan | last_idx_scan
----------+-------------------------------+----------+-------------------------------
23 | 2022-12-07 15:17:57.261575+03 | 2 | 2022-12-05 14:59:53.564968+03
(1 row)
```
```
SELECT indexrelname, idx_scan, last_idx_scan
FROM pg_stat_all_indexes
WHERE relid = 'tickets'::regclass;
```
```
indexrelname | idx_scan | last_idx_scan
----------------------+----------+-------------------------------
tickets_pkey | 2 | 2022-12-05 14:59:53.564968+03
tickets_book_ref_idx | 0 |
(2 rows)
```
It can be helpful for analyzing index and table use if no dedicated monitoring system is implemented.
**[pg\_buffercache: a new function pg\_buffercache\_summary](https://commitfest.postgresql.org/40/3839/)**
commit: [2589434a](https://github.com/postgres/postgres/commit/2589434a)
The pg\_buffercache extension now can display aggregated buffer cache data:
```
CREATE EXTENSION pg_buffercache;
SELECT * FROM pg_buffercache_summary()\gx
```
```
-[ RECORD 1 ]--+------------------
buffers_used | 2544
buffers_unused | 13840
buffers_dirty | 38
buffers_pinned | 0
usagecount_avg | 2.183176100628931
```
We used to obtain this data by aggregating the pg\_buffercache view, but the new function does not lock the buffers, therefore it is cheaper and can be easily integrated into monitoring systems.
**[walsender displays the database name in the process status](https://commitfest.postgresql.org/40/3937/)**
commit: [af205152](https://github.com/postgres/postgres/commit/af205152)
walsender is the process that handles replication protocol connections. For physical replication or backup, walsender connects to an instance, but not to a specific database. When you create a logical replication subscription, however, the publisher creates a logical replication slot, and walsender connects to the database where the publication is created.
The patch adds the name of the database to walsender process description in case of logical replication, which makes monitoring those processes more convenient.
```
16(sub)=# CREATE SUBSCRIPTION sub CONNECTION 'port=5416 user=postgres dbname=demo' PUBLICATION pub;
```
```
NOTICE: created replication slot "sub" on publisher
CREATE SUBSCRIPTION
```
```
16(pub)=# \! ps -o pid,command --ppid `head -n 1 /home/pal/pg16/data/postmaster.pid`
```
```
PID COMMAND
38514 postgres: checkpointer
38515 postgres: background writer
38517 postgres: walwriter
38518 postgres: autovacuum launcher
38519 postgres: logical replication launcher
38522 postgres: postgres demo [local] idle
38662 postgres: walsender postgres demo [local] START_REPLICATION
```
Here, the walsender process status displays the demo database name.
**[Reducing the WAL overhead of freezing tuples](https://commitfest.postgresql.org/40/3886/)**
commit: [9e540599](https://github.com/postgres/postgres/commit/9e540599)
Peter Geoghegan is [working](https://wiki.postgresql.org/wiki/Freezing/skipping_strategies_patch:_motivating_examples) on proactive tuple freezing. The purpose is clear: to avoid transaction counter wraparound, you need to start freezing in advance. However, an earlier freeze leads to a larger WAL volume and increases the associated overhead (WAL replication and archiving).
In this patch, Peter proposed to form WAL freezing records more compactly (~5 times so).
**[Reduced power consumption when idle](https://commitfest.postgresql.org/40/3566/)**
commit: [cd4329d9](https://github.com/postgres/postgres/commit/cd4329d9), [05a7be93](https://github.com/postgres/postgres/commit/05a7be93)
When the main server is idle, the startup process on physical replicas still wakes up every 5 seconds to check if the file specified in the *promote\_trigger\_file* has appeared. But there are other mechanisms for promoting a replica: pg\_ctl promote and the pg\_promote function. To reduce resource consumption for such wake-ups, the *promote\_trigger\_file* parameter was removed.
[Similar work](https://github.com/postgres/postgres/commit/05a7be93) was done with the walreceiver process, which woke up 10 times a second, checking whether it needed to do something. Now, the process calculates the time of its next start in advance.
**[postgres\_fdw: batch mode for COPY](https://commitfest.postgresql.org/40/2601/)**
commit: [97da4824](https://github.com/postgres/postgres/commit/97da4824)
Batch-inserting records into foreign tables [first became possible](https://habr.com/ru/company/postgrespro/blog/541252#commit_b663a413) in the 14th release. The batch size is set by the batch\_size parameter at the foreign server or table level. However, it was implemented only for the INSERT command. This patch adds support for batch paste mode for the COPY FROM command.
Let's compare the insertion speed by different commands. To do this, I first create an empty bookings table in the postgres database, into which we will insert data.
```
postgres=# CREATE TABLE public.bookings (
book_ref char(6),
book_date timestamptz,
total_amount numeric(10,2)
);
```
In the demo database in the same cluster, let's create a foreign table for the bookings table.
```
CREATE EXTENSION postgres_fdw;
CREATE SERVER srv
FOREIGN DATA WRAPPER postgres_fdw
OPTIONS (dbname 'postgres', batch_size '1');
CREATE USER MAPPING FOR postgres
SERVER srv
OPTIONS (user 'postgres');
CREATE FOREIGN TABLE bookings_remote (
book_ref char(6),
book_date timestamptz,
total_amount numeric(10,2)
) SERVER srv
OPTIONS (schema_name 'public', table_name 'bookings');
```
The batch size is set at the server level as 1, which means that the batch mode is disabled and records are sent one at a time.
Let's dump the bookings table contents from the [demo database](https://postgrespro.com/community/demodb) into a file:
```
\COPY bookings TO 'bookings.txt'
```
Now, upload the file contents into the foreign table and measure the time:
```
\timing on
\COPY bookings_remote FROM 'bookings.txt'
```
```
COPY 2111110
Time: 57327,152 ms (00:57,327)
```
It took almost a minute to insert a little more than two million rows. Set the batch size to 100 and repeat the test:
```
TRUNCATE bookings_remote;
ALTER SERVER srv OPTIONS (SET batch_size '100');
\COPY bookings_remote FROM 'bookings.txt'
```
```
COPY 2111110
Time: 8780,000 ms (00:08,780)
```
The insertion speed has increased by more than 6 times!
Curiously, the INSERT command works even faster in batch mode:
```
TRUNCATE bookings_remote;
INSERT INTO bookings_remote SELECT * FROM bookings;
```
```
INSERT 0 2111110
Time: 6669,504 ms (00:06,670)
```
So when it comes to insertion with the COPY command, there's room for optimization yet! Also, it would be great to teach postgres\_fdw to use batch mode to modify and delete rows, not just read and insert.
**[Modernizing the GUC infrastructure](https://commitfest.postgresql.org/40/3879/)**
commit: [f13b2088](https://github.com/postgres/postgres/commit/f13b2088), [3057465a](https://github.com/postgres/postgres/commit/3057465a), [407b50f2](https://github.com/postgres/postgres/commit/407b50f2), [9c911ec0](https://github.com/postgres/postgres/commit/9c911ec0)
This series of commits optimizes storage and speeds up access to configuration parameters, including user-generated ones.
The optimization is most evident in the example that Tom Lane gave in the letter that started the discussion:
```
do $$
begin
for i in 1..10000 loop
perform set_config('foo.bar' || i::text, i::text, false);
end loop;
end $$;
```
On my computer, creating ten thousand user parameters in PostgreSQL 15 took about six seconds, and after applying the patches, the time was reduced to ~ 30 milliseconds.
**[Hash index build optimization](https://commitfest.postgresql.org/38/3635/)**
commit: [e09d7a12](https://github.com/postgres/postgres/commit/e09d7a12), [d09dbeb9](https://github.com/postgres/postgres/commit/d09dbeb9)
When building hash indexes, the values were sorted only by the bucket number. If you additionally sort by value, then inserting subsequent values is faster.
The first commit was made in July, and the second in November. By now, the hash index build speed increased by 5-15%.
**[MAINTAIN ― a new privilege for table maintenance](https://commitfest.postgresql.org/41/4055/)**
commit: [60684dd8](https://github.com/postgres/postgres/commit/60684dd8)
A number of maintenance actions for tables and materialized views are not regulated by privileges and are usually available only to the object owner and the superuser.
PostgreSQL 16 introduces the MAINTAIN privilege, which can be granted on materialized views and tables, including system ones:
```
GRANT MAINTAIN ON pg_class, pg_attribute, pg_type TO alice;
```
The \dp output uses the m character for this privilege:
```
\dp pg_catalog.pg_class
Access privileges
Schema | Name | Type | Access privileges | Column privileges | Policies
------------+----------+-------+----------------------------+-------------------+----------
pg_catalog | pg_class | table | postgres=arwdDxtm/postgres+| |
| | | =r/postgres +| |
| | | alice=m/postgres | |
```
What actions are granted by this privilege? These include executing the commands ANALYZE, VACUUM (including VACUUM FULL), CLUSTER, REINDEX, REFRESH MATERIALIZED VIEW and LOCK TABLE.
In addition, a predefined pg\_maintain role has been added. Membership in this role grants the MAINTAIN privilege on all relations in the database. This allows you to grant maintenance privileges to a regular role that does not have the rights to perform DDL and DML operations in the database otherwise.
The initial patch proposed the addition of two privileges for VACUUM and ANALYZE, but eventually the community settled on the MAINTAIN privilege with more extensive maintenance capabilities.
**[SET ROLE: better role change management](https://commitfest.postgresql.org/40/3868/)**
commit: [3d14e171](https://github.com/postgres/postgres/commit/3d14e171)
This patch continues the effort to build a more robust roles and privileges management system. The previous article talked about [granting membership in roles](https://postgrespro.com/blog/pgsql/5969859#commit_ce6b672e) and [inheriting privileges](https://postgrespro.com/blog/pgsql/5969859#commit_e3ce2de0).
The new patch introduces switching to another role with the SET ROLE command. Suppose we decide to include the alice role into pg\_read\_all\_data with privilege inheritance enabled:
```
postgres=# GRANT pg_read_all_data TO alice WITH INHERIT TRUE;
```
The alice role can now use pg\_read\_all\_data privileges. But nothing is stopping alice from switching role to pg\_read\_all\_data and starting to create objects on its behalf:
```
postgres=# \c - alice
```
```
You are now connected to database "postgres" as user "alice".
```
```
alice=> CREATE TABLE t (id int);
```
```
CREATE TABLE
```
```
alice=> \dt t
```
```
List of relations
Schema | Name | Type | Owner
--------+------+-------+------------------
public | t | table | pg_read_all_data
```
Actually, there is. To create objects, the pg\_read\_all\_data role must have the CREATE privilege in some schema, such as in public. And starting from PostgreSQL 15, the pseudo-role public no longer has this privilege. As for the example above, I had to run the following command in advance:
```
postgres=# GRANT CREATE ON SCHEMA public TO public;
```
Nevertheless, switching to another role may be undesirable in certain situations. If we provided membership in a role with INHERIT TRUE, then why switch at all? In the new version, this can be prohibited by the same GRANT command:
```
postgres=# GRANT pg_read_all_data TO alice WITH INHERIT TRUE, SET FALSE;
```
Alice can now use pg\_read\_all\_data privileges, but will not be able to switch to it.
```
alice=> SET ROLE pg_read_all_data;
```
```
ERROR: permission denied to set role "pg_read_all_data"
```
The ability to switch to a role is stored in the set\_option column of the pg\_auth\_members table, next to inherit\_option and admin\_option.
```
SELECT roleid::regrole, member::regrole, grantor::regrole,
admin_option, inherit_option, set_option
FROM pg_auth_members
WHERE member = 'alice'::regrole\gx
```
```
-[ RECORD 1 ]--+-----------------
roleid | pg_read_all_data
member | alice
grantor | postgres
admin_option | f
inherit_option | t
set_option | f
```
**[Support for file inclusion directives in pg\_hba.conf and pg\_ident.conf](https://commitfest.postgresql.org/40/3558/)**
commit: [a54b658c](https://github.com/postgres/postgres/commit/a54b658c)
The configuration files pg\_hba.conf and pg\_ident.conf, as well as postgresql.conf, now support the directives to include other files: include, include\_if\_exists, include\_dir.
Columns containing the file name and rule/map number have been added to pg\_hba\_file\_rules and pg\_ident\_file\_mappings:
```
SELECT * FROM pg_hba_file_rules
WHERE file_name LIKE '%hba_ident_test.conf' \gx
```
```
-[ RECORD 1 ]---------------------------------
rule_number | 1
file_name | /home/pal/pg/hba_ident_test.conf
line_number | 1
type | local
database | {all}
user_name | {alice}
address |
netmask |
auth_method | peer
options | {map=m1}
error |
```PGSQL
SELECT * FROM pg_ident_file_mappings
WHERE file_name LIKE '%ident_test.conf' \gx
```
```
-[ RECORD 1 ]-----------------------------
map_number | 1
file_name | /home/pal/pg/ident_test.conf
line_number | 1
map_name | m1
sys_name | student
pg_username | alice
error |
```
**[Regular expressions support in pg\_hba.conf](https://commitfest.postgresql.org/40/3824/)**
commit: [8fea8683](https://github.com/postgres/postgres/commit/8fea8683), [a9039713](https://github.com/postgres/postgres/commit/a9039713), [fc579e11](https://github.com/postgres/postgres/commit/fc579e11)
pg\_hba.conf supports regular expressions for the user name and the database name. If any of these fields starts with a slash (/), then the value is considered a regular expression.
---
This is all for now. Looking forward to the results of the [January CommitFest](https://commitfest.postgresql.org/41/)! | https://habr.com/ru/post/708082/ | null | en | null |
# Первый опыт участия в kaggle-конкурсе и работа над ошибками
Хочу поделиться опытом своего первого участия в kaggle конкурсе (учебный [Bag of Words](https://www.kaggle.com/c/word2vec-nlp-tutorial)). И хотя мне не удалось достичь поражающих воображение результатов, я расскажу о том, как искала и находила способы улучшить примеры “учебника” (для этого сами примеры тоже кратко опишу), а также остановлю внимание на разборе своих просчетов. Должна предупредить, что статья будет интересна прежде всего новичкам в области text mining. Тем не менее, большинство методов я описываю кратко и упрощенно, давая при этом ссылки на более точные определения, поскольку цель моя — обзор практики, а не теории. К сожалению, конкурс уже завершился, но прочитать материалы к нему все равно может быть полезно. Ссылка на код к статье [тут](https://github.com/Jaylla/NlpKaggleTraining).
#### Обзор конкурса
Само задание состоит в анализе эмоциональной окраски текста. Для этого взяты отзывы и оценки к фильмам с сайта IMDb. Отзывы с оценкой >=7 считаются позитивно окрашенными, с оценкой меньше — негативно. Задача: обучив модель на тренировочных данных, где каждому тексту проставлена оценка (негативный/позитивный), затем предсказать этот параметр для текстов из тестового сета. Качество предсказания оценивается с помощью параметра под названием [ROC-кривая](https://ru.wikipedia.org/wiki/ROC-%D0%BA%D1%80%D0%B8%D0%B2%D0%B0%D1%8F). Подробно можно прочитать по ссылке, но чем ближе этот параметр к 1 — тем точнее предсказание.
Все примеры написаны на языке Python и используют библиотеку [scikit-learn](http://scikit-learn.org/), которая позволяет использовать готовые реализации всех нужных нам классификаторов и векторизаторов.
#### Методы решения задачи
В нашем распоряжении чистый текст, а все data mining классификаторы требуют на вход числовые векторы. Поэтому первейшая задача — определиться со способом преобразования текстового блока в вектор (векторизация).
Самый простой метод — Bag of Words, с которого начинается первый пример учебника. Метод заключается в создании общего пула используемых слов, каждому из которых присваивается свой индекс. Предположим, что у нас есть два простых текста:
> John likes to watch movies. Mary likes movies too.
>
> John also likes to watch football games.
Каждому уникальному слову поставим в соответствие индекс:
*«John»: 1,
«likes»: 2,
«to»: 3,
«watch»: 4,
«movies»: 5,
«also»: 6,
«football»: 7,
«games»: 8,
«Mary»: 9,
«too»: 10*
Теперь каждое из этих предложений можно представить в виде вектора размерности 10, в котором число x в i-ой позиции означает, что слово под номером i встречается в тексте x раз:
> [1, 2, 1, 1, 2, 0, 0, 0, 1, 1]
>
> [1, 1, 1, 1, 0, 1, 1, 1, 0, 0]
Подробнее в [википедии](https://en.wikipedia.org/wiki/Bag-of-words_model) или в этой обзорной [статье](http://habrahabr.ru/post/263171/), посвященной тому же конкурсу.
В общих чертах все просто, но дьявол в деталях. Во-первых, в примере удаляются слова *(a, the, am, i, is…)*, которые не несут никакой смысловой нагрузки. Во-вторых, операции с этой матрицей производятся в оперативной памяти, таким образом, объем памяти ограничивает допустимую размерность матрицы. Мне чтобы избежать *“MemoryError”* пришлось уменьшать пул слов до 7000 наиболее частых. В качестве классификатора во всех примерах учебника используется [Random Forest classifier](https://ru.wikipedia.org/wiki/Random_forest).
Далее нас призывают поэкспериментировать с различными параметрами, что мы и сделаем. Первое очевидная мысль — добавить [лемматизацию](https://ru.wikipedia.org/wiki/%D0%9B%D0%B5%D0%BC%D0%BC%D0%B0%D1%82%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F), т.е. привести все слова к их словарным формам. Для этого используем функцию из библиотеки nltk:
```
from nltk import WordNetLemmatizer
wnl = WordNetLemmatizer()
meaningful_words = [wnl.lemmatize(w) for w in meaningful_words]
```
Другая хорошая идея — немного поменять метод векторизации текста. Вместо простой характеристики “сколько раз слово встретилось в тексте” можно использовать чуть более сложную, но тоже хорошо известную — [tf-idf](https://ru.wikipedia.org/wiki/TF-IDF) (она присваивает словам ценность в зависимости от их редкости в коллекции документов).
Отправив на проверку результаты исходной и модифицированной программы, получаем улучшение с 0.843 до 0.844. Это не очень много. Используя этот пример как основу можно хорошенько поэкспериментировать и получить гораздо лучшие результаты. Но у меня было не так много времени, а, следовательно, и попыток (они ограничены 5-ю в день). Поэтому я приступила к следующим частям.
Следующие части учебника строятся на библиотеке под названием [Word2vec](https://code.google.com/p/word2vec/), которая дает нам представление слов в виде числового вектора. Причем эти вектора обладают интересными свойствами. Например, минимальное расстояние между векторами будет у наиболее похожих по смыслу слов.
Итак, преобразовав все слова, получаем список векторов для каждого отзыва. Как преобразовать его в единый вектор? Первый вариант — просто вычислить среднее арифметическое ([average vector](https://www.kaggle.com/c/word2vec-nlp-tutorial/details/part-3-more-fun-with-word-vectors)). Результат, даже хуже, чем Bag of Words (0.829).
Как можно было бы улучшить этот метод? Ясно, что нет смысла усреднять все слова, слишком много среди них мусора, не влияющего на эмоциональную окраску текста. Интуитивно кажется, что сильнее всего будут влиять оценочные прилагательные и, возможно, некоторые другие слова. На наше счастье, существуют методы под общим названием [feature selection](https://en.wikipedia.org/wiki/Feature_selection), которые позволяют оценить, насколько сильно тот или иной параметр (в нашем случае слово) коррелирует со значением результирующей переменной (эмоциональной окраской). Применим один из таких методов и взглянем, на выбранные слова:
```
from sklearn.feature_selection import chi2
from sklearn.feature_selection import SelectKBest
select = SelectKBest(chi2, k=50)
X_new = select.fit_transform(train_data_features, train["sentiment"])
names = count_vectorizer.get_feature_names()
selected_words = np.asarray(names)[select.get_support()]
print(', '.join(selected_words))
```
В результате получаем такой список слов, который подтверждает теорию:
> acting, amazing, annoying, avoid, awful, bad, badly, beautiful, best, boring, brilliant, crap, dull, even, excellent, fantastic, favorite, great, highly, horrible, just, lame, laughable, love, loved, mess, minutes, money, no, nothing, oh, pathetic, perfect, plot, pointless, poor, poorly, ridiculous, save, script, stupid, superb, supposed, terrible, waste, wasted, why, wonderful, worse, worst
Если теперь вычислять average vector, но учтя только слова из топ-листа (который мы после пары экспериментов расширим до 500 слов), то получим результат лучше (0.846), который обходит даже (хотя и ненамного) bag of centroids из следующего учебного примера этого конкурса. В этом решении (обозначим его как average of top words) в качестве классификатора тоже использовался Random Forest.
#### Работа над ошибками
На этом количество моих попыток, и собственно конкурс, подошли к концу, и я отправилась на форум выяснять, как решали эту задачу люди более опытные. Я не буду касаться [решений](https://www.kaggle.com/c/word2vec-nlp-tutorial/forums/t/14966/post-competition-solutions), которые получили действительно отличный результат (более 0.96) потому, что они как правило довольно сложные и многоходовые. Но укажу на некоторые варианты, которые позволили получить высокую точность простыми методами.
Например, [указание](https://www.kaggle.com/c/word2vec-nlp-tutorial/forums/t/11261/beat-the-benchmark-with-shallow-learning-0-95-lb) на то, что удалось достичь хорошего результата с помощью простого tf-idf и [логистической регрессии](https://ru.wikipedia.org/wiki/%D0%9B%D0%BE%D0%B3%D0%B8%D1%81%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F), побудило меня исследовать другие классификаторы. При прочих равных (TfidfVectorizer с ограничением в 7000 столбцов) LogisticRegression дает результат — 0.88, [LinearRegression](https://ru.wikipedia.org/wiki/%D0%9B%D0%B8%D0%BD%D0%B5%D0%B9%D0%BD%D0%B0%D1%8F_%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F) — 0.91, [Ridge regression](http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.Ridge.html) — 0.92.
Если бы я использовала линейную регрессию в своем решении (average of top words) вместо Random forest, то получила бы результат 0.93 вместо 0.84. Таким образом первая моя ошибка была в том, что я считала, что метод векторизации влияет сильнее, чем выбор классификатора. На ошибочные мысли меня натолкнул материал учебной статьи, но мне следовало все самостоятельно проверить.
Вторую идею я извлекла, внимательнее взглянув на код этого примера. Нюанс в том, как именно был использован TfidfVectorizer. Был взят сет из объединенных тестовых и тренировочных данных, не ставились ограничения на максимальное количество столбцов, более того, фичи формировались не только из отдельных слов, но и из [пар слов](https://ru.wikipedia.org/wiki/N-%D0%B3%D1%80%D0%B0%D0%BC%D0%BC) (параметр ngram\_range=(1, 2)). Если ваша программа не падает с MemoryError от такого объема, то это существенно повышает точность предсказания (автор заявил результат 0.95). Вывод номер два — точность можно повысить ценой большего объема вычислений, а не каких-то особо хитрых методов. Для этого можно, например, прибегнуть к какому-нибудь сервису для облачных вычислений, если собственный комп не слишком мощный.
В качестве заключения хочу сказать, что участвовать в конкурсе kaggle было крайне интересно, и ободрить тех, кто пока не решился по каким-либо причинам. Разумеется, на kaggle встречаются и гораздо более сложные конкурсы, для первого раза стоит выбирать задачу по силам. И последний совет — читайте форум. Даже в течение конкурса там публикуют полезные советы, идеи, а иногда даже целые решения. | https://habr.com/ru/post/263399/ | null | ru | null |
# Безопасность мобильного OAuth 2.0
Всем привет! Я Никита Ступин, специалист по информационной безопасности Почты Mail.Ru. Не так давно я провел исследование уязвимостей мобильного OAuth 2.0. Для создания безопасной схемы мобильного OAuth 2.0 мало реализовать стандарт в чистом виде и проверять redirect\_uri. Необходимо учитывать специфику мобильных приложений и применять дополнительные механизмы защиты.
В этой статье я хочу поделиться с вами знаниями об атаках на мобильный OAuth 2.0, о методах защиты и безопасной реализации этого протокола. Все необходимые компоненты защиты, о которых я расскажу ниже, реализованы в последней версии SDK для мобильных клиентов Почты Mail.Ru.
Природа и функция OAuth 2.0
===========================
OAuth 2.0 — это протокол авторизации, который описывает, как сервису-клиенту безопасно получить доступ к ресурсам пользователя на сервисе-провайдере. При этом OAuth 2.0 избавляет пользователя от необходимости вводить пароль за пределами сервиса-провайдера: весь процесс сводится к нажатию кнопки «Согласен предоставить доступ к ...».
Провайдер в терминах OAuth 2.0 — это сервис, который владеет данными пользователя и, с разрешения пользователя, предоставляет сторонним сервисам (клиентам) безопасный доступ к этим данным. Клиент — это приложение, которое хочет получить данные пользователя, находящиеся у провайдера.
Через некоторое время после релиза протокола OAuth 2.0 обычные разработчики приспособили его для аутентификации, хотя изначально он для этого не предназначался. Аутентификация смещает вектор атаки с данных пользователя, которые хранятся у сервиса-провайдера, на аккаунты пользователей сервиса-клиента.
Одной лишь аутентификацией дело не ограничилось. В эру мобильных приложений и превознесения конверсии вход в приложение при помощи одной кнопки стал очень заманчивым. Разработчики поставили OAuth 2.0 на мобильные рельсы. Естественно, мало кто задумывался о безопасности и специфике мобильных приложений: раз-раз, и в продакшн. Впрочем, OAuth 2.0 вообще плохо работает за пределами веб-приложений: одни и те же проблемы наблюдаются и в мобильных, и в десктопных приложениях.
Давайте разберемся, как же всё-таки сделать безопасный мобильный OAuth 2.0.
Как оно работает?
=================
Помните, что на мобильных устройствах в роли клиента может выступать не браузер, а мобильное приложение без бэкенда. Поэтому мы сталкиваемся с двумя основными проблемами безопасности мобильного OAuth 2.0:
1. Клиент не является доверенным.
2. Поведение редиректа из браузера в мобильное приложение зависит от настроек и приложений, которые установил пользователь.
#### Мобильное приложение — это публичный клиент
Чтобы понять корни первой проблемы, давайте посмотрим, как работает OAuth 2.0 в случае взаимодействия server-to-server, а затем сравним его с OAuth 2.0 в случае взаимодействия client-to-server.
В обоих случаях всё начинается с того, что сервис-клиент регистрируется у сервиса-провайдера и получает `client_id` и, в некоторых случаях, `client_secret`. Значение `client_id` является публичным и необходимо для идентификации сервиса-клиента, в отличие от `client_secret`, значение которого является приватным. Более подробно процесс регистрации описан в [RFC 7591](https://tools.ietf.org/html/rfc7591).
На схеме ниже показана работа OAuth 2.0 при взаимодействии server-to-server.
*Картинка взята из <https://tools.ietf.org/html/rfc6749#section-1.2>*
Можно выделить 3 основных этапа протокола OAuth 2.0:
1. [шаги A-C] Получить Authorization Code (далее просто `code`).
2. [шаги D-E] Обменять `code` на `access_token`.
3. Получить доступ к ресурсу с помощью `access_token`.
Разберем получение code подробнее:
1. [Шаг A] Сервис-клиент перенаправляет пользователя на сервис-провайдер.
2. [Шаг B] Сервис-провайдер запрашивает у пользователя разрешение на предоставление данных сервису-клиенту (стрелка B вверх). Пользователь предоставляет доступ к данным (стрелка B вправо).
3. [Шаг C] Сервис-провайдер возвращает `code` браузеру пользователя, а тот перенаправляет `code` сервису-клиенту.
Разберем получение `access_token` подробнее:
1. [Шаг D] Сервер клиента отправляет запрос на получение `access_token`. В запрос включаются: `code`, `client_secret` и `redirect_uri`.
2. [Шаг E] В случае валидных `code`, `client_secret` и `redirect_uri` предоставляется `access_token`.
Запрос за `access_token` выполняется по схеме server-to-server, поэтому в общем случае для похищения `client_secret` злоумышленник должен взломать сервер сервиса-клиента или сервер сервиса-провайдера.
Теперь посмотрим, как выглядит схема OAuth 2.0 на мобильном устройстве без бэкенда (взаимодействие client-to-server).
*Картинка взята из <https://tools.ietf.org/html/rfc8252#section-4.1>*
Общая схема разбивается на те же 3 основных шага:
1. [шаги 1-4 на картинке] Получить `code`.
2. [шаги 5-6 на картинке] Обменять `code` на `access_token`.
3. Получить доступ к ресурсу с помощью `access_token`.
Однако в данном случае мобильное приложение также выполняет функции сервера, а значит `client_secret` будет зашит внутри приложения. Это приводит к тому, что на мобильных устройствах невозможно сохранить `сlient_secret` в тайне от злоумышленника. Достать `client_secret`, зашитый в приложение, можно двумя способами: проснифать трафик от приложения к серверу или выполнить обратный инжиниринг приложения. Оба способа легко осуществимы, поэтому `client_secret` бесполезен на мобильных устройствах.
Относительно схемы client-to-server у вас мог возникнуть вопрос: «а почему бы сразу не получить `access_token`?». Казалось бы, зачем нам лишний шаг? Более того, существует схема [Implicit Grant](https://tools.ietf.org/html/rfc6749#section-4.2), при которой клиент сразу получает `access_token`. И хотя в некоторых случаях её использовать можно, ниже мы увидим, что для безопасного мобильного OAuth 2.0 схема [Implicit Grant](https://tools.ietf.org/html/rfc6749#section-4.2) не подходит.
#### Редирект на мобильных устройствах
В общем случае, для редиректа из браузера в приложение на мобильных устройствах используются механизмы [Custom URI Scheme](https://developer.apple.com/documentation/uikit/core_app/allowing_apps_and_websites_to_link_to_your_content/communicating_with_other_apps_using_custom_urls) и [AppLink](https://developer.android.com/training/app-links/verify-site-associations). Ни один из этих механизмов в чистом виде не является столь же надежным, как браузерный редирект.
Custom URI Scheme (или deep link) используется следующим образом: разработчик перед сборкой определяет схему приложения. Схема может быть произвольной, при этом на одном устройстве может быть установлено несколько приложений с одинаковой схемой. Всё довольно просто, когда на устройстве каждой схеме соответствует одно приложение. А что если два приложения зарегистрировали одинаковую схему на одном устройстве? Как операционной системе определить, какое из двух приложений открыть при обращении по Custom URI Scheme? Android покажет окно с выбором приложения, в котором нужно открыть ссылку. В iOS [поведение не определено](https://developer.apple.com/library/archive/documentation/iPhone/Conceptual/iPhoneOSProgrammingGuide/Inter-AppCommunication/Inter-AppCommunication.html#//apple_ref/doc/uid/TP40007072-CH6-SW7), а значит может быть открыто любое из двух приложений. В обоих случаях у злоумышленника появляется [возможность перехватить code или access\_token](https://habr.com/company/mailru/blog/417031#1).
AppLink, в противоположность Custom URI Scheme, позволяет гарантированно открыть нужное приложение, но у этого механизма есть ряд недостатков:
1. Каждый сервис-клиент должен самостоятельно проходить [процедуру верификации](https://developer.android.com/training/app-links/verify-site-associations).
2. Пользователи Android могут выключить AppLink для конкретного приложения в настройках.
3. Android ниже 6.0 и iOS ниже 9.0 не поддерживают AppLink.
Вышеуказанные недостатки AppLink, во-первых, повышают порог вхождения для потенциальных сервисов-клиентов, а во-вторых, могут привести к тому, что при определенных обстоятельствах у пользователя не будет работать OAuth 2.0. Это делает механизм AppLink непригодным для замены браузерным редиректам в протоколе OAuth 2.0.
Ладно, что атаковать?
=====================
Проблемы мобильного OAuth 2.0 породили и специфические атаки. Давайте разберемся, что они собой представляют и как работают.
#### Authorization Code Interception Attack
Исходные данные: на устройстве пользователя установлено легитимное приложение (клиент OAuth 2.0) и зловредное приложение, которое зарегистрировало ту же схему, что и легитимное. На рисунке ниже приведена схема атаки.
*Картинка взята из <https://tools.ietf.org/html/rfc7636#section-1>*
Проблема здесь вот в чем: на шаге 4 браузер возвращает `code` в приложение через Custom URI Scheme, поэтому `code` может быть перехвачен зловредом (потому что он зарегистрировал ту же схему, что и легитимное приложение). После этого зловред меняет `code` на `access_token` и получает доступ к данным пользователя.
Как защититься? В некоторых случаях можно использовать механизмы межпроцессного взаимодействия, о них мы поговорим ниже. В общем же случае необходимо применять схему, которая называется [Proof Key for Code Exchange](https://tools.ietf.org/html/rfc7636). Суть ее отражена на схеме ниже.
*Картинка взята из <https://tools.ietf.org/html/rfc7636#section-1.1>*
В запросах от клиента есть несколько дополнительных параметров: `code_verifier`, `code_challenge` (на схеме `t(code_verifier)`) и `code_challenge_method` (на схеме `t_m`).
`Code_verifier` — это случайное число [длиной минимум 256 бит](https://tools.ietf.org/html/rfc7636#section-7.1), которое [используется только один раз](https://ru.wikipedia.org/wiki/Nonce). То есть для **каждого** запроса на получение `code` клиент должен генерировать новый `code_verifier`.
`Code_challenge_method` — это название функции преобразования, чаще всего SHA-256.
`Code_challenge` — это `code_verifier`, к которому применили преобразование `code_challenge_method` и закодировали в URL Safe Base64.
Преобразование `code_verifier` в `code_challenge` необходимо, чтобы защититься от векторов атак, основанных на перехвате `code_verifier` (например, из системных логов устройства) при запросе `code`.
В случае, если устройство пользователя **не поддерживает** SHA-256, то [допустим даунгрейд до отсутствия преобразования code\_verifier](https://tools.ietf.org/html/rfc7636#section-4.2). Во всех остальных случаях необходимо использовать SHA-256.
Работает схема следующим образом:
1. Клиент генерирует `code_verifier` и запоминает его.
2. Клиент выбирает `code_challenge_method` и получает `code_challenge` из `code_verifier`.
3. [Шаг А] Клиент запрашивает `code`, причем в запрос добавляется `code_challenge` и `code_challenge_method`.
4. [Шаг Б] Провайдер запоминает `code_challenge` и `code_challenge_method` на сервере и возвращает `code` клиенту.
5. [Шаг C] Клиент запрашивает `access_token`, причем в запрос добавляется `code_verifier`.
6. Провайдер получает `code_challenge` из пришедшего `code_verifier`, а затем сверяет его с `code_challenge`, который он запомнил.
7. [Шаг D] Если значения совпадают, то провайдер выдает клиенту `access_token`.
Давайте разберемся, почему `code_challenge` позволяет защититься от атаки перехвата кода. Для этого пройдем по этапам получения `access_token`.
1. Сначала легитимное приложение запрашивает `code` (вместе с **запросом** пересылается `code_challenge` и `code_challenge_method`).
2. Зловред перехватывает `code` (но не `code_challenge`, потому что **в ответе** `code_challenge` отсутствует).
3. Зловред запрашивает `access_token` (с валидным `code`, но **без** валидного `code_verifier`).
4. Сервер замечает несоответствие `code_challenge` и выдает ошибку.
Заметьте, что у злоумышленника нет возможности угадать `code_verifier` (рандомные 256 бит!) или найти его где-то в логах (`code_verifier` передается один раз).
Если свести всё это в одну фразу, то `code_challenge` позволяет ответить сервису-провайдеру на вопрос: «`access_token` запрашивается тем же приложением-клиентом, которое запросило `code`, или другим?».
#### OAuth 2.0 CSRF
На мобильных устройствах OAuth 2.0 зачастую используется в качестве механизма аутентификации. Как мы помним, аутентификация через OAuth 2.0 отличается от авторизации тем, что уязвимости OAuth 2.0 затрагивают данные пользователя на стороне сервиса-клиента, а не сервиса-провайдера. В результате CSRF-атака на OAuth 2.0 позволяет украсть чужой аккаунт.
Рассмотрим CSRF-атаку применительно к OAuth 2.0 на примере приложения-клиента taxi и провайдера provider.com. Сначала злоумышленник на своем устройстве входит в аккаунт `attacker@provider.com` и получает `code` для taxi. После этого злоумышленник прерывает процесс OAuth 2.0 и генерирует ссылку:
`com.taxi.app://oauth?
code=b57b236c9bcd2a61fcd627b69ae2d7a6eb5bc13f2dc25311348ee08df43bc0c4`
Затем злоумышленник отправляет ссылку жертве, например, под видом письма или SMS от администрации taxi. Жертва переходит по ссылке, на её телефоне открывается приложение taxi, которое получает `access_token`, и в результате жертва попадает в taxi-аккаунт **злоумышленника**. Не ведая подвоха, жертва пользуется этим аккаунтом: совершает поездки, вводит свои данные и т.д.
Теперь злоумышленник может в любое время зайти в taxi-аккаунт жертвы, потому что он привязан к `attacker@provider.com`. CSRF-атака на логин позволила украсть аккаунт.
От CSRF-атак обычно защищаются с помощью CSRF-токена (также его называют `state`), и OAuth 2.0 не исключение. Как использовать CSRF-токен:
1. Приложение-клиент генерирует и сохраняет CSRF-токен на мобильном устройстве пользователя.
2. Приложение-клиент включает CSRF-токен в запрос на получение `code`.
3. Сервер возвращает в ответе вместе с code тот же самый CSRF-токен.
4. Приложение-клиент сравнивает пришедший и сохраненный CSRF-токен. Если значения совпадают, то процесс продолжается дальше.
Требования к CSRF-токену: [nonce](https://ru.wikipedia.org/wiki/Nonce) длиной минимум 256 бит, полученный из хорошего источника псевдослучайных последовательностей.
Если коротко, то CSRF-токен позволяет приложению-клиенту ответить на вопрос: «это я начал получение `access_token`, или кто-то пытается меня обмануть?».
#### Зловред, притворяющийся легитимным клиентом
Некоторые зловреды могут мимикрировать под легитимные приложения и поднимать consent screen от их имени (consent screen — это экран, на котором пользователь видит: «Согласен предоставить доступ к ...»). Невнимательный пользователь может нажать «разрешить», и в результате зловред получает доступ к данным пользователя.
Android и iOS предоставляют механизмы взаимной проверки приложений. Приложение-провайдер может убедиться в легитимности приложения-клиента, и наоборот.
К сожалению, если механизм OAuth 2.0 использует поток через браузер, то защититься от этой атаки нельзя.
#### Другие атаки
Мы рассмотрели атаки, которые присущи исключительно мобильному OAuth 2.0. Однако не стоит забывать про атаки на обычный OAuth 2.0: подмена `redirect_uri`, перехват трафика по незащищенному соединению и т.д. Подробнее про них вы можете почитать [тут](https://sakurity.com/oauth).
Что делать-то?
==============
Мы узнали, как работает протокол OAuth 2.0, и разобрались, какие уязвимости существуют в реализациях этого протокола на мобильных устройствах. Давайте теперь из отдельных кусочков соберем безопасную схему мобильного OAuth 2.0.
#### Хороший, плохой OAuth 2.0
Начнем с того, как правильно поднимать consent screen. На мобильных устройствах существует два способа открыть веб-страницу из нативного приложения (примеры нативных приложений: Почта Mail.Ru, VK, Facebook).
Первый способ называется Browser Custom Tab (на картинке слева). **Примечание**: Browser Custom Tab на Android называется Chrome Custom Tab, а на iOS SafariViewController. По сути, это обычная вкладка браузера, которая отображается прямо в приложении, т.е. не происходит визуального переключения между приложениями.
Второй способ называется «поднять WebView» (на картинке справа), применительно к мобильному OAuth 2.0 я считаю его плохим.
WebView — это обособленный браузер для нативного приложения.
«*Обособленный браузер*» означает, что для WebView запрещен доступ к кукам, хранилищу, кешу, истории и другим данным браузеров Safari и Chrome. Обратное утверждение тоже верно: Safari и Chrome не могут получить доступ к данным WebView.
«*Браузер для нативного приложения*» означает, что нативное приложение, которое подняло WebView, имеет **полный** доступ к кукам, хранилищу, кешу, истории и другим данным WebView.
А теперь представьте: пользователь нажимает кнопку «войти с помощью ...» и WebView зловредного приложения запрашивает у него логин и пароль от сервиса-провайдера.
Провал сразу по всем фронтам:
1. Пользователь вводит логин и пароль от аккаунта сервиса-провайдера в приложении, которое легко может похитить эти данные.
2. OAuth 2.0 изначально разрабатывался для того, чтобы *не вводить логин и пароль* от сервиса-провайдера.
3. Пользователь привыкает вводить логин и пароль где попало, увеличивается вероятность [фишинга](https://ru.wikipedia.org/wiki/%D0%A4%D0%B8%D1%88%D0%B8%D0%BD%D0%B3).
Учитывая, что все аргументы против WebView, вывод напрашивается сам: поднимайте Browser Custom Tab для consent screen.
Если у кого-то из вас есть аргументы в пользу WebView вместо Browser Custom Tab, напишите об этом в комментариях, я буду очень благодарен.
#### Безопасная схема мобильного OAuth 2.0
Мы будем использовать схему Authorization Code Grant, потому что она позволяет добавить `code_challenge` и защититься от атаки перехвата кода.
*Картинка взята из <https://tools.ietf.org/html/rfc8252#section-4.1>*
Запрос на получение code (шаги 1-2) будет выглядеть следующим образом:
`https://o2.mail.ru/code?
redirect_uri=com.mail.cloud.app%3A%2F%2Foauth&
anti_csrf=927489cb2fcdb32e302713f6a720397868b71dd2128c734181983f367d622c24& code_challenge=ZjYxNzQ4ZjI4YjdkNWRmZjg4MWQ1N2FkZjQzNGVkODE1YTRhNjViNjJjMGY5MGJjNzdiOGEzMDU2ZjE3NGFiYw%3D%3D&
code_challenge_method=S256&
scope=email%2Cid&
response_type=code&
client_id=984a644ec3b56d32b0404777e1eb73390c`
На шаге 3 браузер получает ответ с редиректом:
`com.mail.cloud.app://oаuth?
code=b57b236c9bcd2a61fcd627b69ae2d7a6eb5bc13f2dc25311348ee08df43bc0c4&
anti_csrf=927489cb2fcdb32e302713f6a720397868b71dd2128c734181983f367d622c24`
На шаге 4 браузер открывает Custom URI Scheme и передает `code` и CSRF-токен в клиентское приложение.
Запрос на получение `access_token` (шаг 5):
`https://o2.mail.ru/token?
code_verifier=e61748f28b7d5daf881d571df434ed815a4a65b62c0f90bc77b8a3056f174abc&
code=b57b236c9bcd2a61fcd627b69ae2d7a6eb5bc13f2dc25311348ee08df43bc0c4&
client_id=984a644ec3b56d32b0404777e1eb73390c`
На последнем шаге возвращается ответ с `access_token`.
В общем случае вышеприведённая схема является безопасной, но существуют и частные случаи, в которых OAuth 2.0 можно сделать проще и чуть-чуть безопаснее.
#### Android IPC
В Android существует механизм двустороннего обмена данными между процессами: IPC (inter-process communication). IPC предпочтительнее Custom URI Scheme по двум причинам:
1. Приложение, которое открывает IPC-канал, может проверить подлинность открываемого приложения по его сертификату. Верно и обратное: открытое приложение может проверить подлинность приложения, которое его открыло.
2. Отправив запрос через IPC-канал, отправитель может получить ответ через этот же канал. Вкупе со взаимной проверкой (п.1) это означает, что никакой сторонний процесс не сможет перехватить `access_token`.
Таким образом, мы можем использовать [Implicit Grant](https://tools.ietf.org/html/rfc6749#section-4.2) и значительно упростить схему мобильного OAuth 2.0. Никаких `code_challenge` и CSRF-токенов. Более того, мы сможем защититься от зловредов, которые мимикрируют под валидные клиенты с целью кражи аккаунтов пользователя.
#### SDK для клиентов
Помимо реализации безопасной схемы мобильного OAuth 2.0, приведенной выше, провайдеру следует разработать SDK для своих клиентов. Это облегчит внедрение OAuth 2.0 на стороне клиента и одновременно сократит количество ошибок и уязвимостей.
Делаем выводы
=============
Для провайдеров OAuth 2.0 я составил «Чеклист безопасного мобильного OAuth 2.0»:
1. Прочный фундамент жизненно важен. В случае с мобильным OAuth 2.0 фундаментом является схема или протокол, который мы выберем для реализации. При [реализации собственной схемы OAuth 2.0](https://hackerone.com/reports/314814) легко ошибиться. Другие уже набили шишки и сделали выводы, нет ничего зазорного в том, чтобы учиться на их ошибках и сразу сделать безопасную реализацию. В общем случае самой безопасной схемой мобильного OAuth 2.0 является схема из раздела «Что делать-то?».
2. `Access_token` и другие чувствительные данные храните: под iOS — в Keychain, под Android — в Internal Storage. Эти хранилища специально разработаны для таких целей. В случае необходимости в Android можно использовать Content Provider, но его нужно безопасно настроить.
3. `Code` должен быть одноразовый, с коротким временем жизни.
4. Для защиты от перехвата code используйте `code_challenge`.
5. Для защиты от CSRF-атаки на логин используйте CSRF-токены.
6. Не используйте WebView для consent screen, используйте Browser Custom Tab.
7. `Client_secret` **бесполезен**, если он не хранится на бэкенде. Не выдавайте его публичным клиентам.
8. Используйте HTTPS **везде**, с запретом даунгрейда до HTTP.
9. Следуйте рекомендациям по криптографии (выбор шифра, длина токена и т.д.) **из стандартов**. Можете скопировать данные и разобраться, почему сделано именно так, но [делать свою криптографию нельзя](https://2017.zeronights.org/wp-content/uploads/materials/ZN17_Karim_Valiev_StopCrypto.pdf).
10. Со стороны приложения-клиента проверяйте, кого вы открываете для OAuth 2.0, а со стороны приложения-провайдера проверяйте, кто вас открывает для OAuth 2.0.
11. Помните об [обычных уязвимостях OAuth 2.0](https://sakurity.com/oauth). Мобильный OAuth 2.0 расширяет и дополняет обычный, поэтому никто не отменял проверку `redirect_uri` на точное совпадение и прочие рекомендации для обычного OAuth 2.0.
12. Обязательно предоставляйте клиентам SDK. У клиента будет меньше ошибок и уязвимостей в коде, и ему будет проще внедрить ваш OAuth 2.0.
Что почитать
============
1. [RFC] OAuth 2.0 for Native Apps <https://tools.ietf.org/html/rfc8252>
2. Google OAuth 2.0 for Mobile & Desktop Apps <https://developers.google.com/identity/protocols/OAuth2InstalledApp>
3. [RFC] Proof Key for Code Exchange by OAuth Public Clients <https://tools.ietf.org/html/rfc7636>
4. OAuth 2.0 Race Condition <https://hackerone.com/reports/55140>
5. [RFC] OAuth 2.0 Threat Model and Security Considerations <https://tools.ietf.org/html/rfc6819>
6. Атаки на обычный OAuth 2.0 <https://sakurity.com/oauth>
7. [RFC] OAuth 2.0 Dynamic Client Registration Protocol <https://tools.ietf.org/html/rfc7591>
Благодарности
=============
Спасибо всем, кто помог написать эту статью, особенно Сергею Белову, Андрею Сумину, Андрею Лабунцу ([@isciurus](https://twitter.com/isciurus)) и Дарье Яковлевой. | https://habr.com/ru/post/417031/ | null | ru | null |
# Получение участников сообщества vk.com за считанные секунды
Ни для кого не секрет, что VK API возвращает за один запрос к методу [**groups.getMembers**](http://vk.com/dev/groups.getMembers) не более 1 000 участников. В одну секунду вы можете получить максимум 3 000 участников, так как установлено ограничение на количество запросов в секунду до 3. Эту проблему решает метод [**execute**](http://vk.com/dev/execute), с помощью которого вы можете получить более 100 000 участников за одну секунду и до 25 000 участников за один запрос. В этой статье я расскажу Вам, как я это реализовал.
Без использования метода [**execute**](http://vk.com/dev/execute), процесс получения участников группы с аудиторией в 4 000 000 человек займет примерно около 22 минут, и нам нужно будет выполнить около 4 000 запросов к API. С помощью метода [**execute**](http://vk.com/dev/execute) мы ускорим этот процесс примерно до 40 секунд и выполним всего около 160 запросов.
Содержание:
* [I. Немного о execute](#tag1)
* [II. Реализация на javascript](#tag2)
* [Исходники и примеры](#tag3)
I. Немного о execute
====================
Это универсальный метод, который позволяет запускать последовательность других методов, сохраняя и фильтруя промежуточные результаты.
Делается обычный запрос как и на все другие методы, но в параметрах нужно передать **code** написанный на **VKScript**.
#### Что поддерживает VKScript и что это?
Это язык похожий на JavaSсript или ActionScript. Алгоритм должен завершаться командой return %выражение%. Операторы должны быть разделены точкой с запятой.
Поддерживаются:
* арифметические операции
* логические операции
* создание массивов и списков ([X,Y])
* parseInt и parseDouble
* конкатенация (+)
* конструкция if
* фильтр массива по параметру (@.)
* вызовы методов API, параметр length
* циклы, используя оператор while
* методы Javascript: slice, push, pop, shift, unshift, splice, substr
* оператор delete
* присваивания элементам массива, например: row.user.action = «test»;
С помощью этого метода, мы можем получить результат нескольких методов за один запрос API.
II. Реализация на javascript
============================
Пишем простую функцию которая рекурсий будет дергать процедуру описанную ниже execute.getMembers.
```
getMembers(group_id);
```
Чтобы получить участников группы мы будем использовать **execute**, за один запрос мы получим 25 000 участников. **Execute** позволяет сделать до 25 запросов описанных с помощью языка **VKScript**. В параметре **code** нам нужно передать алгоритм на языке **VKScript**.
Создана процедура getMembers, которую мы будем дергать с клиента 3 раза в секунду.
```
var members = API.groups.getMembers({"group_id": Args.group_id, "v": "5.27", "sort": "id_asc", "count": "1000", "offset": Args.offset}).items; // делаем первый запрос и создаем массив
var offset = 1000; // это сдвиг по участникам группы
while (offset < 25000 && (offset + Args.offset) < Args.total_count) // пока не получили 20000 и не прошлись по всем участникам
{
members = members + "," + API.groups.getMembers({"group_id": Args.group_id, "v": "5.27", "sort": "id_asc", "count": "1000", "offset": (Args.offset + offset)}).items; // сдвиг участников на offset + мощность массива
offset = offset + 1000; // увеличиваем сдвиг на 1000
};
return members;
```
Исходники и примеры
===================
На случай если лежит VK, то выглядело так:
Пример работы: <http://vk.com/app4236781>
Исходники: [github.com/romkagolovadvayha/getmembersVKAPI.git](https://github.com/romkagolovadvayha/getmembersVKAPI.git) | https://habr.com/ru/post/248725/ | null | ru | null |
# Вопросы совместимости Tibero и Oracle. Часть 1. Условная компиляция PL/SQL
Условная компиляция PL/SQL позволяет избирательно компилировать участки исходного кода в зависимости от условия, как правило связанного со значением пакетной константы. Часто это используется для обеспечения совместимости приложений с разными версиями СУБД.
В декабре 2017 года такая возможность появилась и в Tibero, что позволило обеспечить ещё б**о**льшую совместимость приложений между Tibero и Oracle.
В качестве примера, возьмем пакет для объявления и связывания исключений с кодами системных ошибок. В Tibero коды системных ошибок отличаются от Oracle.
В первую очередь, надо использовать стандартные исключения из пакета SYS.STANDARD, как например NO\_DATA\_FOUND. С ними проблем совместимости не возникнет. Для остальных, используемых в вашем приложении исключений рекомендуется создать отдельный пакет.
В этом пакете у пользовательских исключений с кодами ошибок от -20999 до -20000 тоже все в порядке — как в Tibero, так и в Oracle. В остальных случаях, если планируется использовать это приложение для работы как с Oracle, так и с Tibero, можно воспользоваться условной компиляцией.
Для начала, нам понадобится пакет с константой для определения с какой СУБД мы работаем:
```
create or replace package tmax_ConstPkg is
c_isTibero constant boolean := false;
end tmax_ConstPkg;
```
Теперь можно писать связывание исключений в зависимости от СУБД:
```
create or replace package tmax_ErrPkg is
e_object_not_exists exception;
pragma exception_init(e_object_not_exists,
$if tmax_Constpkg.c_isTibero $THEN
-7071
$ELSE
-4043
$END
);
--
e_compilation_error exception;
pragma exception_init(e_compilation_error,
$IF tmax_Constpkg.c_isTibero $THEN
-15163
$ELSE
-06550
$END
);
end tmax_ErrPkg;
```
Если пакет для объявления и связывания исключений в вашем приложении для Oracle уже используется, то вам остается получить (опытным путем) соответствующий код ошибки в Tibero и добавить его с помощью условной компиляции.
В случае, если объявление и связывание исключений рассыпано бисером по всему коду вашего приложения, то это не повод для паники.
Мы решили воспользоваться замечательной возможностью для анализа PL/SQL кода с помощью PL/Scope. Приводить весь код утилиты здесь нецелесообразно, он доступен на [Oracle2Tibero\_Tools](https://github.com/VasiliyFloka/Oracle2Tibero_Tools). Утилита представляет собой несколько PL/SQL пакетов, два из которых уже были рассмотрены выше. Проще всего будет ими пользоваться, если вы установите эти пакеты в схему вашего приложения вместе с анализируемыми PL/SQL объектами.
Т.к. для анализа кода используется PL/Scope, то необходимо скомпилировать ваши PL/SQL объекты в режиме поиска идентификаторов, например:
```
SQL> ALTER SESSION SET plscope_settings='IDENTIFIERS:ALL';
SQL> alter procedure p1 compile;
```
Для перекомиляции **всех** PL/SQL объектов в режиме поиска идентификаторов, достаточно выполнить:
```
SQL> exec tmax_check4migrate.recompile4plscope
```
Теперь можно запустить утилиту следующим образом:
```
SQL> set serveroutput on
SQL> exec tmax_check4migrate.run
```
Будут выведены сообщения о всех проблемных исключениях с предложениями использования либо стандартных исключений, либо заготовок объявления и связывания исключений с кодами ошибок в Oracle для пакета Tmax\_ErrPkg:
```
1. Exception LONG_TEXT(PACKAGE BODY HR.TEST line 2528) init with error code -6502(line 2529)
...replace it to VALUE_ERROR Reference list
1) PACKAGE BODY HR.TEST line(s) 2570,2615
3. Exception E_MONTH_ERR(PACKAGE BODY HR.TEST line 6128) init with error code -1843(line 6129) Reference list
1) PACKAGE BODY HR.TEST line(s) 6198
...
...You need to use conditional compilation to define different system error codes for Tibero and Oracle Following error codes did not find in Tmax_ErrPkg package, need to add:
/* ORA-01843: not a valid month */
------------------------------
e_not_a_valid_month exception;
pragma exception_init(e_not_a_valid_month,
$if tmax_Constpkg.c_isTibero $THEN
-?????
$ELSE
-1843
$END
);
```
Кстати это будет полезно хотя бы для консолидации всех исключений в один пакет. Сразу предупрежу, что кроме проверки исключений, утилита решает ряд других вопросов совместимости, о которых мы поговорим в следующих частях. Поэтому на этом этапе, в основной процедуре Run, вы можете закомментировать вызовы других проверок — процедур с префиксом Chk\_ .
После того, как вы добавите все заготовки исключений в пакет Tmax\_ErrPkg, можно запустить утилиту в режиме исправлений:
```
SQL> set serveroutput on
SQL> exec tmax_check4migrate.run(p_modify => true)
```
Старые объявления и связывания будут закомментированы и вместо них в коде будут использоваться либо стандартные исключения, либо исключения из пакета Tmax\_ErrPkg.
Теперь, что касается Tibero. На момент написания статьи условная компиляция еще не вошла в стандартную сборку, доступную на сайте [technet.tmaxsoft.com](http://technet.tmaxsoft.com). Проверить поддержку условной компиляции на вашем экземпляре Tibero можно либо попробовав установить требуемые параметры инициализации:
```
_PSM_PREPROCESS=Y
_PSM_PREPROCESS_SELECTION=Y
```
Либо можно проверить SQL запросом, что такие скрытые параметры есть:
```
SQL> select NAME,VALUE from sys._vt_parameter where name like '_PSM_PREPROCESS%';
```
Версию Tibero, поддерживающую условную компиляцию вы можете запросить в российском представительстве компании TmaxSoft.
В следующих публикациях мы рассмотрим некоторые отличия синтаксиса Tibero и Oracle, с которыми вы можете встретиться, а также как избежать связанных с этим исправлений вручную. | https://habr.com/ru/post/350530/ | null | ru | null |
# Unrestricted File Upload at Apple.com
Внимание — это фривольный перевод заметки о том, как именно [Jonathan Bouman](https://protozoan.nl) нашёл публичный AWS S3, который использовался на одном из поддоменнов apple.com. Плюс заметка хороша тем, что наглядно демонстрирует пользу от нескольких маленьких утилит в совокупности с терпением.
Возьмите кофе и запустите [Aquatone](https://github.com/michenriksen/aquatone/). Эта утилита может обнаружить поддомены в заданном домене используя открытые источники и метод грубой силы со словарём.
Aquatone имеет четыре различные команды:
1. Aquatone-discover — ищет различные поддомены
2. Aquatone-scan — сканирует результат п.1. на открытые порты
3. Aquatone-gather — создаёт скриншоты каждого сабдомена, собирая все результаты в html-отчёт
4. Aquatone-takeover — пытается найти неактивные поддомены, которые хостятся внешними хостерами. Нашёл один? Иди регистрируй и получай свою награду!
Report output of Aquatone
Сидим, ждём, мечтаем.
Обычно нужно несколько минут на поиск, скан и сбор.
А на Apple.com? Это заняло 30 минут, 84 отчёта, 18к уникальных хостов.
Мы первые кто использует aquatone для скана apple.com? Определённо нет. Читали ли другие люди все 84 страницы? Определённо нет.
Так что начнём со страницы 50 и прочтём лишь последние 34 страницы.
**Поиск аномалий в шаблонах**
После 50 минут чтения отчётов замечен шаблон. Один из них в том, что apple.com иногда использует AWS S3 для хранения файлов, используемых их поддоменами. Так что, если можно получить доступ на запись на один из S3 — можно обеспечить доступ на один из поддоменов apple.com.
Чтение всех 84х отчётов — скука. Все отчёты содержат http-заголовки, отправляемые сервером. S3 — всегда отправляет заголовок X-Amz-Bucket-Region. Поиск этого заголовка в отчётах:
Теперь каждый вручную нужно прокликать, чтобы увидеть, что будет, если открыть урлу. Почти все поддомены отдают Access denied.
Кроме одного: [live-promotions.apple.com](http://live-promotions.apple.com)
S3 response, containing the bucket name and directory contents.
Итак, теперь есть имя S3 бакета. Это позволяет напрямую коннектиться к нему
Как получить доступ, [смотрите здесь](https://docs.aws.amazon.com/cli/latest/reference/s3/).
Нужно установить Command Line Interface of AWS и можно пробовать открыть этот бакет используя имя из ответа выше
После этого можно пытаться загрузить фейковую страницу входа и открывать её в браузере.
```
aws s3 cp login.html s3://$bucketName --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers
```
алерт кук
**Заключение**
Был получен полный доступ на чтение/запись на S3 бакет Apple, который доступен на одном из их поддоменов. Достаточно для залития фишингового сайта или воровства кук.
**Решение**
Никогда не предоставлять анонимам права на чтение/запись
К счастью защита S3 довольно проста и настроена по дефолту
см. доку: [docs.aws.amazon.com/AmazonS3/latest/dev/access-control-overview.html](https://docs.aws.amazon.com/AmazonS3/latest/dev/access-control-overview.html)
**Что это было:**
— Загружена фишинговая страница на live-promotions.apple.com
— Можно было красть кукисы посетителей
— Можно было стянуть конфиденциальные файлы из бакета (он содержал проекты на xcode)
**Зал славы**
Спустя 4 часа я получил ответ от Apple, подтверждающий баг. В тот же день он был исправлен и теперь он упомянут в [зале славы](https://support.apple.com/en-is/HT201536)
**Письмо + скрин из зала**
**Timeline**
19–06–2018 Discovered and reported bug
19–06–2018 Apple confirmed the bug
19–06–2018 Apple fixed the bug
22–06–2018 Apple mentioned me in the Hall of Fame
22–06–2018 Published this blog | https://habr.com/ru/post/415003/ | null | ru | null |
# Строгая типизация для приложений Vue.js на TypeScript
> **Вопрос**: Каковы самые слабые места Vue?
>
>
>
> **Oтвет**: На данный момент, наверное, недружественность к типизации. Наш API разрабатывался без планирования поддержки типизированных языков (типа TypeScript), но мы сделали большие улучшения в 2.5.
>
>
>
> **Вопрос**: Тони Хор (Tony Hoare) назвал null ошибкой на миллиард долларов. Какое было самое неудачное техническое решение в твоей карьере?
>
>
>
> **Oтвет**: Было бы неплохо использовать TypeScript изначально, еще когда я начал переписывать код для Vue 2.x.
>
>
>
> *из интервью ["Создатель Vue.js отвечает Хабру"](https://habrahabr.ru/post/350290/)*
Недружественность Vue.js к типизации вынуждает применять "костыли", чтобы использовать преимущества TypeScript. Один из предлагаемых в официальной документации Vue.js вариантов — это применение декораторов вместе с библиотекой "vue-class-component".
Я применяю другой вариант "костылей" для решения проблемы строгой типизации в приложениях Vue.js (без декораторов и vue-class-component). Через явное определение интерфейсов для опций "data" и "props", используемых в конструкторе экземпляров Vue-компоненты. В ряде случаев это проще и удобнее.
В данном tutorial, для иллюстрации обоих подходов к типизации (с декораторами и без) используется решение Visual Studio 2017 с приложениями Vue.js + Asp.Net Core MVC + TypeScript. Хотя приведенные здесь примеры можно поместить и в другое окружение (Node.js + Webpack).
Попутно демонстрируется, как компоненту на JavaScript быстро переделать под «полноценный» TypeScript с включенной строгой типизацией.
**Содержание**
[Введение](#intro)
[Используемые механизмы](#theory)
[— Включение опций строгой типизации](#theory1)
[— Типизация через декораторы](#theory2)
[— Типизация через интерфейсы входных и выходных данных](#theory3)
[Проект TryVueMvcDecorator](#TryVueMvcDecorator)
[— Тестовое приложение](#TryVueMvcDecorator1)
[— Корректировка конфигурации](#TryVueMvcDecorator2)
[— Корректировка Index.cshtml](#TryVueMvcDecorator3)
[— Переход на декораторы](#TryVueMvcDecorator4)
[— Сборка и запуск проекта](#TryVueMvcDecorator5)
[Проект TryVueMvcGrid](#TryVueMvcGrid)
[— Тестовое приложение](#TryVueMvcGrid1)
[— Создание заготовки AppGrid](#TryVueMvcGrid2)
[— Сборка и запуск проекта](#TryVueMvcGrid3)
[— Адаптация под строгую типизацию](#TryVueMvcGrid4)
[Заключение](#conclusion)
Введение
=========
Данная статья является продолжением серии статей:
* [Приложение Vue.js + Asp.NETCore + TypeScript без Webpack](https://habrahabr.ru/post/349880/)
* [RequireJS для приложений Vue.js + Asp.NETCore + TypeScript](https://habrahabr.ru/post/350056/)
* [Vue.js + Asp.Net Core MVC + TypeScript и ещё Bootstrap4](https://habrahabr.ru/post/350332/)
В примерах, которые приводились в этих статьях, TypeScript использовался только наполовину — строгая типизация была сознательно отключена. Теперь попробуем перейти к полноценному использованию TypeScript.
На широких просторах Интернета можно найти массу качественных примеров и готовых приложений, использующих Vue.js. Но подавляющее большинство этих примеров написано на JavaScript. Поэтому заталкивание этих примеров в "прокрустово ложе" TypeScript требует некоторых усилий.
API, который предлагается в [официальной документации Vue.js](https://ru.vuejs.org/v2/guide/typescript.html#%D0%9A%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82%D1%8B-Vue-%D0%BD%D0%B0-%D0%BE%D1%81%D0%BD%D0%BE%D0%B2%D0%B5-%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%BE%D0%B2), позволяет определить Vue-компоненту на основе классов при помощи официально поддерживаемого декоратора [vue-class-component](https://github.com/vuejs/vue-class-component). Использование декораторов требует установки опции компилятора `{"experimentalDecorators": true}`, что несколько напрягает (есть вероятность существенных изменений в будущих версиях TypeScript). Кроме того, требуется использовать дополнительную библиотеку.
Параноидальное стремление избавляться от "лишних" библиотек привело меня к использованию явного определения интерфейсов для свойств и данных Vue-компонент при решении проблемы строгой типизации в приложениях Vue.js + TypeScript.
В данном tutorial сначала опишем механизмы использования обоих вариантов "костылей", затем создадим 2 проекта: TryVueMvcDecorator, TryVueMvcGrid.
Используемые механизмы
=======================
Если исходный код Vue-компонеты, который загоняем в модуль TypeScript, написан на JavaScript, то сначала можно попытаться его откомпилировать, просто отключив все опции компилятора, отвечающие за контроль (по умолчанию они отключены). Затем в работающем коде приложения "закручиваем гайки", путем включения нужных опций с устранением причин ругани компилятора TypeScript.
После включения ряда опций компилятора код Vue-компонент может перестать компилироваться. Т.к. отсутствует явное определение переменных, перечисленных в "data" и "props". Ниже опишем способ решения этой проблемы при помощи декораторов и без них.
Включение опций строгой типизации
----------------------------------
Опция `{"strict": true}` сразу включает множество проверок (noImplicitAny, noImplicitThis, alwaysStrict, strictNullChecks, strictFunctionTypes, strictPropertyInitialization), поэтому бывает полезно включать эти проверки последовательно. Затем можно дополнительно ужесточить контроль, например, включив проверку на наличие неиспользуемых переменных и параметров.
**скрытый текст фрагмента tsconfig.json**
```
{
"compilerOptions": {
...
"experimentalDecorators": true,
//"noImplicitAny": true,
//"noImplicitThis": true,
//"alwaysStrict": true,
//"strictNullChecks": true,
//"strictFunctionTypes": true,
//"strictPropertyInitialization": true,
"strict": true,
"noUnusedLocals": true,
"noUnusedParameters": true
},
"include": [
"./ClientApp/**/*.ts"
]
}
```
Постепенное ужесточение контроля компилятора TypeScript ("закручивание гаек") позволяет достаточно быстро включить строгую типизацию, не особенно вникая в логику работы Vue-компоненты.
Типизация через декораторы
---------------------------
Определение Vue-компоненты выглядит похожим на определение класса, но на самом деле — это вызов функции `Vue.extend()`, которая создает и регистрирует экземпляр объекта `Vue` с определенными свойствами и методами. Так как определение свойств и методов задаются в параметре вызова функции `Vue.extend()`, то компилятор TypeScript не всё о них знает.
В приведенном примере подразумевается, что у экземпляра Vue есть свойства: name, initialEnthusiasm, enthusiasm, а также методы: increment(), decrement(), exclamationMarks(). Естественно, компилятор TypeScript может начать ругаться благим матом при попытке включить соответствующие опции контроля типов.
Декоратор vue-class-component позволяет использовать определение Vue-компоненты в виде полноценного класса. Соответственно, появляется возможность определения всех свойств и методов Vue-компоненты в явном виде. А такое компилятор TypeScript вполне нормально переваривает.
**скрытый текст фрагмента Hello.ts**
```
// Исходный текст определения Vue-компоненты
export default Vue.extend({
template:'#hello-template',
props: ['name', 'initialEnthusiasm'],
data() {
return {
enthusiasm: this.initialEnthusiasm
}
},
methods: {
increment() { this.enthusiasm++; },
decrement() {
if (this.enthusiasm > 1) {
this.enthusiasm--;
}
}
},
computed: {
exclamationMarks(): string {
return Array(this.enthusiasm + 1).join('!');
}
}
});
```
```
// Текст определения Vue-компоненты с использованием декоратора
@Component({
template: '#hello-template',
props: ['name', 'initialEnthusiasm']
})
export default class HelloComponent extends Vue {
enthusiasm!: number;
initialEnthusiasm!: number;
data() {
return {
enthusiasm: this.initialEnthusiasm
}
};
// methods:
increment() { this.enthusiasm++; };
decrement() {
if (this.enthusiasm > 1) {
this.enthusiasm--;
}
};
// computed:
get exclamationMarks() {
return Array(this.enthusiasm + 1).join('!');
}
};
```
Типизация через интерфейсы входных и выходных данных
-----------------------------------------------------
Применение строгой типизации через определение интерфейсов для свойств и данных основано на следующем моменте: у экземпляров `Vue` есть соответствующие прокси (`this.$props, this.$data`).
> **vm.$data**
>
>
>
> Объект с данными, над которым экземпляр Vue осуществляет наблюдение. Экземпляр проксирует сюда вызовы своих полей. (Например, vm.a будет указывать на vm.$data.a)
>
>
>
> **vm.$props**
>
>
>
> Объект, предоставляющий доступ к текущим входным данным компонента. Экземпляр Vue проксирует доступ к свойствам своего объекта входных данных.
>
>
>
> Подробнее смотрите в [официальной документации](https://ru.vuejs.org/v2/api/index.html#vm-data).
Благодаря этому, в приведенном примере для Vue-компоненты получаем: `this.initialEnthusiasm` эквивалентно `this.$props.initialEnthusiasm`, а также `this.enthusiasm` эквивалентно `this.$data.enthusiasm`. Остается в явном виде определить интерфейсы для свойств и данных, а также обеспечить явное приведение типов при использовании `this.$props, this.$data`.
```
// Пример явного определения интерфейсов
interface HelloProps {
name: string;
initialEnthusiasm: number;
}
interface HelloData {
enthusiasm: number;
}
// Примеры приведения типов при использовании свойств экземпляра Vue
...
enthusiasm = (this.$props as HelloProps).initialEnthusiasm;
...
var thisData = this.$data as HelloData;
if (thisData.enthusiasm > 1) {
thisData.enthusiasm--;
}
...
```
Для лучшего понимания применяемого здесь подхода приводим более сложный пример использования интерфейсов для строгой типизации:
**скрытый текст фрагмента DemoGrid.ts**
```
// Фрагмент ClientApp/components/DemoGrid.ts
interface DemoGridProps {
rows: Array;
columns: Array;
filterKey: string;
}
interface DemoGridData {
sortKey: string;
sortOrders: { [index: string]: number };
}
export default Vue.extend({
...
computed: {
filteredData: function () {
var thisData = (this.$data as DemoGridData);
var thisProps = (this.$props as DemoGridProps);
var sortKey = thisData.sortKey;
var filterKey = thisProps.filterKey && thisProps.filterKey.toLowerCase();
var order = thisData.sortOrders[sortKey] || 1;
var rows = thisProps.rows;
if (filterKey) {
rows = rows.filter(function (row) {
return Object.keys(row).some(function (key) {
return String(row[key]).toLowerCase().indexOf(filterKey) > -1
})
})
}
if (sortKey) {
rows = rows.slice().sort(function (a, b) {
a = a[sortKey]
b = b[sortKey]
return (a === b ? 0 : a > b ? 1 : -1) \* order
})
}
return rows;
}
},
...
methods: {
sortBy: function (key: string) {
var thisData = (this.$data as DemoGridData);
thisData.sortKey = key
thisData.sortOrders[key] = thisData.sortOrders[key] \* -1
}
}
});
```
В результате получаем простой способ перехода к строгой типизации — после явного определения интерфейсов свойств и данных, тупо ищем `this.someProperty` и применяем в этих местах явное приведение типов. Например, `this.columns` превратится в `(this.$props as DemoGridProps).columns`.
Проект TryVueMvcDecorator
==========================
В данном разделе tutorial создаем приложение Vue.js на TypeScript с вариантом решения проблемы строгой типизации при помощи декторатора "vue-class-component".
Тестовое приложение
--------------------
В качестве отправной точки для тестового приложения берём на github проект [TryVueMvc](https://github.com/schavelev/starter-vue-mvc/tree/master/TryVueMvc) для Visual Studio 2017. Либо создаем этот проект "с нуля" по предыдущему tutorial [Vue.js + Asp.Net Core MVC + TypeScript и ещё Bootstrap4](https://habrahabr.ru/post/350332/). Сборку и запуск проекта можно произвести в среде VS2017 либо через командную строку в каталоге проекта:
```
npm install
dotnet build
dotnet bundle
dotnet run
```
В браузере открываем страницу, адрес которой dotnet сообщает в консоли, например, <http://localhost:52643>.
Для предпочитающих однофайловые Vue-компонеты и сборку при помощи Webpack, в качестве отправной точки для тестового приложения можно использовать проект [TryVueWebpack](https://github.com/schavelev/starter-vue/tree/master/TryVueWebpack). Для сборки и запуска приложения, через командную строку в каталоге проекта выполняем следующее:
```
npm install
npm run build
```
Далее можно также воспользоваться `dotnet run`, а можно просто открыть файл wwwroot\index.html.
Корректировка конфигурации
---------------------------
В файле tsconfig.json добавить опцию компилятора `{"experimentalDecorators": true}`.
Добавляем в файл package.json установку NPM-пакета "vue-class-component".
**скрытый текст package.json**
```
{
"version": "1.0.0",
"name": "asp.net",
"private": true,
"dependencies": {
"jquery": "^3.3.1",
"popper.js": "^1.12.9",
"bootstrap": "^4.0.0",
"vue": "^2.5.13",
"systemjs": "^0.21.0",
"vue-class-component": "^6.2.0"
}
}
```
Корректируем bundleconfig.json для обеспечения возможности копирования vue.js и vue-class-component.js из каталога node\_modules в wwwroot/vendor.
**скрытый текст bundleconfig.json**
```
[
{
"outputFileName": "wwwroot/dist/vendor1.js",
"inputFiles": [
"node_modules/jquery/dist/jquery.js",
"node_modules/popper.js/dist/umd/popper.js",
"node_modules/bootstrap/dist/js/bootstrap.js",
"node_modules/systemjs/dist/system.src.js"
],
"minify": {
"enabled": true,
"renameLocals": true
},
"sourceMap": true
},
{
"outputFileName": "wwwroot/dist/vendor1.css",
"inputFiles": [
"node_modules/bootstrap/dist/css/bootstrap.css"
],
"minify": {
"enabled": false
}
},
{
"outputFileName": "wwwroot/dist/vendor1.min.css",
"inputFiles": [
"node_modules/bootstrap/dist/css/bootstrap.min.css"
],
"minify": {
"enabled": false
}
},
{
"outputFileName": "wwwroot/vendor/vue.js",
"inputFiles": [
"node_modules/vue/dist/vue.js"
],
"minify": {
"enabled": true,
"renameLocals": true
},
"sourceMap": true
},
{
"outputFileName": "wwwroot/vendor/vue-class-component.js",
"inputFiles": [
"node_modules/vue-class-component/dist/vue-class-component.js"
],
"minify": {
"enabled": true,
"renameLocals": true
},
"sourceMap": true
},
{
"outputFileName": "wwwroot/dist/main.css",
"inputFiles": [
"ClientApp/**/*.css"
],
"minify": {
"enabled": true
}
},
{
"outputFileName": "wwwroot/dist/app-bandle.min.js",
"inputFiles": [
"wwwroot/dist/app-bandle.js"
],
"minify": {
"enabled": true,
"renameLocals": true
}
},
{
"outputFileName": "wwwroot/dist/app-templates.html",
"inputFiles": [
"ClientApp/**/*.html"
],
"minify": {
"enabled": false,
"renameLocals": false
}
}
]
```
Корректировка Index.cshtml
---------------------------
Так как у нас появилось использование vue-class-component, необходимо сообщить SystemJS откуда грузить эту библиотеку. Для этого модифицируем код Razor-рендеринга в Views/Home/Index.cshtml.
**скрытый текст Views/Home/Index.cshtml**
```
@* Views/Home/Index.cshtml *@
@using Microsoft.AspNetCore.Hosting
@inject IHostingEnvironment hostingEnv
@{
var suffix = hostingEnv.IsDevelopment() ? "" : ".min";
var vueUrl = $"vendor/vue{suffix}.js";
var vueClassComponentUrl = $"vendor/vue-class-component{suffix}.js";
var mainUrl = $"dist/app-bandle{suffix}.js";
ViewData["Title"] = "TryVueMvc Sample";
}
loading..
@section Scripts{
System.config({
map: {
"vue": "@vueUrl",
"vue-class-component": "@vueClassComponentUrl"
}
});
$.get("dist/app-templates.html").done(function (data) {
$('#app-templates').append(data);
SystemJS.import('@mainUrl').then(function (m) {
SystemJS.import('index');
});
});
}
```
Переход на декораторы
----------------------
Для перехода на декораторы в нашем приложении достаточно поменять код модулей AppHello.ts и Hello.ts.
**скрытый текст ClientApp/components/AppHello.ts**
```
// ClientApp/components/AppHello.ts
import Vue from "vue";
import Component from "vue-class-component";
import HelloComponent from "./Hello";
@Component({
template: '#app-hello-template',
components: {
HelloComponent
}
})
export default class AppHelloComponent extends Vue {
data() {
return {
name: "World"
}
}
};
```
**скрытый текст ClientApp/components/Hello.ts**
```
// ClientApp/components/Hello.ts
import Vue from "vue";
import Component from "vue-class-component";
@Component({
template: '#hello-template',
props: ['name', 'initialEnthusiasm']
})
export default class HelloComponent extends Vue {
enthusiasm!: number;
initialEnthusiasm!: number;
data() {
return {
enthusiasm: this.initialEnthusiasm
}
};
// methods:
increment() { this.enthusiasm++; };
decrement() {
if (this.enthusiasm > 1) {
this.enthusiasm--;
}
};
// computed:
get exclamationMarks() {
return Array(this.enthusiasm + 1).join('!');
}
};
```
Если в качестве отправной точки использовался проект TryVueWebpack, то код модулей AppHello.ts и Hello.ts будет немного отличаться.
**скрытый текст ClientApp/components/AppHello.ts**
```
// ClientApp/components/AppHello.ts
import Vue from "vue";
import Component from "vue-class-component";
import HelloComponent from "./Hello.vue";
@Component({
components: {
HelloComponent
}
})
export default class AppHelloComponent extends Vue {
data() {
return {
name: "World"
}
}
};
```
**скрытый текст ClientApp/components/Hello.ts**
```
// ClientApp/components/Hello.ts
import Vue from "vue";
import Component from "vue-class-component";
@Component({
props: ['name', 'initialEnthusiasm']
})
export default class HelloComponent extends Vue {
enthusiasm!: number;
initialEnthusiasm!: number;
data() {
return {
enthusiasm: this.initialEnthusiasm
}
};
// methods:
increment() { this.enthusiasm++; };
decrement() {
if (this.enthusiasm > 1) {
this.enthusiasm--;
}
};
// computed:
get exclamationMarks() {
return Array(this.enthusiasm + 1).join('!');
}
};
```
Сборка и запуск проекта
------------------------
Сборка и запуск приложения — традиционные для среды VS2017. Бандлинг производится через команду "Bundler&Minifier\Update Bundles" контексного меню на файле bundleconfig.json. Также сборку и запуск можно произвести через командную строку в каталоге проекта. Должны получить что-то подобное изображенному на скриншоте.
**скрытый скриншот AppHello**
Свой результат выполнения описанных действий можете сравнить с проектом [TryVueMvcDecorator](https://github.com/schavelev/starter-vue-mvc/tree/master/TryVueMvcDecorator) на github.
Проект TryVueMvcGrid
=====================
Теперь создаем приложение Vue.js на TypeScript с вариантом решения проблемы строгой типизации путем явного определения типов для входных (this.$props) и выходных (this.$data) данных Vue-компоненты. На этот раз обходимся без декоратора и дополнительной библиотеки.
Приложение немного усложним, встроив в него пример с официального сайта Vue.js [Grid Component Example](https://vuejs.org/v2/examples/grid-component.html). Можете посмотреть этот же пример на [jsfiddle](http://jsfiddle.net/yyx990803/23qze30k/).
Идем от простого к сложному. Для облегчения понимания разобьём создание AppGrid на четыре этапа:
* подготовка тестового приложения (клонирование TryVueMvc);
* создание скелета приложения AppGrid;
* перенос основного исходного кода примера с официального сайта Vue.js;
* включение опций строго типизации с адаптацией кода приложения.
Тестовое приложение
--------------------
В качестве отправной точки для тестового приложения, также, как и в предыдущем случае, берём на github проект [TryVueMvc](https://github.com/schavelev/starter-vue-mvc/tree/master/TryVueMvc) для Visual Studio 2017.
Создание заготовки AppGrid
---------------------------
Заменяем приложение AppHello на заготовку (скелет) приложения AppGrid. Для этого меняем содержимое файла ClientApp/index.ts, а вместо старых файлов в папке ClientApp/components создаем заготовки новых компонент: AppGrid, DemoGrid.
**скрытый текст ClientApp/index.ts**
```
// ClientApp/index.ts
import Vue from "vue";
import AppGrid from "./components/AppGrid";
new Vue({
el: "#app-root",
render: h => h(AppGrid),
components: {
AppGrid
}
});
```
**скрытый текст ClientApp/AppGrid**
```
// ClientApp/components/AppGrid.ts
import Vue from "vue";
import DemoGrid from "./DemoGrid";
export default Vue.extend({
template: '#app-grid-template',
components: {
DemoGrid
},
data: function () {
return {
foo: 42
}
}
});
```
```
AppGrid component
-----------------
```
**скрытый текст ClientApp/DemoGrid**
```
// ClientApp/components/DemoGrid.ts
import Vue from "vue";
export default Vue.extend({
template: '#demo-grid-template',
props: ['foo'],
data: function () {
return {
bar: 42
}
}
});
```
```
#### DemoGrid component
```
После пересборки и запуска приложения в браузере должно получиться что-то подобное изображенному на скриншоте.
**скрытый скриншот AppGrid**
Встраивание примера DemoGrid
-----------------------------
Переносим код AppGrid.ts и содержимое шаблона. Производим замену возвращаемого свойства `'gridData' -> 'gridRows'`, чтобы не путать с `data()`. Компиляция ts-кода должна пройти нормально даже после включения опций контроля типов, т.к. здесь строгая типизация не требуется.
**скрытый текст ClientApp/AppGrid**
```
// ClientApp/components/AppGrid.ts
import Vue from "vue";
import DemoGrid from "./DemoGrid";
export default Vue.extend({
template: '#app-grid-template',
components: {
DemoGrid
},
data: function() {
return {
searchQuery: '',
gridColumns: ['name', 'power'],
gridRows: [
{ name: 'Chuck Norris', power: Infinity },
{ name: 'Bruce Lee', power: 9000 },
{ name: 'Jackie Chan', power: 7000 },
{ name: 'Jet Li', power: 8000 }
]
}
}
});
```
```
Search
```
Переносим код DemoGrid.ts и содержимое шаблона. Производим замену входного свойства `'data' -> 'rows'`, чтобы не путать с `data()`. Определение свойств Vue-компоненты переделываем в массив имен (`props: ['rows', 'columns', 'filterKey']`).
**скрытый текст ClientApp/DemoGrid**
```
// ClientApp/components/DemoGrid.ts
import Vue from "vue";
export default Vue.extend({
template: '#demo-grid-template',
props: ['rows', 'columns', 'filterKey'],
data: function () {
var sortOrders = {}
this.columns.forEach(function (key) {
sortOrders[key] = 1
})
return {
sortKey: '',
sortOrders: sortOrders
}
},
computed: {
filteredData: function () {
var sortKey = this.sortKey
var filterKey = this.filterKey && this.filterKey.toLowerCase()
var order = this.sortOrders[sortKey] || 1
var rows = this.rows
if (filterKey) {
rows = rows.filter(function (row) {
return Object.keys(row).some(function (key) {
return String(row[key]).toLowerCase().indexOf(filterKey) > -1
})
})
}
if (sortKey) {
rows = rows.slice().sort(function (a, b) {
a = a[sortKey]
b = b[sortKey]
return (a === b ? 0 : a > b ? 1 : -1) * order
})
}
return rows
}
},
filters: {
capitalize: function (str) {
return str.charAt(0).toUpperCase() + str.slice(1)
}
},
methods: {
sortBy: function (key) {
this.sortKey = key
this.sortOrders[key] = this.sortOrders[key] * -1
}
}
});
```
```
|
{{ key | capitalize }}
|
| --- |
|
{{entry[key]}}
|
```
Создаем файл ClientApp/css/demo-grid.css на основе стилей компоненты DemoGrid.
**скрытый ClientApp/css/demo-grid.css**
```
/* ClientApp/css/demo-grid.css */
body {
font-family: Helvetica Neue, Arial, sans-serif;
font-size: 14px;
color: #444;
}
table {
border: 2px solid #42b983;
border-radius: 3px;
background-color: #fff;
margin-top: .5rem;
}
th {
background-color: #42b983;
color: rgba(255,255,255,0.66);
cursor: pointer;
-webkit-user-select: none;
-moz-user-select: none;
-ms-user-select: none;
user-select: none;
}
td {
background-color: #f9f9f9;
}
th, td {
min-width: 120px;
padding: 10px 20px;
}
th.active {
color: #fff;
}
th.active .arrow {
opacity: 1;
}
.arrow {
display: inline-block;
vertical-align: middle;
width: 0;
height: 0;
margin-left: 5px;
opacity: 0.66;
}
.arrow.asc {
border-left: 4px solid transparent;
border-right: 4px solid transparent;
border-bottom: 4px solid #fff;
}
.arrow.dsc {
border-left: 4px solid transparent;
border-right: 4px solid transparent;
border-top: 4px solid #fff;
}
```
Сборка и запуск проекта
------------------------
Сборка и запуск приложения производится также, как и для проекта TryVueMvcDecorator, описанного ранее. После пересборки и запуска приложения в браузере должно получиться что-то подобное изображенному на скриншоте.
**скрытый скриншот AppGrid**
Адаптация под строгую типизацию
--------------------------------
Теперь начинаем закручивать гайки. Если попробовать сразу поставить опцию компилятора `{"strict": true}`, то получим кучу ошибок TypeScript при компиляции.
Как правило, включать контроль лучше поэтапно: включаем одну опцию, устраняем возникшие ошибки, затем делаем тоже самое для следующей опции и т.д.
Для адаптации существующего кода Vue-компоненты под строгую типизацию, в первую очерередь, определяем интерфейсы для входных (props) и выходных данных (data) компоненты.
```
interface DemoGridProps {
rows: Array;
columns: Array;
filterKey: string;
}
interface DemoGridData {
sortKey: string;
sortOrders: { [index: string]: number };
}
```
Затем ставим опцию компилятора `{"noImplicitThis": true}` и устраняем ошибки способом, описанным ранее в пункте [Типизация через интерфейсы входных и выходных данных](#theory3).
После установки опции компилятора `{"noImplicitAny": true}` разбираемся с остальными неопределенными типами. После этого включение `{"strict": true}` уже ошибок не дает (для нашего примера). Результат адаптации модуля DemoGrid.ts приведен под спойлером.
**скрытый текст ClientApp/DemoGrid.ts**
```
// ClientApp/components/DemoGrid.ts
import Vue from "vue";
interface DemoGridProps {
rows: Array;
columns: Array;
filterKey: string;
}
interface DemoGridData {
sortKey: string;
sortOrders: { [index: string]: number };
}
export default Vue.extend({
template: '#demo-grid-template',
props: ['rows', 'columns', 'filterKey'],
//props: { rows: Array, columns: Array, filterKey: String },
data: function () {
var sortOrders: any = {};
(this.$props as DemoGridProps).columns.forEach(function (key) {
sortOrders[key] = 1
})
return {
sortKey: '',
sortOrders: sortOrders
} as DemoGridData
},
computed: {
filteredData: function () {
var thisData = (this.$data as DemoGridData);
var thisProps = (this.$props as DemoGridProps);
var sortKey = thisData.sortKey
var filterKey = thisProps.filterKey && thisProps.filterKey.toLowerCase()
var order = thisData.sortOrders[sortKey] || 1
var rows = thisProps.rows
if (filterKey) {
rows = rows.filter(function (row) {
return Object.keys(row).some(function (key) {
return String(row[key]).toLowerCase().indexOf(filterKey) > -1
})
})
}
if (sortKey) {
rows = rows.slice().sort(function (a, b) {
a = a[sortKey]
b = b[sortKey]
return (a === b ? 0 : a > b ? 1 : -1) \* order
})
}
return rows
}
},
filters: {
capitalize: function (str: string) {
return str.charAt(0).toUpperCase() + str.slice(1)
}
},
methods: {
sortBy: function (key: string) {
var thisData = (this.$data as DemoGridData);
thisData.sortKey = key
thisData.sortOrders[key] = thisData.sortOrders[key] \* -1
}
}
});
```
Свой результат выполнения описанных действий можете сравнить с проектом [TryVueMvcGrid](https://github.com/schavelev/starter-vue-mvc/tree/master/TryVueMvcGrid) на github.
Заключение
===========
У способа определения Vue-компонент через декоратор есть свои преимущества и недостатки. Один из недостатков — необходимость реструктуризации кода, когда работающий пример написан на JavaScript. Что требует большей аккуратности.
Вариант строгой типизации через явное определение интерфейсов для опций "data" и "props", позволяет меньше включать мозги на этапе переноса JavaScript-кода Vue-компонент.
Кроме того, интерфейсы дают возможность повторного использования определений типов для входных и выходных данных Vue-компонент. Ведь тип входных данных одной компоненты часто совпадает с выходными данными другой.
**Благодарности**
* Заглавные цитаты взяты из статьи на Хабре: ["Создатель Vue.js отвечает Хабру"](https://habrahabr.ru/post/350290/)
* Фото кота с костылем взято [здесь](https://www.tapetus.pl/65064,kotek-inwalida.php).
* При создании примеров частично использовался: ["TypeScript Vue Starter"](https://github.com/Microsoft/TypeScript-Vue-Starter#typescript-vue-starter).
* При создании примеров использовался: ["Grid Component Example"](https://vuejs.org/v2/examples/grid-component.html).
**Update 05.06.2019:**
На данный момент исходный код примеров на на [github](https://github.com/schavelev/starter-vue-mvc) немного отличается от приведенного в статье. Изменения вызваны обновлением версий используемых компонент (переход на Asp.NETCore 2.2 и т.д.). | https://habr.com/ru/post/351216/ | null | ru | null |
# Сейчас как заавтоматизирую
Итак, Вам надоело набирать пароли, писать команды, смотреть на скучные обои? А хочется завоевать вселенную и почивать на лаврах? Заставьте роботов трудиться вместо cебя!
#### Собираем робота
Для тренировки терпимости и лояльности, учитель Йода разрешил нам зайти на все 1000 серверов Имперского комитета по разведению Эвоков в условиях невесомости по SSH, вбить руками логин и пароль и проверить кто создал и размер файла /tmp/yoda\_is\_awesome.txt
Пишем скрипт который будет набирать пароли и команды за нас. Из предустановленных/легко доставляемых на unix/linux присутствуют: Bash/Shell, Perl, Python.
Для задачи с SSH в Bash/Perl/Python есть более специализированные модули/программы. А ведь завтра учитель Йода попросит сделать тоже через Telnet, потом sudo echo “Yoda is superman!”. Рассмотрим более общий Expect в связке с Bash, модуль «Expect.pm» для Perl, модуль «pexpect» для Python.
Листинг скриптов в конце.
Начинаем медитировать на бегущие строчки:
```
$ ./sshauto.sh|pl|py 'ls -l /tmp/yoda_is_awesome.txt'
```
Output:
```
Password:
pavlo@10.10.10.10's password:
-rw-r--r-- 1 root root 56 Jul 19 2006 /tmp/yoda_is_awesome.txt
pavlo@20.20.20.20's password:
-rw-r--r-- 1 root root 56 Jul 19 2006 /tmp/yoda_is_awesome.txt
pavlo@30.30.30.30's password:
-rw-r--r-- 1 root root 56 Jul 19 2006 /tmp/yoda_is_awesome.txt
<дальше поглотила бездна>
```
Медитация закончена. Доделываем напильником «grep» по вкусу.
#### Изучаем чужих роботов
**Public key**. Разложить на все 1000 серверов «SSH Public key» для своего пользователя. Это трудоемко, и при других условиях (иной пользователь, необходимость использовать sudo,.. .) может оказаться бесполезным.
**cssh (Cluster SSH)**. Открывает консоли по количеству серверов, и одно дополнительное окошко для выполнения команд на всех серверах одновременно. Хорошее решение для 3 серверов, но не для 1000.
**sshpass**. Передача пароля для ssh в открытом виде на STDIN не поддерживается. Но есть например sshpass: `sshpass -p 'PASSWORD' ssh pavlo@10.10.10.10 'ls -l /tmp/temp\_file.txt'` который решает эту проблему, но не поможет если потребуется дополнительное sudo или смена пользователя.
**Микроскопы**. (CFEngine, Puppet, свой вариант). При условии что он стоит везде. Ему можно и такую задачу поручить. Но это уже не целевое использование, «Забивать гвозди микроскопом».
#### Темная сторона
Ни одно из перечисленных решений не встречалось мне работающим из коробки при обычной установке операционной системы. Для каждого из них требуется установка хотя бы одного пакета.
#### Захват галактики
Здесь приводиться примеры реализации/использования «Expect» на Bash, Perl, Python.
Требования к скрипту:
a. ip\_addresses.txt — файл со списком всех IP адресов.
b. пароль должен вводиться при старте скрипта в скрытом виде.
**BASH**
Требуется установка: expect
```
$ cat ./sshauto.sh
#!/bin/bash
echo -n "Password:"
read -s passw; echo
stty echo
while read IP
do
./sshlogin.exp $passw $IP "$1" 2> /dev/null
done < ip_addresses.txt
$ cat ./sshlogin.exp
#!/usr/bin/expect -f
set password [lrange $argv 0 0]
set ip_address [lrange $argv 1 1]
set command [lindex $argv 2]
spawn ssh -q -t -o StrictHostKeyChecking=no pavlo@$ip_address $command
expect "*?assword:*"
send -- "$password\r"
expect eof
```
**PERL**
Требуется установка модулей: Expect, Term::ReadKey
```
$ cat ./sshauto.pl
#!/usr/bin/perl
use Expect;
use Term::ReadKey;
print "Password:";
ReadMode 'noecho';
$password = ReadLine(0);
chomp($password);
print "\n";
ReadMode 'normal';
$command = $ARGV[0];
open (IP_list, 'ip_addresses.txt');
foreach $IP () {
chomp($IP);
$cli = "/usr/bin/ssh -q -t -o StrictHostKeyChecking=no et0362\@$IP $command";
$exp = new Expect;
$exp->raw\_pty(1);
$exp->spawn($cli) or die "Cannot spawn $cli: $!\n";
$exp->expect(5, [ qr /ssword:\*/ => sub { my $exph = shift; $exph->send("$password\n"); exp\_continue; }] );
};
close (IP\_list);
```
**Python**
Требуется установка модуля: pexpect
```
$ cat ./sshauto.py
#!/usr/bin/python
import pexpect
import getpass
import sys
command = sys.argv[1]
password = getpass.getpass()
IP_list = open('ip_addresses.txt')
IP = IP_list.readline()
while IP:
print IP,
cli="ssh pavlo@%s %s" % (IP,command)
exp = pexpect.spawn(cli)
exp.expect('password:')
exp.sendline(password)
exp.expect(pexpect.EOF)
print exp.before
IP = IP_list.readline()
IP_list.close()
```
Ну вот и всё. Удачных Вам свершений на ниве автоматизации.
\*В статье использовалась картинка [отсюда](http://pricoles.ru/?p=1752) | https://habr.com/ru/post/131835/ | null | ru | null |
# Обмен сообщениями → PubSub внутри OTP
[OTP](https://en.wikipedia.org/wiki/Open_Telecom_Platform) расшифровывается как *Open Telecom Platform*; так исторически сложилось, потому что платформа создавалась для нужд и на деньги *Ericsson*. Но, в принципе, это название имеет примерно столько же коннотаций с ее функциональностью, сколько и яблоки со среднего качества телефонами.
Основной отличительной характеристикой *OTP* по замыслу авторов является отказоустойчивость. Не многопоточность, не модель акторов, не богатые возможности pattern matching’а, даже не прозрачная кластеризация и не hot code upgrades. Отказоустойчивость.
Виртуальная машина эрланга на поверхностный взгляд устроена очень просто: есть куча «процессов» (не системных процессов, эрланг-процессов) с изолированной памятью, которые могут обмениваться сообщениями. Все. Вот, что говорил Джо Армстронг по этому поводу:
> In my blog I argued that processes should behave pretty much like people. People have private memories and exchange data by message passing.
>
> — [Why I don't like shared memory](http://armstrongonsoftware.blogspot.com/2006/09/why-i-dont-like-shared-memory.html)
Обмен сообщениями внутри OTP очень прост: один процесс посылает сообщение другому (или группе других процессов), синхронно, или асинхронно. Но для этого необходимо знать, кому эти сообщения посылать. То есть менеджером обмена выступает отправитель. Но что если мы хотим просто слать broadcast и дать возможность всем заинтересованным процессам подписаться на это сообщение?
Да, это обычный PubSub, но из коробки в OTP он не реализован. Ну да не беда, все кирпичики для того, чтобы за часик воплотить его на коленке у нас есть. Приступим.
### Варианты реализации
В принципе, *Elixir* включает модуль [`Registry`](https://hexdocs.pm/elixir/master/Registry.html), который может быть использован как [scaffold для pubsub](https://hexdocs.pm/elixir/master/Registry.html#module-using-as-a-pubsub). Немного домотканного кода, аккуратный присмотр за всеми участниками (супервизор для каждого), — и все готово. Единственная проблема — `Registry` локален и не умеет в кластеризацию. То есть в распределенной среде (distributed nodes) эта красота работать не будет.
На нашу удачу, есть и распределенная реализация [`Phoenix.PubSub`](https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.html), которая поставляется с двумя готовыми реализациями: [`Phoenix.PubSub.PG2`](https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.PG2.html#content) и [`Phoenix.PubSub.Redis`](https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.html#module-direct-usage). Ну, `Redis` — это явно лишнее звено в нашей цепочке, а вот `PG2`, работающий поверх эрланговских групп процессов [`pg2`](http://erlang.org/doc/man/pg2.html) — самое оно. Тоже, правда, без boilerplate не обойдется.
Итак, у нас есть все, чтобы наладить удобные *PubSub* подписки в нашем приложении. Пора открывать текстовый редактор? — Не совсем. Я не люблю дублировать код из проекта в проект и все, что я могу вычленить в библиотеку — обособляется для повторного использования.
### Envío
Таким образом родился пакет [`Envío`](https://hexdocs.pm/envio). Поскольку, болтовня, как известно, гроша выломанного не сто́ит, начнем с примеров использования.
#### Локальная рассылка → `Registry`
```
defmodule MyApp.Sub do
use Envio.Subscriber, channels: [{MyApp.Pub, :main}]
def handle_envio(message, state) do
# optionally call the default implementation
{:noreply, state} = super(message, state)
# handle it!
IO.inspect({message, state}, label: "Received")
# respond with `{:noreply, state}` as by contract
{:noreply, state}
end
end
```
Вот, в общем-то, и все. Осталось запихнуть `MyApp.Sub` в наше дерево супервизоров, и этот процесс начнет получать все сообщения, высланные при помощи функций из `MyApp.Pub`, который тоже не перегружен кодом.
```
defmodule MyApp.Pub do
use Envio.Publisher, channel: :main
def publish(channel, what), do: broadcast(channel, what)
def publish(what), do: broadcast(what) # send to :main
end
```
#### Распределенная рассылка → `PG2`
Для распределенных систем, состоящих из множества узлов, такой способ не подойдет. Нам нужно уметь подписываться на сообщения от других узлов, и `Registry` тут не помощник. Зато есть `PG2`, реализующий то же `behaviour`.
```
defmodule Pg2Sucker do
use Envio.Subscriber, channels: ["main"], manager: :phoenix_pub_sub
def handle_envio(message, state) do
{:noreply, state} = super(message, state)
IO.inspect({message, state}, label: "Received")
{:noreply, state}
end
end
```
Единственное отличие от автономного кода выше — `manager: :phoenix_pub_sub` параметр, который мы передаем в `use Envio.Subscriber` (и `use Envio.Publisher`), чтобы построить модуль на основе `:pg2` вместо локального `Registry`. Теперь сообщения, отправленные с помощью такого `Publisher` будут доступны на всех узлах в кластере.
### Применение
[`Envío`](https://hexdocs.pm/envio) поддерживает так называемые [backends](https://hexdocs.pm/envio/backends.html#content). В поставке идет `Envio.Slack`, который позволяет донельзя упростить отсылку сообщений в `Slack`. Все, что требуется от приложения — отправить сообщение в канал, сконфигурированный в файле `config/prod.exs` — все остальное сделает `Envío`. Вот пример конфигурации:
```
config :envio, :backends, %{
Envio.Slack => %{
{MyApp.Pub, :slack} => [
hook_url: {:system, "SLACK_ENVIO_HOOK_URL"}
]
}
}
```
Теперь все сообщения, отправленные при помощи вызова `MyApp.Pub.publish(:slack, %{foo: :bar})` будут доставлены в соответствующий канал в *Slack*, красиво отформатированные. Для того, чтобы перестать слать сообщения в *Slack*, достаточно остановить процесс `Envio.Slack`. Больше примеров (например, лог в `IO`) можно найти в тестах.
Да чего я распинаюсь, попробуйте сами.
```
def deps do
[
{:envio, "~> 0.8"}
]
end
```
Удачного сообщательства! | https://habr.com/ru/post/481460/ | null | ru | null |
# Идеальный css-framework. Maxmertkit widget manager – build your own framework
Добрый день!
Как и обещал некоторое время назад, я выпустил бету maxmertkit widget manager. Я давно хотел npm или gem, но для css. Добавил несколько зависимостей в json-файл, набрал команду и все установилось. Это быстро и удобно. Хороших решений я не нашел, значит пора реализовать свое. Пока не начал, ссылки на статьи о том, с чего все начиналось – [первая](http://habrahabr.ru/post/165373/) и [вторая](http://habrahabr.ru/post/167951/) статьи. Можно не читать, кратко я все перескажу здесь. Можно сразу зайти на портал и разобраться что к чему, а также посмотреть видео – [www.maxmertkit.com](http://maxmertkit.com).
Почти все, что я опишу ниже, есть в этом видео. Я прошу прощения за качество звука, попытаюсь найти нормальный микрофон.
#### Требования
Перед реализацией любого проекта нужно определить основные требования, которым этот проект должен соответствовать.
* **Неймспейсы**. Для всех классов фреймворка.
+ **-<имя-виджета>** – наименование виджета, например -table, -btn, -tooltip
+ **-<имя-темы>-** – наименование темы для виджета, например -primary-, -error-, -orange-
+ **\_<имя-размера>** – размер, например \_tiny, \_small, \_huge, \_divine
+ **\_<имя-модификатора>\_** – модификатор, например \_top\_, \_active\_, \_hover\_, \_unclickable\_
* **Модульность**. Что я имею ввиду по модульностью? Есть виджет кнопка *-btn* и она используется в составе виджета *-group*. Во-первых, при создании виджета группы *-group* можно указать зависимость от виджета *-btn* и не описывать его еще раз (это легко добиться и при нативном css). Во-вторых, если я использую виджет *-btn* с темой *-error-*, то в составе группы я эту тему использовать не могу. Ну и наоборот, применив кастомную тему к группе, моя кнопка не должна поменяться. То есть виджеты должны быть совершенно независимы друг от друга. Для css это довольно сложно реализуемо, зато удобно и практично.
* **Capture theme**. Когда я применяю тему к виджету-родителю, виджеты-дети должны унаследовать тему. Например, ставим группе тему *-error-*, и все элементы внутри группы должны изменить цвета на *-error-*. Это очень удобно.
Все эти требования реализованы в **mwm** – maxmertkit widget manager. Он работает как npm для node.js или как gem для ruby on rails. Его задача скачать нужные вам виджеты, темы, модификаторы и анимации, после чего скомпоновать их для компиляции. Первый шаг – установка mwm. Это нужно сделать глобально, поэтому чтобы избежать лишних вопросов привожу команду с sudo:
```
sudo npm install -g mwm
```
После установки убедитесь, что mwm установлен правильно, набрав вызов справки:
```
mwm -h
```
Если появился список команд, значит все в порядке.
Для инициализации maxmertkit, перейдем в корень вашего проекта (именно в корень, а не в папку с вашими стилями). Здесь мы можем создать конфигурационный файл, который укажет mwm путь к папке с вашими стилями. Имя файла: **.mwmc**. Пока что mwm поддерживает только одно поле:
```
{
"directory": "path-to-your-stylesheets-from-projects-root"
}
```
Например, если мои стили относительно корня находятся в *public/stylesheets*, то
```
{
"directory": "public/stylesheets"
}
```
Если вы создали конфигурационный файл, то запускайте mwm из корня вашего проекта, если же нет, то перейдите в папку со стилями.
Далее нужно инициализировать maxmertkit следующей командой:
```
mwm init
```
Mwm поспрашивает вас о названии, тегах и прочей ерунде (которую обязательно заполнять, если вы создаете виджет/тему/анимацию и собираетесь ее опубликовать) и создаст необходимые для компиляции файлы, а именно:
* **\_imports.sass** – включает в себя перечисление всех подключаемых виджетов, тем, модификаторов и анимаций.
* **\_params.sass** – содержит параметры, необходимые для компиляции проекта
* **\_vars.sass** – переменные, используемые в *зависимых виджетах*
* **\_myvars.sass** – переменные, используемые в текущем виджете
* **\_index.sass** – файл, в который можно писать свои стили, только оставьте импорты
* **maxmertkit.json** – файл конфигурации проекта
Все эти файлы, кроме *\_index.sass* и *maxmertkit.json*, не нужно менять, трогать, а в идеале – нужно не знать про их существование или не замечать.
Попробуем установить виджет *btn*. Для этого добавим в *maxmertkit.json* поле *dependences*:
```
{
"type": "project",
"name": "test",
...
"dependences": {
"btn": "0.0.9"
}
}
```
Вместо версии 0.0.9 можно указать **\***, если вы хотите последнюю доступную версию этого виджета. Сохраняем и в терминале набираем
```
mwm install
```
Я не стал учить mwm компилировать sass-файлы, поэтому компилировать *\_index.sass* вам нужно самим. Для этого можно открыть новое окно терминала, перейти в папку со стилями (не в корень) проекта и набрать
```
sass -w _index.sass:index.css
```
Можно оставить это окно терминала, теперь sass будет следить за изменениями в структуре файлов и перекомпилировать проект при необходимости (отслеживает он не очень, поэтому после `mwm install` рекомендую открыть *\_index.sass* и сохранить его, чтобы компилятор сообразил, что нужно перекомпилить проект). Виджет кнопка *-btn* установлен. Можете использовать его в html-коде. Чтобы понять как, приветствуется зайти на [www.maxmert.com](http://maxmertkit.com) в раздел *widgets* и почитать документацию. В нашем случае это
```
кнопка
```
OK, а как же установить определенную тему для этого виджета? Нужно опять изменить *maxmertkit.json*:
```
{
...
"dependences": {
"btn": {
"version": "0.0.9",
"themes": {
"error": "*",
"orange": "*"
}
}
}
}
```
И снова набрать
```
mwm install
```
Теперь с виджетом -btn можно использовать темы **-error-** и **-orange-**:
```
Error button
Orange button
Default button
```
Вот, собственно, и все что необходимо, чтобы использовать mwm для своих проектов.
Приведу пример файла maxmertkit.json
```
{
"type": "widget",
"name": "group",
"version": "0.0.4",
"description": "Standart group",
"repository": "",
"author": "maxmert",
"themeUse": true,
"tags": "button, buttons, group, input, label, appendix",
"license": "BSD",
"dependences": {
"bourbon": "3.1.8",
"object": "0.0.0",
"btn": {
"version": "0.0.9",
"themes": {
"primary": "*",
"error": "*",
"orange": "*"
}
},
"forms": "0.0.5",
"caret": "0.0.4"
},
"themes": {
"default": "*",
"disabled": "*",
"primary": "*"
},
"modifiers": {
"tiny": "0.0.0",
"small": "0.0.0",
"minor": "0.0.0",
"normal": "0.0.0",
"major": "0.0.0",
"big": "0.0.0",
"huge": "0.0.0",
"giant": "0.0.0",
"divine": "0.0.0",
"active": "*",
"hover": "*",
"unclickable": "*",
"loading": "*",
"unstyled": "*"
},
"animation": {
"loading": "0.0.2"
}
}
```
#### Использование портала
После sign up на [maxmertkit.com](http://maxmertkit.com) у вас будут следующие возможности (я вообще никак не буду использовать ваши личные данные, обещаю):
* Вы сможете собирать проект прямо на сайте и скачивать стили в архиве.
* Можно сохранять необходимый набор виджетов/тем/модификаторов/анимаций в пресеты для отложенной компиляции или скачивания.
* Можно сохранять в избранное, чтобы долго не искать (хотя есть поиск) или просто сообщить, что вам этот виджет нравится.
* Можно создавать и публиковать свои виджеты, темы (темы — прямо на сайте, очень быстро и здорово), модификаторы и анимации.
Вся документация для виджетов доступна на сайте и без регистрации.
#### Создание виджета
Предположим, вы хотите сделать и опубликовать свой виджет. Первое, что вам нужно сделать, это зарегистрироваться на [maxmertkit.com](http://maxmertkit.com), войти в свой профайл (кликнуть на своей аватарке в sidebar'е) и создать developer password. Он будет необходим при публикации вашего виджета.
После этого создаем папку, в котором будет коваться наш виджет, заходим туда и набираем
```
mwm init -w
```
Флаг **-w** означает, что мы инициализируем виджет, а не проект. Mwm создает необходимые файлы, в целом похожие на файлы проекта. В файл **maxmertkit.json** добавляем зависимости, модификаторы и анимации, которые будет использовать наш новый виджет (по аналогии с проектом, описано выше). Набираем
```
mwm install
```
а затем
```
sass -w _index.sass:index.css
```
и приступаем к правке основного файла виджета **\_index.sass**.
##### Правим \_index.sass
\_index.sass – главный файл виджета, в котором прописаны все необходимые для виджета стили. Изначально он такой:
```
@import "imports"
@import "params"
@import "myvars"
@import "vars"
%#{$test}
@extend %object
// Set _minor to default size
$sizes: null!default
@if $sizes
@each $size in $sizes
$sz: #{nth($size, 1)}
@if $sz != _minor
&.#{nth($size, 1)}
font-size: nth($size,2)
padding: nth($size,2)/3 nth($size,2)/2
@else
font-size: nth($size,2)
padding: nth($size,2)/3 nth($size,2)/2
// Modifiers
// Themes
$themes: null!default
@if $themes
@each $theme in $themes
$index: 1
@if length( $themes ) != 1
$index: index( $themes, $theme )
$imp: ""
@if $theme == "-disabled-"
$imp: !important
@if $theme != "default"
&.#{$theme}
color: nth( $color-invert, $index )
border-color: nth( $border-color-lighten, $index )
&:hover
border-color: nth( $border-color-darken, $index )#{$imp}
@else
color: nth( $color-invert, $index )
border-color: nth( $border-color-lighten, $index )
&:hover
border-color: nth( $border-color-darken, $index )#{$imp}
@if $dependent == null
.#{$test}
@extend %#{$test}
```
Вместо $test будет название вашего виджета, например, если при инициализации вы сказали, что виджет будет называться *superbutton*, то вместо $test будет $superbutton. Но далее будем считать, что мой виджет будет называться test.
Разберем код.
```
%#{$test}
```
**%** здесь используется, чтобы не добавлять класс в css в случае, если этот виджет будет зависимостью другого виджета (это extend-only селектор). Советую почитать об этом [здесь](http://sass-lang.com/documentation/file.SASS_REFERENCE.html#placeholders).
###### Динамические размеры
```
$sizes: null!default
@if $sizes
@each $size in $sizes
$sz: #{nth($size, 1)}
@if $sz != _minor
&.#{nth($size, 1)}
font-size: nth($size,2)
padding: nth($size,2)/3 nth($size,2)/2
@else
font-size: nth($size,2)
padding: nth($size,2)/3 nth($size,2)/2
```
В случае, если наш будущий виджет будет иметь различные размеры, нужно не забыть включить в зависимости виджет **sizes** и определить свойства нашего виджета в этом цикле. В данном случае для каждого размера (см. виджет [sizes](http://maxmertkit.com/widgets/sizes)) определяем **font-size** и **padding**. Конечно же можно определять и другие параметры, включив *nth($size,2)* в значение. Здесь **nth($size,2)** – определенное значение в px, соответствующее каждому из размеров. Его можно преобразовать по вашему вкусу. Как вы могли заметить, код здесь дублирующийся. Но это необходимо для определения размера по-умолчанию после **@else** (код можно не дублировать, а выставить, например, какие-то заранее определенные значения).
###### Динамические темы
Теперь рассмотрим как добавлять темы.
```
$themes: null!default
@if $themes
// Берем каждую из тем
@each $theme in $themes
// В sass со списками все сложно, поэтому нужно проверить, является ли тема списком
$index: 1
@if length( $themes ) != 1
$index: index( $themes, $theme )
// Тема -disabled- всегда имеет приоритет, так что ставим !important, если эта тема текущая
$imp: ""
@if $theme == "-disabled-"
$imp: !important
// Если тема не default, используем название класса
@if $theme != "default"
&.#{$theme}
// Выставляем все необходимые параметры для нашего виджета
// В данном случае – это цвет текста и цвет границы
color: nth( $color-invert, $index )
border-color: nth( $border-color-lighten, $index )
// Кроме того, указываем каким показывать виджет для :hover, :active
// или других модификаторов, например .#{$mod-active} для использования виджета с модификатором _active_
&:hover
border-color: nth( $border-color-darken, $index )#{$imp}
&.#{$mod-active}
background-color: nth( $background-color, $index )#{$imp}
// И то же самое для темы по умолчанию без использования класса темы
@else
color: nth( $color-invert, $index )
border-color: nth( $border-color-lighten, $index )
&:hover
border-color: nth( $border-color-darken, $index )#{$imp}
&.#{$mod-active}
background-color: nth( $background-color, $index )#{$imp}
```
Я постарался дать комментарии в source, однако стоит упомянуть, что в **nth( $background-color, $index )#{$imp}** вам нужно лишь менять **background-color** на наименование из списка, присутствующего в каждой теме, например тут – [error theme](http://maxmertkit.com/themes/error). Это, например, *color*, *color-invert-darken*, *background-color-invert-darkener* и другие. При такой структуре темы будут автоматически применяться к вашему виджету. Попробуйте включить пару тем в зависимости и потестировать их.
```
@if $dependent == null
.#{$test}
@extend %#{$test}
```
Проверка, является ли ваш виджет зависимостью. Если да, то нет необходимости создавать селектор класса, но от него можно наследоваться. Если же нет, то создаем селектор класса.
###### Тесты и документация
Перейдем к тестам. Для публикации вы должны будете создать файл **test.html** и подключить в него скомпилированный *index.css* чтобы проверить, все ли правильно компилируется и работает. На портале ваш *test.html* будет отображаться в iframe после документации. Если вы указали github-репозиторий этого виджета в *maxmertkit.json*, то файл README.md будет взять оттуда. Если github-репозитория у виджета нет, то создайте файл README.md с рекомендациями по его использованию. Можно, конечно, без него, но как-то это плохо. Когда все протестировано, написано и готово, просто наберите
```
mwm publish
```
Помните, что ваше имя mwm возьмет из файла *maxmertkit.json*, поля **author**, а вот пароль ввести попросит. Далее можно следовать указаниям mwm. Виджет опубликован. Команда `unpublish` присутствует, но в тестовых целях, поэтому сервер будет ее игнорировать (вскоре она исчезнет из mwm совсем). Если вы вдруг поняли, что допустили ошибку, то вам прийдется ее исправить, повысить версию в *maxmertkit.json* и снова опубликовать виджет. Mwm хорошо поддерживает версионность, поэтому если кто-то уже использует старую версию вашего виджета, ничего не поломается.
#### Создание тем
Темы можно создавать прямо на сайте. Это быстро и удобно. Войдите с помощью одной из соцсетей, напротив меню *themes* появится **+**, нажав на который вы перейдете на страницу добавления темы. Достаточно ввести название и основные цвета: главный и инвертированный. Остальные поля можно оставить пустыми, они будут вычислены автоматически (см. плейсхолдеры этих полей).
#### Issues
Для mwm – <https://github.com/maxmert/mwm/issues>
Для виджетов, тем, модификаторов и анимаций (для sass и css) – [https://github.com/maxmert/maxmertkit/issues](https://github.com/maxmert/maxmertkit/issues?state=open)
Мои проблемы с английским или русским (очень прошу помочь с правкой текстов) – в личку на habrahabr или на [me@maxmert.com](mailto:me@maxmert.com).
#### Конкурс
Я прошу вас, друзья, присылать мне на почту [vetrenko.maxim@gmail.com](mailto:vetrenko.maxim@gmail.com) готовые UI (укажите, пожалуйста, тему **habrahabr — UI**, чтобы я смог ориентироваться), которые вы хотели бы видеть реализованными в maxmertkit. Я по мере возможности, начиная с самых привлекательных, буду добавлять их. Будет здорово! Присылать можно jpg (в этом случае когда я начну реализацию, скорее всего попрошу psd) или сразу psd. Буду обновлять пост, чтобы было видно, что появится в ближайшее время.
**P.S.**: Друзья, прошу помощи с написанием английской статьи для распространения в зарубежных блогах. Дело в том, что по-английски я пишу по-русски, простите за каламбур. Скорее всего текст такой грамотной статьи я возьму на главную страницу и укажу вас как автора статьи. Да и аккаунтов на зарубежных блогах с соответствующей тематикой у меня, к сожалению, нет, так что прошу помощи и с этим. | https://habr.com/ru/post/197834/ | null | ru | null |
# Добавляем GUI в EFI
В стандартном EDK нет поддержки графического интерфейса. Есть только из коробки пиксельный/текстовый вывод и [TUI](https://en.wikipedia.org/wiki/Text-based_user_interface) для [HII](https://edk2-docs.gitbook.io/edk-ii-uefi-driver-writer-s-guide/12_uefi_driver_configuration/121_hii_overview) интерфейса. А хочется капельку красоты и человеческий GUI. Дак добавим же! Даже не ради чего-то конкретного, а просто JUST FOR FUN!
Все элементарно: берем EDK, хватаем красивый язык для описания GUI и какую-нибудь не менее красивую библиотеку для вывода. Соединяем все это вместе и плавно перемешиваем на медленном огне. Все, готово, можно есть. Ну что, попробуем?
*Дисклеймер: в статье нет каких-либо тайных или сильно новых знаний, она просто показывает путь ~~самурая~~ по портированию проекта в EFI.*
Выбор
-----
В качестве библиотеки GUI будем использовать библиотеки под названием [LVGL](https://lvgl.io/). Просто потому что она мне нравится. При своей минималистичности в ней богатый функционал и есть куча всего, и плюс все это еще и активно развивается. Можно даже прямо в браузере посмотреть какие [крутые штуки делают на ней разработчики](https://lvgl.io/demos).
А еще она портирована на micropython, который, в принципе, подходит под “красивый язык”. Тут сразу может возникнуть вопрос: а почему не портировать его на более полный “python 3”? Ответ прост: сам micropython внутренне несколько по другому устроен по сравнению со своим старшим братом и требует сложной адаптации, которой бы не хотелось. Можно прочитать про это [тут](https://forum.lvgl.io/t/support-for-python3/1098).
Едем дальше! Что там у нас в EDK?! Еще в недалеком в 2018 в EDK портировали micropython, но судя по [github-у](https://github.com/tianocore/edk2-staging/tree/MicroPythonTestFramework) он с тех пор этот проект не сильно и развивался. Мы люди не гордые - возьмем что есть и пойдем дальше. Как говорится: “работает - не трожь!”.
Итак, есть Micropython под EFI и есть LVGL под micropython под Linux/микроконтроллеры. Надо их соединить.
Соединяем!
----------
Первым делом перетащим существующий micropython на новый EDK, хотя бы потому, что там много чего поменялось за последнее время и есть более классный эмулятор EFI, гораздо лучше чем раньше. Тут все просто: берем старое, Ctrl+C, берем новый EDK, Ctrl+V и пытаемся собрать. Не собралось - подредактировали - собралось. Там всего пару мелочей вроде отсутствующих в новом EDK небезопасных AsciiStrnCpy/AsciiStrCat и прочие мелкие неприятности. Собралось - отлично - едем дальше!
Далее, добавляем сам LVGL в micropython. Так как сам LVGL написан на С, то логично, что для языка micropython нужна некоторая обертка. Для генерации этой обертки существует проект [lv\_micropython](https://github.com/lvgl/lv_micropython). Суть проекта сводится к следующему: запускается некоторый условный “компилятор” для нашей библиотеки и генерирует на его основе с-файл с обертками для micropython-функций, которые в дальнейшем линкуются к micropython. После сборки уже в самом интерпретаторе micropython-а можно получить доступ к этим функциям библиотеки через отдельный модуль.
Было несколько попыток и мне так и не удалось запустить этот “компилятор” для текущих исходников micropython под EDK. Сделаем "workaround" и скомпилируем проект под Linux, а затем возьмем уже скомпилированный файл оберток “lv\_mpy\_example.c” и поместим в существующий проект в нашем EDK.
Доступ к модулям micropython после компиляции указываются в mpconfigport.h. Необходимо добавить ссылку на структуру модуля mp\_module\_lvgl, описанную в “lv\_mpy\_example.c” в MICROPY\_PORT\_BUILTIN\_MODULES:
```
extern const struct _mp_obj_module_t mp_module_lvgl;
#define MICROPY_PORT_BUILTIN_MODULES \
...
{ MP_OBJ_NEW_QSTR(MP_QSTR_lvgl), (mp_obj_t)∓_module_lvgl },
...
```
Здесь так же указывается идентификатор строки MP\_QSTR\_lvgl. Все идентификаторы, которые используются micropython хранятся в файле “qstrdefs.generated.h” в виде 3х байтового хеша и самой строки. Этот файл генерируется автоматически скриптом genhdr.py. Поэтому для обновления строки и перед компиляция его как минимум один раз надо запустить.
Добавляем все новые исходные файлы LVGL и в inf файл модуля MicroPythonDxe.inf.
Компилируем. Запускаем в Shell наш свежескомпилированный micropython.efi. Вводим в строке интерпретатора “import lvgl”, нажимаем Enter и наш micropython принимает модуль без ошибок. Автодополнение по tab тоже работает. Супер, все сделано верно!
Игла в яйце, яйцо в утке, утка в зайце
В смысле Lvgl в Micropython, а он в EFILvgl есть, а GUI нет - непорядок
--------------------------------
Сейчас у нас нет драйвера, который был знал как выводить Lvgl на экран. Напишем! Драйвер будет выполнен в качестве еще одного модуля micropython.
Как же написать драйвер? Тут все просто. Посмотрим как устроен уже существующий [драйвер SDL под Linux](https://github.com/lvgl/lv_binding_micropython/tree/master/driver/SDL) и [пример](https://github.com/lvgl/lv_binding_micropython/blob/master/examples/example1.py) как работать с ним в нашем питоне.
Начнем с вывода на экран. Так, есть функция инициализации и есть callback, который должен выводить буфер lvgl на экран
```
void monitor_flush(struct _disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p)
```
Окей, все понятно, пишем.
В EFI вывод на экран происходит через протокол EfiGopProtocol. Он реализует простейшие функции для работы с экранным буфером. Помним, что в системе EfiGopProtocol может быть несколько штук (например, для нескольких экранов). Делаем так, чтобы наш вывод изображения был на все из них, дабы не искать куда же вывелось изображение. Проходимся по всем EfiGopProtocol-ам и выводим буфер через функцию Blt, который пришел нам на вход.
Код вывода
```
{
EFI_STATUS Status;
UINTN Index;
EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
EFI_HANDLE *HndlBuf;
UINTN HndlNum;
//
// Get all the GOP protocol handles
//
Status = gBS->LocateHandleBuffer(ByProtocol, &gEfiGraphicsOutputProtocolGuid, NULL, &HndlNum, &HndlBuf);
if (EFI_ERROR(Status) || HndlNum == 0) {
return;
}
for (Index = 0; Index < HndlNum; Index++) {
Status = gBS->HandleProtocol (
HndlBuf[Index],
&gEfiGraphicsOutputProtocolGuid,
(VOID **) &GraphicsOutput
);
if (EFI_ERROR(Status)) {
continue;
}
//
// Out buffer to screen for each GOP protocol
//
GraphicsOutput->Blt(
GraphicsOutput,
(EFI_GRAPHICS_OUTPUT_BLT_PIXEL*)color_p,
EfiBltBufferToVideo,
0,
0,
area->x1,
area->y1,
w,
h,
0
);
}
gBS->FreePool(HndlBuf);
}
```
Далее сделаем из этого кода модуль для micropython:
Код
```
STATIC const mp_rom_map_elem_t efidirect_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_efidirect) },
{ MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(∓_init_efidirect_obj) },
{ MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(∓_deinit_efidirect_obj) },
{ MP_ROM_QSTR(MP_QSTR_monitor_flush), MP_ROM_PTR(&PTR_OBJ(monitor_flush))}
};
STATIC MP_DEFINE_CONST_DICT (
mp_module_efidirect_globals,
efidirect_globals_table
);
const mp_obj_module_t mp_module_efidirect = {
.base = { ∓_type_module },
.globals = (mp_obj_dict_t*)∓_module_efidirect_globals
};
```
Компилируем, стартуем. Запускаем тестовый скрипт:
Скрипт
```
import lvgl as lv
import efidirect as ed
# Screen size
scr_width = 800
scr_height = 600
# Initialize EFI driver
ed.init(w = scr_width, h = scr_height)
lv.init()
# Register EFI display driver
disp_buf1 = lv.disp_buf_t()
buf1_1 = bytearray(scr_width*scr_height*4)
disp_buf1.init(buf1_1, None, len(buf1_1)//4)
disp_drv = lv.disp_drv_t()
disp_drv.init()
disp_drv.buffer = disp_buf1
disp_drv.flush_cb = ed.monitor_flush
disp_drv.hor_res = scr_width
disp_drv.ver_res = scr_height
disp_drv.register()
scr = lv.obj()
btn = lv.btn(scr)
btn.align(lv.scr_act(), lv.ALIGN.CENTER, 0, 0)
label = lv.label(btn)
label.set_text("Hello World!")
# Load the screen
lv.scr_load(scr)
```
Смотрим на экран.. а там.. ничего нет! Ну как же так!
Главное, не падать духом. В Linux с SDL работает, а у нас нет. Где-то вышла промашка. Снова изучаем [документацию](https://docs.lvgl.io/latest/en/html/porting/display.html) и изучаем [SDL драйвер](https://github.com/lvgl/lv_binding_micropython/tree/master/driver/SDL) и вот оно!
Дело в том, в Lvgl необходим обработчик, который должен вызываться в цикле. Для SDL это сделали в отдельном потоке при инициализации библиотеки. У нас в EFI нет отдельного потока, поэтому, для простоты, будем вызывать цикл обработки прямо в нашем скрипте:
```
while(1):
lv.task_handler()
#Дельту времени пока задаем 1.
#По хорошему здесь должно быть честное вычисление дельты времени, но пока так
lv.tick_inc(1)
```
Запускаем и о чудо, it’s works!
Привет мир!Единственное “Но” - мы в цикле, у нас ничего нет, мы ничего не может сделать. Это конец, “перезагружаемся”.
Добавляем ввод
--------------
Полностью аналогично предыдущему пункту. Смотрим в SDL драйвер и делаем так же. Для ввода с клавиатуры в EFI используем EfiSimpleInputProtocol. Он реализует метод ReadKeyStroke, который и возвращает нам нажатую клавишу. Упаковываем его в в callback от Lvgl, не забыв преобразовать определение клавиш с EFI в LVGL:
Код для клавиатуры
```
/**
* ConvertEfiKeyToLvgl
*/
uint32_t
ConvertEfiKeyToLvgl(
EFI_INPUT_KEY *Key
)
{
switch (Key->UnicodeChar)
{
case CHAR_CARRIAGE_RETURN:
return LV_KEY_ENTER;
case CHAR_BACKSPACE:
return LV_KEY_BACKSPACE;
case CHAR_TAB:
return LV_KEY_NEXT;
default:
break;
}
switch (Key->ScanCode)
{
case SCAN_UP:
return LV_KEY_UP;
case SCAN_DOWN:
return LV_KEY_DOWN;
case SCAN_RIGHT:
return LV_KEY_RIGHT;
case SCAN_LEFT:
return LV_KEY_LEFT;
case SCAN_DELETE:
return LV_KEY_DEL;
case SCAN_HOME:
return LV_KEY_HOME;
case SCAN_END:
return LV_KEY_END;
default:
break;
}
return Key->UnicodeChar;
}
bool keyboard_read(struct _lv_indev_drv_t * indev_drv, lv_indev_data_t * data)
{
EFI_STATUS Status;
EFI_INPUT_KEY Key;
Status = gST->ConIn->ReadKeyStroke(gST->ConIn, &Key);
if (EFI_ERROR(Status)) {
data->state = LV_INDEV_STATE_REL;
return false;
}
data->key = ConvertEfiKeyToLvgl(&Key);
data->state = LV_INDEV_STATE_PR;
return false;
}
```
Для мыши есть протокол EfiSimplePointerProtocol. Действуем аналогично.
Код для мыши
```
bool mouse_read(struct _lv_indev_drv_t * indev_drv, lv_indev_data_t * data)
{
EFI_STATUS Status;
EFI_SIMPLE_POINTER_STATE State;
STATIC lv_coord_t X = 0, Y = 0;
if (gSimplePointer == NULL) {
return false;
}
//
// Get current the mouse state
//
Status = gSimplePointer->GetState(gSimplePointer, &State);
if (EFI_ERROR(Status)) {
return false;
}
//
// And calculate the absolute coordinate
//
X += (lv_coord_t)(State.RelativeMovementX / (INT32)gSimplePointer->Mode->ResolutionX);
Y += (lv_coord_t)(State.RelativeMovementY / (INT32)gSimplePointer->Mode->ResolutionY);
X = MAX(X, 0);
Y = MAX(Y, 0);
//
// Store the collected data
//
data->point.x = X;
data->point.y = Y;
data->state = State.LeftButton ? LV_INDEV_STATE_PR : LV_INDEV_STATE_REL;
return false;
}
```
Здесь стоит отметить только то, что если в случае с EfiSimpleInputProtocol, он уже есть в системной таблице gST, которая подается на вход программы, то EfiSimplePointerProtocol в gST нет, и его надо получить по хендлу ConsoleInHandle.
Получение EfiSimplePointerProtocol
```
EFI_SIMPLE_POINTER_PROTOCOL *gSimplePointer = NULL;
...
/*
* Init Function
*/
void input_init()
{
EFI_STATUS Status;
Status = gBS->HandleProtocol(gST->ConsoleInHandle, &gEfiSimplePointerProtocolGuid, &gSimplePointer);
if (EFI_ERROR(Status)) {
gSimplePointer = NULL;
}
}
```
Обновим тестовый скрипт. Запускаем. На этот раз работает все так как и ожидалось!
Скрипт micropython
```
import lvgl as lv
import efidirect as ed
import uctypes
# Screen size
scr_width = 800
scr_height = 600
close_flag = False
# Click button handler
def event_handler(source,evt):
global close_flag
if evt == lv.EVENT.CLICKED:
print("Clicked")
close_flag = True
# Initialize EFI drivers
ed.init(w = scr_width, h = scr_height)
lv.init()
# Register display driver.
disp_buf1 = lv.disp_buf_t()
buf1_1 = bytearray(scr_width*scr_height*4)
disp_buf1.init(buf1_1, None, len(buf1_1)//4)
disp_drv = lv.disp_drv_t()
disp_drv.init()
disp_drv.buffer = disp_buf1
disp_drv.flush_cb = ed.monitor_flush
disp_drv.hor_res = scr_width
disp_drv.ver_res = scr_height
disp_drv.register()
# Regsiter mouse driver
indev_drv = lv.indev_drv_t()
indev_drv.init()
indev_drv.type = lv.INDEV_TYPE.POINTER;
indev_drv.read_cb = ed.mouse_read
mouse_indev = indev_drv.register();
indev_drv = lv.indev_drv_t()
indev_drv.init()
indev_drv.type = lv.INDEV_TYPE.KEYPAD;
indev_drv.read_cb = ed.keyboard_read
kb_indev = indev_drv.register();
kb_group = lv.group_create()
kb_indev.set_group(kb_group)
scr = lv.obj()
# First button
btn = lv.btn(scr)
btn.align(lv.scr_act(), lv.ALIGN.CENTER, 0, 0)
label = lv.label(btn)
label.set_text("Cancel")
btn.set_event_cb(event_handler)
# Set the group for 'tab' works
kb_group.add_obj(btn)
# Second button
btn = lv.btn(scr)
btn.align(lv.scr_act(), lv.ALIGN.CENTER, 0, 50)
label = lv.label(btn)
label.set_text("Hello World!")
kb_group.add_obj(btn)
# Load the screen
lv.scr_load(scr)
# Set the PLAY symbol as the cursor image
img = lv.img(lv.scr_act(), None)
img.set_src(lv.SYMBOL.PLAY)
mouse_indev.set_cursor(img)
while(1):
lv.task_handler()
lv.tick_inc(1)
key = lv.indev_t.get_key(kb_indev)
if close_flag:
break
```
Запускаем. На этот раз работает все так как и ожидалось!
Теперь работает и мышь и клавиатура. И да, это все еще запускается под UEFIМожно заметить одно маленькое "фи". Если запустить наше приложение со ~~скрипом~~ скриптом в эмуляторе и одновременно отобразить диспетчер задач, то можно увидеть простой факт: приложение занимает слишком много процессорного времени.
Да, 9% кажется мало, но вторая вкладка диспетчера задача говорит, что одно ядро процессора постоянно занято эмулятором на 100%. Необходимо чтобы обработчик LVGL не так часто выполнялся и процессор немного “отдохнул” от рутины, прежде чем начнет выполнять его заново. Другими словами, должна быть небольшая задержка в цикле обработки, который мы описали в скрипте. Функция задержка есть в EFI. Вызовем ее прямо из скрипта. Для этого на помощь нам приходит EDK модуль micropython-a "uefi":
HotFix
```
import Lib.Uefi.uefi as uefi
…
while(1):
lv.task_handler()
lv.tick_inc(1)
# Delay 1ms
uefi.bs.Stall(100)
#
key = lv.indev_t.get_key(kb_indev)
if close_flag:
break
```
Все! Можно приступать к созданию GUI приложений или даже игр (если кому-то захочется) без каких-либо проблем под EFI. И главное все это делать на micropython-е. Не думаю, что сильно кому-нибудь это понадобится, но вдруг найдутся такие отважные люди.
Исходный код всего этого безобразия есть на [Github](https://github.com/ectogigamau/EfiLvgl)**.**
Если кто хочет поиграться с уже скомпилированной версией micropython-а с LVGL под EFI - вам [сюда](https://github.com/ectogigamau/EfiLvgl/tree/master/Binary). Тестовый py-файл [здесь](https://github.com/ectogigamau/EfiLvgl/blob/master/Examples/test.py). Документацию по API можно найти на [официальной сайте](https://docs.lvgl.io/7.11/).
И напоследок, быстро накидал [2048](https://github.com/ectogigamau/EfiLvgl/blob/master/Examples/2048.py).
P.S. Пока окончально дописал статью, немного отстал от жизни т.к. вышел следующий релиз LVGL за номером 8, в то время как статья базируется на LVGL 7.x. Но большой беды в этом нет, т.к. описанное почти полностью идентично если бы портировался свежий LVGL 8. | https://habr.com/ru/post/583450/ | null | ru | null |
# Самый простой способ создать трафик на сетевом интерфейсе
Есть программа iperf, которая позволяет проверять скорость интерфейсов (у меня на тестах из 10G интерфейса она выжимала 9.37 Гбит/с).
Пакет (в дебиане и убунте) так и называется — iperf.
Применение очень простое: на одном сервере запускаете iperf -s X.X.X.X (свой собственный адрес сервера, на котором слушать). Можно запустить просто `iperf -s`, тогда слушать будет на всех интерфейсах.
На клиентской части пишем `iperf -c X.X.X.X` (адрес сервера из предыдущего этапа). Клиент подключается, работает 10 с и показывает скорость работы канала.
Пример: сервер имеет адрес 192.0.2.1, клиент 192.0.2.200. На сервере запускаем `iperf -s 192.0.2.1` на клиенте `iperf -c 192.0.2.1`.
Для того, чтобы сделать много байтов (привет хостерам с соотношениями) нужно просто указать опцию -t (время в секундах). Многие гигабайты трафика в нужном направлении вам обеспечены. С учётом текущих тарифов для дома — можно даже с домашней машины, за 3-4 часика можно выправить любое соотношение с минимальной нагрузкой как на сервер, так и на клиента. | https://habr.com/ru/post/109259/ | null | ru | null |
# Босяцкий кластер высокой доступности
Порой нам бывает нужно добавить избыточность какому-то сервису, который оказался публичной точкой входа в нашу инфраструктуру. Например, представьте, что мы хотим добавить второй балансировщик для высокой доступности. При этом балансировщики находятся на границе нашей сети и пересылают трафик доступным бэкенд-серверам.
```
┌─────────────┐
│ │
┌─────►│ Backend 1 │
│ │ │
│ └─────────────┘
│
│
│ ┌─────────────┐
│ │ │
┌────────────┐ ├─────►│ Backend 2 │
│ │ │ │ │
│ │ │ └─────────────┘
Public traffic │ Load │ │
───────────────────►│ ├────┤
│ Balancer │ │ ┌─────────────┐
│ │ │ │ │
│ │ ├─────►│ ... │
└────────────┘ │ │ │
│ └─────────────┘
│
│
│ ┌─────────────┐
│ │ │
└─────►│ Backend N │
│ │
└─────────────┘
```
Мы не можем просто добавить ещё один балансировщик нагрузки перед парой наших балансировщиков, потому что иначе любой переключатель трафика перед нашей парой высокой доступности также сам станет единой точкой отказа. Но нам всё равно как-то нужно организовать переключение трафика между парой этих балансировщиков:
```
┌─────────────┐
│ │
┌─────►│ Backend 1 │
┌────────────┐ │ │ │
│ │ │ └─────────────┘
│ │ │
Public traffic │ Load │ │
───────────────────►│ ├────┤ ┌─────────────┐
▲ │ Balancer 1 │ │ │ │
│ │ │ ├─────►│ Backend 2 │
│ │ │ │ │ │
└────────────┘ │ └─────────────┘
Switching? │
│
│ ┌────────────┐ │ ┌─────────────┐
│ │ │ │ │ │
▼ │ │ ├─────►│ ... │
Public traffic │ Load │ │ │ │
─ ─ ─ ─ ─ ─ ─ ─ ─ ─►│ ├────┤ └─────────────┘
│ Balancer 2 │ │
│ │ │
│ │ │ ┌─────────────┐
└────────────┘ │ │ │
└─────►│ Backend N │
│ │
└─────────────┘
```
Подходы обеспеченных людей
--------------------------
Давно существуют разнообразные решения для этой задачи. Все они так или иначе манипулируют сетевой коммутацией на каком-то уровне, чтобы направить входящий трафик на оба или только один балансировщик.
### VRRP, CARP, Virtual IP, Floating IP, ...
По сути сопоставляет один или несколько IP-адресов одному или нескольким активным балансировщикам нагрузки. IP-адреса (пере-)присоединяются к рабочим серверам в случае отказа других серверов. Такие методы в конечном счёте используют сетевое оборудование в качестве того самого переключателя между рабочими балансировщиками нагрузки.
Стоит заметить, что упомянутое сетевое оборудование совсем необязательно имеет какую-либо избыточность (резервирование). Например, вполне возможна пара из двух балансировщиков нагрузки подключенных к одному Ethernet-свитчу, который будет в этом случае единой точкой отказа. И даже свитчи с резервированием компонентов могут быть склонны к одновременным отказам из-за схожих условий работы или общего широковещательного домена.
Это решение подходит только для балансировки нагрузки внутри одного датацентра.
### Anycast, BGP и методы, основанные на динамической маршрутизации
Обычно используются не сами по себе, а в сочетании с балансировщиками внутри датацентра. Отправляют анонсы одного и того же блока IP-адресов из разных местоположений, фактически выстраивая обслуживание этих IP-адресов машинами из разных датацентров. Эти методы в конечном счёте используют своих сетевых соседей по пирингу и соседей этих соседей как переключатель трафика перед собственной инфраструктурой, анонсируя или не анонсируя блоки IP-адресов из некоторого расположения (датацентра).
Этот способ в особенности доступен только достаточно крупным сетевым операторам, вероятно даже эксплуатирующим собственные [автономные системы](https://ru.wikipedia.org/wiki/%D0%90%D0%B2%D1%82%D0%BE%D0%BD%D0%BE%D0%BC%D0%BD%D0%B0%D1%8F_%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_(%D0%98%D0%BD%D1%82%D0%B5%D1%80%D0%BD%D0%B5%D1%82)).
### Методы, использующие DNS
Производят переключение трафика на уровне DNS, приводя клиента к правильному серверу. Существуют следующие широкоизвестные варианты:
* [Round robin DNS](https://ru.wikipedia.org/wiki/Round_robin_DNS) - на самом деле, не-вариант, потому что обнажает все известные серверы сразу, надеясь, что клиенту либо повезёт подключиться к рабочему серверу, либо он будет достаточно упорным, чтобы перепробовать их по-очереди.
* Динамический DNS, отслеживающий состояние балансируемых серверов (AWS Route53, Cloudflare DNS LB, PowerDNS dnsdist, ...). Отслеживают работоспособность серверов и отвечают на DNS-запросы адреса сервера адресом **только одного** работоспособного сервера.
Занимательный факт насчёт таких облачных сервисов балансировки нагрузки состоит в том, что они тарифицируются на основе принятых DNS-запросов, однако мы в общем-то не имеем возможности ни как-то влиять на объём входящих DNS-запросов, ни проверить как много DNS-запросов на самом деле было произведено клиентами.
### Проблемы обеспеченных людей
Некоторые из этих методов сложно правильно реализовать. Даже для keepalived рекомендуется использовать отдельный канал связи для VRRP-протокола. Иначе дефицит полосы пропускания на рабочем соединении будет мешать протоколу выбора мастера. Некоторые из них просты в интеграции (такие как DNS GTM-ы), но могут обернуться достаточно дорогостоящими.
Решения выше подразумевают что цель пересылки трафика (локальный балансировщик нагрузки или просто сервер) либо работоспособны, либо неисправны, что является некоторым допущением. Это может быть не всегда так, в особенности для решений, переключающих трафик между разными датацентрами. Например, AWS Route53 производит периодические пробы жизнеспособности серверов из разных местоположений, чтобы убедиться, что целевой сервер доступен. Но положительный результат такой пробы не обязательно свидетельствует о глобальной доступности из всех возможных удалённых местоположений - возможность установления соединения в Интернете не всегда однозначна.
Босяцкий Кластер Высокой Доступности не делает таких допущений, не ограничен только лишь одним датацентром, не имеет "подвижных частей" и не стоит Вам практически ничего. С ним Вы можете быстро запускать глобальные отказоустойчивые сервисы, что позволяет посвятить больше времени сведению концов с концами.
Схема
-----
Обычно процесс разрешения доменных имён выглядит следующим образом:
```
┌────────────┐ A? example.com ┌───────────────┐
│ │ (1) │ │
│ ├───────────────►│ DNS recursive │
│ Client │ │ │
│ │◄───────────────┤ resolver │
┌─┤ │ A example.com │ │
│ └────────────┘ (8) └┬────┬────┬────┘
│ │ ▲ │ ▲ │ ▲
│ ┌─────────────────────────────┘ │ │ │ │ │
│ │A? example.com (2) │ │ │ │ │
│ │ ┌─────────────────────────────┘ │ │ │ │
│ ▼ │NS com (3) │ │ │ │
│ ┌──┴──────────┐ ┌────────────────┘ │ │ │
│ │ ├┐ │A? example.com (4)│ │ │A? example.com (6)
│ │ ROOT ││ │NS example.com (5)│ │ │A example.com (7)
│ │ ││ ▼ ┌────────────────┘ │ │
│ │ nameservers ││ ┌──┴──────────┐ │ │
│ │ ││ │ ├┐ │ │
│ └┬────────────┘│ │ .COM ││ │ │
│ └─────────────┘ │ ││ ▼ │
│ │ nameservers ││ ┌──────┴──────┐
│ │ ││ │ ├┐
│ └┬────────────┘│ │ example.com ││
│ └─────────────┘ │ ││
│ │ nameservers ││
│ │ ││
│ └┬────────────┘│
│ └─────────────┘
│ ┌─────────────┐
│ │ ├┐
│Actual connection │ EXAMPLE.COM ││
└─────────────────►│ ││
(9) │ servers ││
│ ││
└┬────────────┘│
└─────────────┘
```
Клиент желает установить соединение с некоторым хостом, указанным по его доменному имени. Клиент запрашивает DNS-резолвер (обычно это DNS-серверы, предоставляемые интернет-провайдером, и находящиеся в той же сети, что и клиент). DNS-резолвер, если не имеет адреса в кэше, следует по всей иерархии авторитативных DNS-серверов. На каждом шаге он оказывается или перенаправлен на следующий более конкретный сервер имён, куда запрошенный домен делегирован, или наконец получает запрошенную ресурсную запись.
Заметьте, что на каждом шаге DNS-рекурсору обычно доступно больше одного сервера имён для осуществления запросов. DNS имеет встроенные механизмы отказоустойчивости и, если какой-то нэймсервер не доступен, будет запрошен следующий в этой группе. Например, прямо сейчас доменная зона .COM обслуживается 13-ю серверами имён:
```
a.gtld-servers.net.
b.gtld-servers.net.
...
m.gtld-servers.net.
```
Каждый из этих серверов имён может быть запрошен для получения нэймсерверов домена example.com, и DNS-рекурсор свяжется со следующим сервером имён, если не получит ответ от сервера из первой попытки. Мы можем использовать это свойство, чтобы построить переключение трафика между рабочими серверами, основанное на DNS. Идея состоит в следующем: мы можем развернуть два или больше авторитативных нэймсерверов для нашего домена на самих рабочих серверах и настроить их возвращать собственный IP-адрес. Таким образом будет причинно-следственная связь между адресом нэймсервера, который смог достигнуть DNS-рекурсор, и IP-адресом используемым для связи с целевым сервером.
В отличии от обычных решений с динамическим DNS, мы не пытаемся решить какой сервер работоспособен, мы не делаем никаких активных проб. Мы просто позволяем DNS-рекурсору определить самостоятельно, какой нэймсервер доступен, и он в свою очередь приведёт клиента к той же машине, которая предоставила успешный DNS-ответ. Фактически, это возлагает прощупывание рабочего сервера и переключение на него на DNS-рекурсор клиента, позволяя нам отделаться двумя DNS-серверами со статической конфигурацией. Диаграмма взаимодействий могла бы выглядеть следующим образом:
```
┌────────────┐ A? example.com ┌───────────────┐
│ │ (1) │ │
│ ├───────────────►│ DNS recursive │
┌─┤ Client │ │ │
│ │ │◄───────────────┤ resolver │
│ │ │ A example.com │ │
│ └────────────┘ (9) (=LB2) └┬────┬────┬─┬──┘
│ │ ▲ │ ▲ │ │ ▲
│ ┌─────────────────────────────┘ │ │ │ │ │ │
│ │A? example.com (2) │ │ │ │ │ │
│ │ ┌─────────────────────────────┘ │ │ │ │ │
│ ▼ │NS com (3) │ │ │ │ │
│ ┌──┴──────────┐ ┌────────────────┘ │ │ │ │
│ │ ├┐ │A? example.com (4)│ │ │ │
│ │ ROOT ││ │NS example.com (5)│ │ │ │ A example.com (8)
│ │ ││ ▼ ┌────────────────┘ │ │ │
│ │ nameservers ││ ┌──┴──────────┐ │ │ │ (=LB2)
│ │ ││ │ ├┐ │ │ │
│ └┬────────────┘│ │ .COM ││ │ │ │
│ └─────────────┘ │ ││ │ │ │
│ │ nameservers ││ │ │ │
│ │ ││ │ │ │
│ └┬────────────┘│ │ │ │
│ └─────────────┘ │ │ │
│ A? example.com (6) │ │ │
│ ┌─xxxxxxxxxxxxxxxx────────────────────┘ │ │
│ │ A? example.com (7)│ │
│ │ ┌──xxxxxxxxxxxxx ┌────────────────┘ │
│ ▼ │ ▼ │
│ ┌──┴──────────────┐ ┌─────────────────┐ │
│ │ │ │ ├─┘
│ │ example.com │ │ example.com │
│ │ │ │ │
│ │ nameserver1 & │ │ nameserver2 & │
│ │ │ │ │
│ │ loadbalancer1 │ │ loadbalancer2 │
│ │ │ │ │
│ │ (FAULTY) │ │ (HEALTHY) │
│ │ │ │ │
│ └─────────────────┘ └─────────────────┘
│ ▲
│ Actual connection (10) │
└───────────────────────────────────┘
```
Как показывает диаграмма, рекурсор DNS спускается по иерархии как обычно. Когда дело доходит до разрешения фактического адреса ресурса example.com, он пытается связаться с первым нэймсервером, который так же является сервером, предоставляющим сервис example.com. Первый сервер неисправен и не предоставялет ответ рекурсору DNS. Рекурсор DNS пытается связаться с другим нэймсервером и преуспевает в этом. Второй (нэйм)сервер отвечает на запрос своим собственным IP-адресом, как и всегда. Это приводит к тому, что DNS-рекурсор вернёт запросившему клиенту IP-адрес живого нэймсервера, который по совместительству является IP-адресом живого балансировщика сервиса example.com.
Реализация
----------
Рассмотрим чуть более практический пример, где нам нужно организовать балансировку некоторого хостнейма, но нам бы не хотелось делегировать всю доменную зону на наши собственные авторитативные нэймсерверы. Мы возьмём домен `example.com` и обеспечим высокую доступность для домена `api.example.com`, который указывает на пару балансировщиков перед рабочими серверами.
### Шаг 1. Подготовка серверов
Подготовьте два сервера для обслуживания входящего трафика. Они могут находиться даже в разных датацентрах и пересылать трафик в местную группу рабочих серверов. Далее мы будем полагать, что IP-адреса развёрнутых серверов `198.51.100.10` и `203.0.113.20`.
**Проверка:** убедитесь, что вы можете залогиниться на эти серверы и они доступны по их внешним адресам.
### Шаг 2. Разверните полезную нагрузку на серверах
Разверните на этих серверах сервис или балансировщики нагрузки, предоставляющие настоящий сервис на этих IP-адресах.
**Проверка:** зависит от вашего сервиса.
### Шаг 3. Установите всезахватывающие (catchall) DNS-серверы
На этом шаге нам нужно установить авторитативный DNS-сервер на каждую машину и настроить его отвечать на любые запросы IP-адресом этой машины. Почти каждый DNS-сервер может справиться с этой работой, даже простой dnsmasq. Однако разумным вариантом для этого будет сервер CoreDNS.
Установите CoreDNS на каждый сервер и примените следующую конфигурацию:
#### Первый сервер
`/etc/coredns/db.lb`:
```
@ 3600 IN SOA lb1 adminemail.example.com. 2021121600 1200 180 1209600 30
3600 IN NS lb1
3600 IN NS lb2
* 30 IN A 198.51.100.10
```
`/etc/coredns/Corefile`:
```
example.com {
file /etc/coredns/db.lb
}
```
#### Второй сервер
`/etc/coredns/db.lb`:
```
@ 3600 IN SOA lb1 adminemail.example.com. 2021121600 1200 180 1209600 30
3600 IN NS lb1
3600 IN NS lb2
* 30 IN A 203.0.113.20
```
`/etc/coredns/Corefile`:
```
example.com {
file /etc/coredns/db.lb
}
```
**Проверка:** команда `dig +short api.example.com @198.51.100.10` должна возвращать адрес `198.51.100.10`. Команда `dig +short api.example.com @203.0.113.20` должна возвращать адрес `203.0.113.20`.
### Шаг 4. Добавьте A-записи для серверов в DNS
Создайте следующие DNS-записи в доменной зоне example.com:
```
lb1.example.com. 300 IN A 198.51.100.10
lb2.example.com. 300 IN A 203.0.113.20
```
Процесс редактирования зоны DNS зависит от того, где вы её хостите. Иногда это панель управления Godaddy, иногда это Cloudflare. Вам виднее.
**Проверка:** команда `dig +short lb1.example.com` должна возвращать `198.51.100.10`. Команда `dig +short lb2.example.com` должна возвращать `203.0.113.20`.
### Шаг 5. Наконец делегируйте хостнейм api.example.com на балансировщики/нэймсерверы
Удалите все имеющиеся DNS-записи для имени `api.example.com`. Добавьте следующие:
```
api.example.com. 300 IN NS lb1.example.com.
api.example.com. 300 IN NS lb2.example.com.
```
Готово! Через несколько минут вы сможете обратиться к домену api.example.com через два балансировщика, которые мы настроили.
**Проверка:** команда `dig +trace api.example.com` должна давать вывод, указывающий на то, что lb1 и lb2 были затронуты при разрешении имени и результат должен давать один из их адресов.
Обслуживание
------------
Если Вам нужно провести обслуживание одного из серверов, или сервер плохо себя ведёт, Вы можете снять с него нагрузку просто остановив CoreDNS на этом сервере и подождав TTL (30 секунд в нашем примере). | https://habr.com/ru/post/683770/ | null | ru | null |
# «Доктор Веб»: портал gosuslugi.ru скомпрометирован и может начать заражать посетителей или красть информацию
*На портале государственных услуг Российской Федерации (gosuslugi.ru) специалисты компании «Доктор Веб» обнаружили внедрённый неизвестными потенциально вредоносный код. В связи с отсутствием реакции со стороны администрации сайта [gosuslugi.ru](http://gosuslugi.ru) мы вынуждены прибегнуть к публичному информированию об угрозе.*
Дату начала компрометации, а также прошлую активность по этому вектору атаки, установить на данный момент не представляется возможным. Вредоносный код заставляет браузер любого посетителя сайта незаметно связываться с одним из не менее 15 доменных адресов, зарегистрированных на неизвестное частное лицо. В ответ с этих доменов может поступить любой независимый документ, начиная от фальшивой формы ввода данных кредитной карточки и заканчивая перебором набора уязвимостей с целью получить доступ к компьютеру посетителя сайта.
В процессе динамического генерирования страницы сайта, к которой обращается пользователь, в код сайта добавляется контейнер , позволяющий загрузить или запросить любые сторонние данные у браузера пользователя. На текущий момент специалистами обнаружено не менее 15 доменов, среди которых: m3oxem1nip48.ru, m81jmqmn.ru и другие адреса намеренно неинформативных наименований. Как минимум для 5 из них диапазон адресов принадлежит компаниям, зарегистрированным в Нидерландах. За последние сутки запросы к этим доменам либо не завершаются успехом, так как сертификат безопасности большинства этих сайтов просрочен, либо не содержит вредоносного кода, однако ничего не мешает владельцам доменов в любой момент обновить сертификаты и разместить на этих доменах вредоносный программный код.
На данный момент сайт [gosuslugi.ru](http://gosuslugi.ru) по-прежнему скомпрометирован, информация передана в техническую поддержку сайта, но подтверждения принятия необходимых мер по предотвращению инцидентов в будущем и расследования в прошлом не получено. «Доктор Веб» рекомендует проявлять осторожность при использовании портала государственных услуг Российской Федерации до разрешения ситуации. ООО «Доктор Веб» рекомендует администрации сайта gosuslugi.ru и компетентным органам осуществить проверку безопасности сайта.
Любой пользователь может проверить наличие кода самостоятельно, использовав поисковый сервис и задав запрос о поиске следующей формулировки:
`site:gosuslugi.ru "A1996667054"`
UPD: пофикшено через 3 часа после публикации. | https://habr.com/ru/post/333008/ | null | ru | null |
# Symfony2. Подводные камни кэширования
Прошло уже 3 месяца с тех пор, как я, в качестве хобби, начал писать проект на новом Symfony 2. Далее в статье я постараюсь поделиться с хабрасообществом проблемами, с которыми может столкнуться разработчик. Статья ориентирована на людей уже знакомых с архитектурой Symfony и Doctrine.
##### Проблема 1. Doctrine 2. Result Cache. Serializing Entities.
Doctrine 2 позволяет нам кэшировать запросы, но при этом не рекомендует это делать с Entity.
> Serializing entities can be problematic and is not really recommended, at least not as long as an entity instance still holds references to proxy objects or is still managed by an EntityManager… ([пруф](http://www.doctrine-project.org/docs/orm/2.0/en/reference/architecture.html))
>
>
В любом случае, если мы решаем кэшировать запрос, то для каждой Entity необходимо реализовать интерфейс Serializable. При этом объекты, которые пришли из кэша не могут корректно обработаться менеджером. Он их считает новыми и пытается заново вставить в базу. Чтобы все работало корректно, необходимо или заново загрузить объект или не использовать в данном случае кэширование.
Пример.
```
//массив объектов из кэша
$blogs = $this->getDoctrine()
->getRepository('BlogBundle:Blog')
->getBlogs();
if ($request->getMethod() == 'POST') {
$form->bindRequest($request);
if ($form->isValid()) {
$data = $form->getData();
// создаем или обновляем пост
// забиваем данные
// ...
// так работать не будет
foreach ($blogs as $blog) {
if ($blog->getId() == $data->blog_id) {
$blog = $blog;
break;
}
}
//а так будет
//$blog = $this->getDoctrine()
// ->getRepository('BlogBundle:Blog')
// ->findOneById($blog->getId());
//указываем блог для поста
$post->setBlog($blog);
//сохраняем
$em = $this->getDoctrine()->getEntityManager();
$em->persist($post);
$em->flush();
}
}
```
##### Проблема 2. Symfony2. HTTP Cache и Security Component.
Идеология кэширования фреймворка основана на [спецификации HTTP](http://symfony.com/doc/current/book/http_cache.html), что позволяет использовать проксирующие кэши. Например, [Varnish](http://symfony.com/doc/current/cookbook/cache/varnish.html). Плюс большой, т.к. страница отдаётся клиенту без загрузки самого фреймворка.
Но этот кэш становится бесполезным, если на сайте будет использоваться встроенная авторизация пользователей. В этом случае Symfony2 создает сессию на каждого пользователя, считая его анонимным. А раз есть сессия, значит, есть и уникальная cookie. В итоге кэш работает для каждого посетителя сайта отдельно, т.к. считает его авторизованным.
**Решение данной проблемы я пока не нашел. Возможно, хабрасообщество поможет.**
Также, исходя из идеологии кэширования, Symfony2 лучше не использовать в проектах, где контент меняется в зависимости от авторизации пользователя. Например, голосование за топик на хабре, где существуют следующие состояния: можно голосовать, я проголосовал положительно, отрицательно, голосование закончилось и т.д. Или, например, форма добавления комментария к публикации, где есть возможность комментирования и анонимными пользователями.
##### Тест на нагрузку.
По счастливой случайности я имею два проекта схожие по функционалу. Один написан на Symfony 1.4, а другой на Symfony2.
И как ни странно простой нагрузочный тест главных страниц показал, что проект на Symfony 1.4 работает быстрее:
1. Symfony 1.4 примерно 2550 запросов за 30 секунд при конкуренции 10.
2. Symfony2 примерно 1750 запросов за 30 секунд при конкуренции 10.
Проекты хостятся на выделеном сервере с четырех ядерным процессором (Intel Core2 Quad CPU Q9550) и 8G оперативной памяти.
Сайты на которых проводились тесты:
1. <http://dreamiech.ru> — Symfony 1.4
2. <http://dvjournal.ru> — Symfony 2 | https://habr.com/ru/post/132211/ | null | ru | null |
# PushAll — платформа для рассылки мгновенных уведомлений
[](https://pushall.ru)
Основная идея
=============
PushAll предоставляет платформу для рассылки мгновенных уведомлений в браузер пользователя или в его мобильное устройство, что позволяет ему получать отфильтрованную свежую информацию из интересующих его источников. Интерфейс сайта позволяет пользователю подписаться на новый канал всего в 2 клика, а унифицированное приложение дает возможность получать уведомления с множества источников. Это куда проще, чем скачивать для каждого сайта отдельное приложение. Вместе с этим компании и разработчики могут экономить время и деньги на разработке и поддержке своего приложения.
Сама система позволяет легко подписываться и отписываться от тех или иных каналов. Что исключает возможность внезапного спама, как это происходит в случае с такими методами уведомлений как SMS и E-mail.
Разработка и API
================
Сервис был запущен пол года назад. В его основе лежит авторизация через **Google+** о которой я даже [писал статью](http://habrahabr.ru/post/229039/) и **GCM**, через который я отправляю пуши как в Google Chrome, так и на Android приложение. Я собираюсь также написать реализацию на сокетах и засчет нее сделать поддержку всех браузеров, а также возможно устройств на Android без встроенного PUSH-сервиса.
Долгое время я использовал PushAll лишь для **Self API** — это API для отправки уведомлений самому себе. При помощи этой функции я получал информацию из автоматизированных скриптов использующихся на моей работе. Это очень удобно, в случе каких либо проблем — прямо на телефон и в хром прилетает уведомление о неполадках и сразу можно приступить к починке. Более того, система сохраняет историю уведомлений. Поэтому если вы спали, а у вас были неполадки, вы потом можете увидеть, что происходило и в каком порядке.
Примерно так будет выглядеть код отправки через PHP используя POST запрос.
```
curl_setopt_array($ch = curl_init(), array(
CURLOPT_URL => "https://pushall.ru/api.php",
CURLOPT_POSTFIELDS => array(
"type" => "self",
"id" => "**ВАШ ID**",
"key" => "**ВАШ КЛЮЧ**",
"text" => "Тестовое сообщение",
"title" => "Заголовок"
),
CURLOPT_SAFE_UPLOAD => true,
));
curl_exec($ch);
curl_close($ch);
```
Буквально месяц назад я ускорил темпы разработки и написал **Broadcast API**. Эта функция позволяет отправлять уведомления всем подписчикам созданного канала. Для отправки broadcast надо прописать ID канала, тип broadcast и ключ канала.
Ответ на все запросы API идет в формате JSON. На данный момент приходит параметр success с количеством устройсв, на которые был отправлен пуш, и error в случае ошибки. В ошибке может быть либо неправильный ключ, либо привышение лимитов.
Лимиты на данный момент такие:
— Не более 1 уведомления в 3 секунды для Self API (а куда чаще спамить на устройство)
— Не более 1 уведомления в 30 секунд для Broadcast — всем и так понятно, что спамить всему каналу чаще чем раз в 30 секунд будет неприятно для аудитории.
— Защита от дубликатов пары «Заголовок»-«Текст» раз в 10 минут.
Сотрудничество и планы на будущее.
==================================
Приблизительно 2 недели назад я начал искать партнеров. Я начал с студий озвучки сериалов. У них практически каждый день выходят серии, а зретелям необходимо оперативно узнавать, когда выходит озвучка их любимого сериала. За 2 недели я начал сотрудничать с BaibaKo, NewStudio и Jaskier Studio. За это время в моем сервисе зарегистрировалось около 1000 пользователей. В скором времени я реализую **Unicast API** для рассылки одному пользователю в канале и хочу начать сотрудничать с новостными сайтами. Эта функция позволит отправлять уведомления одному человеку из канала, к примеру это может быть ответ на комментарий, или личное сообщение.
Также хочу отметить недавно добавленную **функцию фильтрации**. Для сериалов она подошла идеально — можно выбрать нужные сериалы по ключевым словам, а также появляются необычные возможности. К примеру можно подписаться на сериалы, которые ты смотришь, и параллельно на все новые сериалы — надо лишь добавить S01E01 и любая первая сериая первого сезона любого сериала будет приходить. (зависит от формата нумерации серий)
По моим задумкам все должно работать приблизительно так — человек заходит на сайт, где он хочет оставить комментарий. После написания комментария ему предложат подписаться на уведомления об ответах. Если у него уже установлено приложение то подписка пройдет в один клик. Отписка от любого канала (если он стал не нужен) происходит в пару кликов в личном кабинете.
Также я думаю сделать каталог каналов похожим на магазины мобильных приложений. То есть сделать систему рейтинга, похожие, отзывы и т.д. Это позволит определить, насколько полезен канал, и решить подписываться на него или нет.
#### Конкуренты
Из аналогов моему сервису можно выделить лишь два сервиса:
**Pushover**
— Платное приложение
— Отсутствие русскоязычной локализации.
— Сервис скорее внешне больше для разработчиков чем для пользователей.
— Сильные ограничения рассылок. Дорогие тарифы
**Pushbullet**
— Гиковский сервис для обмена данными между устройствами
— Система каналов появилась недавно, что странно, через 2-3 месяца как я написал Self API и начал постить информацию о сервисе.
— Система каналов не предусматривает отправку одному пользователю
— Отсутствие русскоязычной локализации.
— Отсутствуют фильтры.
Моей основной целью является создать сервис понятным пользователю. Вход и подписка в пару кликов ([быстрая ссылка для подписки на канал новостей](https://pushall.ru/?fs=1)), простые приложения, все гиковские функции для разработчиков скрыты в специальный раздел. Также я хочу создать именно русскоязычное комьюнити разработчиков. Этот пост был написан первым в этом корпоративном блоге, дальше в нем будут публиковаться не только успехи, кейсы PushAll, но и различные проекты, в основу которых легла моя система уведомлений. К примеру почему бы не написать Push — клиент для социальной сети Facebook или Вконтакте? Пуши приходят через небольшое по весу приложение, а по клику на пуш ответить можно через веб-интерфейс.
#### Монетизация
На данный момент монетизация сервиса построена на добровольных пожертвованиях. В будущем новые каналы будут иметь ограничение по отправляемым уведомлениям в сутки. Данное ограничение можно будет снять, оплатив платный тариф. Старые же каналы будут иметь пожизненную безлимитную подписку. Некоммерческие организации также смогут получить бесплатную подписку.
Собственно адрес сайта: [Pushall.ru](https://pushall.ru)
Для добавления канала можно перейти в раздел для разработчика. Отправлять уведомления можно как вручную, так и через API. То есть даже если вы не разработчик, вы все равно можете без проблем вести канал.
**UPD 10.05.2015 Добавлен Unicast API и возможность получения ID пользователя через Callback.** | https://habr.com/ru/post/257585/ | null | ru | null |
# Тензоры для C#. И матрицы, и векторы, и кастомный тип, и сравнительно быстро
Привет!
Понадобились мне как-то тензоры (расширения матриц) для моего проектика. Погуглил, нашел целый ряд всяких библиотек, все вокруг да около, а чего нужно — нет. Пришлось реализовать пятидневку и имплементировать то, что надо. Короткая заметка о работе с тензорами и трюках оптимизации.
Итак, что же нам нужно?
1. N-мерные матрицы (тензоры)
2. Имплементация базового набора методов работы с тензором как со структурой данных
3. Имплементация базового набора математических функций (для матриц и векторов)
4. Типы Generic, то есть любые. И кастомные операторы
**А что уже написано до нас?**
Так, в [Towel](https://github.com/ZacharyPatten/Towel) имплементированы матрицы, но есть несколько существенных недостатков:
1. Не тензоры, а только матрицы
2. Transpose — это «активная» операция, работающая за O(V), где V — объем «фигуры». То есть поменять местами оси вам будет стоить перемещения элементов по всей матрице
3. ~~В принципе библиотека будет работать с любыми типами, но при работе с ними она будет обращаться в том числе к их операторам. Поэтому если вам вдруг понадобилась работа с типом, у которого нет операторов, придется писать собственную обертку, которая явно не бесплатная по времени.~~ На самом деле можно перезаписывать вызываемые делегаты вручную, хотя это и неочевидно (и еще не так быстро, об этом ниже)
System.Numerics.Tensor скажете вы. Жаль, у этого типа очень мало методов определено, а главное, он не поддерживает кастомные типы. И, похоже, их [подвела](https://github.com/dotnet/runtime/blob/master/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/Tensor.cs#L138) собственная технология.
Конечно еще есть всякие [MathSharp](https://github.com/john-h-k/MathSharp), [NumSharp](https://github.com/SciSharp/NumSharp), [Torch.Net](https://github.com/SciSharp/Torch.NET), [TensorFlow](https://github.com/migueldeicaza/TensorFlowSharp), но это все игровые/ML-овские, ни о каких кастомных типах речи нет.
Хранение элементов, транспонирование, подтензор
-----------------------------------------------
Элементы будут храниться в одномерном массиве. Чтобы из набора индексов получить элемент, мы будем умножать индексы на определенные коэффициенты и складывать. А именно, положим, у нас есть тензор [3 x 4 x 5]. Тогда нам нужно сформировать массив из трех элементов — *блоков* (сам название придумал). Тогда последний элемент равен 1, предпоследний равен 5, а первый элемент — 5 \* 4 = 20. То есть blocks = [20, 5, 1]. Например, при обращении по индексу [1, 0, 4] индекс в массиве будет выглядеть как 20 \* 1 + 5 \* 0 + 4 \* 1 = 24. Пока все ясно
### Транспонирование
… то есть изменение порядка осей. Тупой и простой способ — создать новый массив и загнать туда элементы в новом порядке. Но часто бывает удобно транспонировать, работать с нужным порядком осей, а затем менять порядок осей обратно. Конечно, в этом случае нельзя менять сам *линейный массив (ЛМ)*, а при обращении к определенным индексам, мы будем просто подменять порядок.
Рассмотрим функцию:
```
private int GetFlattenedIndexSilent(int[] indices)
{
var res = 0;
for (int i = 0; i < indices.Length; i++)
res += indices[i] * blocks[i];
return res + LinOffset;
}
```
Как видим, если поменять *blocks* местами, то создастся видимость свапнутых осей. Поэтому [так](https://github.com/asc-community/GenericTensor/blob/master/GenericTensor/Core/Tensor/GenTensor.Axes.cs#L44) и запишем:
```
public void Transpose(int axis1, int axis2)
{
(blocks[axis1], blocks[axis2]) = (blocks[axis2], blocks[axis1]);
(Shape[axis1], Shape[axis2]) = (Shape[axis2], Shape[axis1]);
}
```
Просто меняем номера и длины осей местами.
### Подтензор
Подтензор N-мерного тензора это M-мерный тензор (M < N), который является частью исходного. Например, нулевой элемент тензора формы [2 x 3 x 4] это тензор формы [3 x 4]. Его мы получим просто сдвигом.
Представим, что мы получаем подтензор по индексу *n*. Тогда его первый элемент это *n \* blocks[0] + 0 \* blocks[1] + 0 \* blocks[2] + ...*. То есть сдвиг равен *n \* blocks[0]*. Соответственно, не копируя исходный тензор, мы запоминаем [сдвиг](https://github.com/asc-community/GenericTensor/blob/master/GenericTensor/Core/Tensor/GenTensor.Axes.cs#L172), создаем новый тензор со ссылкой на наши данные, но уже со сдвигом. А еще нужно будет выкинуть элемент из blocks, а именно элемент blocks[0], ведь это первая ось, к ней обращений не будет.
### Другие операции с композицией
Все остальные уже следуют из этих.
1. SetSubtensor форвардит элементы в нужный подтензор
2. Concat создает новый тензор, и туда форвардит элементы из двух (при этом длина первой оси — сумма длин осей двух тензоров)
3. Stack группирует некоторое число тензоров в один с дополнительной осью (например, stack([3 x 4], [3 x 4]) -> [2 x 3 x 4])
4. Slice возвращает Stack от определенных подтензоров
Все операции с композицией, которые я определил, можно найти [здесь](https://github.com/WhiteBlackGoose/GenericTensor#composition).
Математические операции
-----------------------
Тут уже все просто.
1) Поточечные операции (то есть для двух тензоров операции производятся над парой соответствующих элементов (то есть с одинаковыми координатами)). Реализация [тут](https://github.com/asc-community/GenericTensor/blob/master/GenericTensor/Functions/PiecewiseArithmetics.cs#L44) (объяснение почему такой некрасивый код ниже).
2) Операции над матрицами. Произведение, инверсия, и другие простые операции, мне кажется, объяснения не требуют. Хотя есть что рассказать о детерминанте.
**Сказ о детерминанте**
Дело в том, что способов посчитать детерминант не один. Есть классический способ — метод Лапласа, рекурсивный, работает за O(N!). При работе с матрицами больше 3x3 метод Лапласа начинает проигрывать методу Гаусса (приведение матрицы к треугольной и перемножение элементов диагонали).
Но у метода Гаусса есть недостаток для нас, программистов. Для разных типов данных он выразится по-разному: для float это будет существенная потеря точности, а для int это будет просто неверный ответ.
Реализации в интернете отличаются друг от друга, одни требуют модуль числа, а другие используют деление. Мы же *почти* избежим и того, и другого.
Чтобы избежать ошибок деления, мы заведем тип *дробь*. Так, любые арифметические операции, включая деление, будут работать с дробью, а в конце функции мы в итоге поделим числитель на знаменатель. Реализацию можно найти [тут](https://github.com/asc-community/GenericTensor/blob/master/GenericTensor/Functions/Determinant.cs#L166). *SafeDivisionWrapper* это как раз та самая дробь.
Хотя у этого метода тоже есть недостаток: переполнение. Ведь если скапливать в числителе и знаменателе параллельно, то вместо одного небольшого числа у нас получится дробь с огромными знаменателем и числителем. Поэтому я оставил и не SafeDivision версию (для типов с большой точностью, или нечисленных типов его хватит).
3) Операции над веторами (dot и cross product).
Оптимизация
-----------
##### Темплейты?
В C# **нет** темплейтов. Поэтому приходится использовать костыли. [Некоторые люди](http://github.com/ZacharyPatten) придумали динамическую компиляцию в делегат, например [так](https://github.com/ZacharyPatten/Towel/blob/master/Sources/Towel/Syntax.cs#L1099) у него реализована сумма двух типов.
Однако хотелось кастома, поэтому я завел [интерфейс](https://github.com/asc-community/GenericTensor/blob/master/GenericTensor/Core/IOperations.cs#L7), от которого пользователю нужно унаследовать структуру. При этом в самом линейном массиве хранится примитив, а функции сложения, разности, и другие вызываются как
```
var c = default(TWrapper).Addition(a, b);
```
Что инлайнится до вашего метода. [Пример имплементации такой структуры](https://github.com/asc-community/GenericTensor/blob/master/GenericTensor/Functions/DefaultWrappers.cs#L42).
##### Индексация
Далее, хотя кажется, что логично в индексаторе использовать params, то есть как-то так:
```
public T this[params int[] indices]
```
На самом деле при каждом обращении будет создаваться массив, поэтому приходится создавать множество [перегрузок](https://github.com/WhiteBlackGoose/GenericTensor/blob/fcdf6533f8b0353f9b85af815eb873d37c27fced/GenericTensor/Core/Tensor/GenTensor.Iterate.cs#L65). Аналогично происходит с другими функциями, работающими с индексами.
##### Исключения
Еще я загнал все исключения и проверки в блок #if ALLOW\_EXCEPTIONS на случай, если точно нужно быстро, а проблем с индексами точно нет. Небольшой прирост по производительности есть.
На самом деле это не просто так микрооптимизация, которая много чего будет стоить в плане безопасности. Например, в ваш тензор идет запрос, в котором вы и так уже по своим соображениям сделали проверку на корректность данных. Тогда зачем вам еще одна проверка? А они не бесплатные, особенно, если мы экономим даже лишние арифметические операции с целыми числами.
##### Многопоточность
Спасибо Билли, это оказалось [очень просто](https://github.com/WhiteBlackGoose/GenericTensor/blob/fcdf6533f8b0353f9b85af815eb873d37c27fced/GenericTensor/Functions/PiecewiseArithmetics.cs#L78) и реализуется через Parallel.For.
Хотя многопоточность это не панацея, и включать ее надо аккуратно. Я провел бенчмарк для поточечного сложения тензоров на i7-7700HQ:
Где Y-ось показывает время (в микросекундах) на выполнение одной операции с двумя целочисленными тензорами определенного размера (размер по оси X).
То есть есть определенный порог, начиная с которого многопоток имеет смысл. Чтобы не надо было думать, сделал флажок *Threading.Auto* и тупо захардкодил константы, начиная с объема равного которым можно включать многопоток (есть более умный автоматический метод?).
При этом библиотека все равно никак не быстрее игровых матриц, или тем более тех, что подсчитываются на CUDA. А зачем? Те уже написаны, а у нас главное — кастомный тип.
### Вот так вот
Вот такая коротенькая заметка, спасибо за прочтение. Ссылка на гитхаб проекта [здесь](https://github.com/asc-community/GenericTensor). А главный его пользователь — библиотека символической алгебры [AngouriMath](https://github.com/asc-community/AngouriMath).
**Немного про наши тензоры в AngouriMath**
Для нее эти тензоры полезны нечисленностью, ведь в AM-е тип элемента это *Entity*, кастомный класс. К примеру,
```
var t = MathS.Matrices.Matrix(3, 3,
"A", "B", "C", // Эти буквы парсятся как символьные переменные, тут могло быть и "A * 3", и "sqrt(sin(x) + 5)"
"D", "E", "F",
"G", "H", "J");
Console.WriteLine(t.Determinant().Simplify());
```
Вернет в ответ
`A * (E * J - F * H) + C * (D * H - E * G) - B * (D * J - F * G)` | https://habr.com/ru/post/512856/ | null | ru | null |
# Введение в Test-Driven Development на React для чайников
Первое правило Test-Driven Development (TDD) – это написание тестов перед написанием кода. Это звучит более интуитивно, когда мы говорим о разработке для бэкенда, если честно, но работает ли данная схема для фронтенда, в частности для React, что же, посмотрим.
В данном посте мы узнаем о TDD на React с простым примером.
Особенности
-----------
Для демонстрации мы будем разрабатывать очень простой и очень ужасный ***счетчик***.
Он поможет нам разобраться, как работает то, что мы хотим понять, в конечно счете мы фокусируемся больше на функциональности, нежели на эстетике.
Настройка проекта
-----------------
В первую очередь, создадим простой React проект.
```
yarn create react-app react-test-driven-development
```
Когда проект создан, проверьте, все ли работает, просто запустив проект.
```
cd react-test-driven-development
yarn start
```
Вы должно получить что-то похожее по адресу <http://localhost:3000>.
Написание счетчика
------------------
Создайте новую папку ***components*** внутри папки ***src***. Данная папка будет содержать компоненты, которые мы напишем. И внутри этой папки создайте файл с названием ***Counter.test.js***. Как было сказано ранее, когда мы работаем с TDD мы пишем сначала тесты, а затем уже код приложения.
Это помогает заложить основы лучшей архитектуры вашего приложения, так как мы сначала думаем о том, как и что будет работать, и что нам нужно писать.
Описание работы счетчика
------------------------
Наш идеальный компонент принимает в себя проп value, который в дальнейшем будет отображаться на экране в определенном тэге.
Прекрасно! Давайте напишем вначале тест.
Написание теста
---------------
Напишите данный код внутри ***Counter.test.js***.
```
import { render, screen } from '@testing-library/react';
import Counter from "Counter";
```
Мы начинаем с того, что импортируем необходимые инструменты для написания тестов. Не беспокойтесь о 2 строчке, мы пока что ещё не создали компонент счетчика. Задача TDD это убедиться, что первый тест провалится, перед тем как написать работающий код.
С этим всем, мы теперь можем написать наш первый тест.
```
test('renders counter component', () => {
render();
const counterElement = screen.getByTestId("counter-test");
});
```
Здесь мы рендерим компонент счетчика в DOM и затем получаем его как элемент. Нам нужно будет протестировать две вещи:
* Компонент отрисовался?
* Компонент отображает именно значение "2"?
```
test('renders counter component', () => {
render();
const counterElement = screen.getByTestId("counter-test");
// Тест, отрисовался ли элемент счетчика
expect(counterElement).toBeInTheDocument();
// Тест, верно ли, что значение счетчика равно 2
expect(counterElement).toHaveTextContent("2");
});
```
Прекрасно! Теперь в командной строке запустите данную команду, чтобы проверить тесты.
```
yarn test
```
Команда, естественно, завершится ошибкой.
Прекрасно! Теперь мы можем написать наш компонент.
Написание компонента
--------------------
Внутри папки компонента создайте новый файл ***Counter.jsx***. И поместите данный код внутри его.
```
import React from "react";
// Это компонент, который мы тестируем
function Counter({value}) {
return (
{value}
);
}
export default Counter;
```
Теперь снова запустить команду для проверки тестов, всё должно быть зеленым.
Мы сделали отличную работу. Следующим шагом будет добавления нашего компонента в ***App.js*** и добавление кнопки для изменения состояния. И мы также будем следовать TDD для этого.
*Примечание: вы можете увидеть данную ошибку в терминале после запуска тестов.*
```
Warning: ReactDOM.render is no longer supported in React 18...
```
Вы можете найти решение данной проблемы на [StackOverflow](https://stackoverflow.com/questions/71685441/react-testing-library-gives-console-error-for-reactdom-render-in-react-18/71716003#71716003).
Написание всего функционала счетчика
------------------------------------
Дальнейшая задача, это добавление кнопки, которая будет изменять значение нашего счетчика в ***Counter.jsx***. И мы это сделаем внутри ***App.js***, так что напишем тесты для этого. Создайте файл ***App.test.js***.
### Что нам нужно сделать
Для создания всего функционала нам нужно:
* По нажатию на кнопку увеличивать значение счетчика на 1
Довольно легко, не так ли? Давайте писать тест.
### Написание теста
Библотека [***testing-library***](https://testing-library.com/) даёт нам инструменты, которые позволяют нам обрабатывать срабатывание действия кнопки. Что очень хорошо!
Начнем с импорта нужных инструментов. Так как мы хотим, чтобы по действию события нажатия на экран (нажатие на кнопку) увеличивалось значение счетчика, то тесты у нас будут асинхронными.
```
import { render, screen } from '@testing-library/react';
import App from './App';
import userEvent from "@testing-library/user-event";
```
***UserEvent*** эмулирует действия пользователя, такие как нажатие мышки, ввод текста, и многое другое. А вот и код теста.
```
import { render, screen } from '@testing-library/react';
import App from './App';
import userEvent from "@testing-library/user-event";
describe('Render the counter with Button', () => {
render();
it("render counter", async () => {
const appElement = screen.getByTestId('app-test');
expect(appElement).toBeInTheDocument();
// Тест, имеет ли счетчик верное стандартное значение
const counterElement = screen.getByTestId('counter-test');
expect(counterElement).toHaveTextContent('0');
// Получение элемента кнопки
const buttonElement = screen.getByTestId('button-counter-test');
expect(buttonElement).toBeInTheDocument();
// Срабатывание действия нажатия кнопки
await userEvent.click(buttonElement);
// Тест, изменилось ли значение счетчика на новое, и верно ли оно
expect(counterElement).toHaveTextContent('1');
})
});
```
Прекрасно, тесты происходят с ошибкой, как нам и нужно. Давайте теперь напишем функционал в компоненте.
### Написание всего функционала нашего счетчика
Внутрь файла ***App.js*** добавьте данный код.
```
import React, { useState } from "react";
import Counter from "./components/Counter";
function App() {
const [count, setCount] = useState(0);
return (
setCount(count + 1)}>Increase
);
}
export default App;
```
Мы используем хук useState для отслеживания и изменения состояния приложения.
После добавления кода запустите тесты снова. Все должно быть зеленым.
И принимайте мои поздравления 🥳! Мы написали наше первое, небольшое, страшненькое, но рабочее приложение на React используя TDD . | https://habr.com/ru/post/661335/ | null | ru | null |
# DI в iOS: Complete guide
Всем привет, меня зовут Виталий, я iOS-разработчик в юните мессенджера в Тинькофф. Сегодня поговорим о том, что такое DI, зачем он нужен, рассмотрим известные библиотеки для DI и сравним их между собой. Поехали!
Часть 1. Введение в DI
----------------------
**Dependency Injection,** или внедрение зависимостей, — это паттерн настройки объекта, при котором зависимости объекта задаются извне, а не создаются самим объектом. Другими словами, объекты настраиваются внешними объектами.
Существует несколько способов внедрения зависимостей.
1. **Interface injection** (через интерфейс)
```
final class TestViewModel {
private lazy var userService = getUserService()
func getData() -> Data {
return userService.getData()
}
}
protocol TestViewModelResolving {
func getUserService() -> UserServiceProtocol
}
extension TestViewModel: TestViewModelResolving {
func getUserService() -> UserServiceProtocol { return UserService() }
}
```
2. **Property injection** (через публичное свойство)
```
final class TestViewModel {
var userService: UserServiceProtocol?
}
final class UserService: UserServiceProtocol { … }
…
let viewModel = TestViewModel()
viewModel.userService = UserService(...)
```
3. **Method injection** (через публичный метод)
```
final class TestView: UIView {
private var style: ViewStyleProtocol?
func apply(style: ViewStyleProtocol) {
self.style = style
// applying style
}
}
struct TestViewStyle: ViewStyleProtocol { … }
…
let style = TestViewStyle(...)
testView.apply(style: style)
```
4. **Constructor injection** (через инициализатор/конструктор)
```
final class TestViewModel {
private let userService: UserServiceProtocol
private let modelId: String
init(userService: UserServiceProtocol, modelId: String) {
self.userService = userService
self.modelId = modelId
}
...
}
final class UserService: UserServiceProtocol { … }
…
let userService = UserService(...)
let viewModel = TestViewModel(userService: userService, modelId: “id”)
```
Предпочтительным, как правило, является **Constructor injection**, так как он лишен недостатков трех предыдущих способов:
1. **Interface Injection** требует создания дополнительного протокола для инъекции в каждый объект, что кажется избыточным.
2. **Property Injection** позволяет создать объект и начать его использовать еще до того, как заинжектили все нужные зависимости. Это может приводить к ошибкам из-за неконсистентного состояния объекта. Кроме того, нам приходится делать внедряемые поля публичными, что дает возможность менять их извне в любой момент, нарушая **инкапсуляцию**.
3. **Method injection** очень похож на **Property Injection**, но внедрение происходит через метод. Используется реже, чем **Property Injection**, но имеет те же недостатки.
Но даже **Constructor injection** можно использовать не всегда — например, когда есть цикл зависимостей (пример будет чуть ниже). Еще бывает так, что использовать **Constructor injection** не очень удобно. Например, когда зависимости создаются уже после создания основного объекта. Конечно, можно использовать **Constructor injection**, если сделать зависимость опциональной и передавать в конструктор как nil по умолчанию. Но в таких кейсах обычно применяется **Property injection.**
Некоторые разработчики считают, что **Constructor injection** плох тем, что приводит к появлению **boilerplate** кода в разрастающемся от количества зависимостей инициализаторе, но, думаю, это не плохо. Такие иниты выступают отличным индикатором того, что вы помещаете в объект слишком много зависимостей и, возможно, стоит вспомнить про **Single Responsibility Principle** и подумать о лучшей декомпозиции объекта.
В чем преимущества от использования DI?
1. DI делает зависимости объекта **явными** (четко прописанными в интерфейсе объекта) — это позволяет лучше контролировать его сложность.
2. DI делает зависимости объекта **внешними** (передаются в объект извне, а не создаются внутри) — это позволяет отделять код создания объектов от бизнес-логики, улучшая разделение ответственности.
3. DI дает возможность сделать зависимости **гибкими**. Mожно подменить объект другим — например, если закрыть его протоколом, скрыв реализацию. Код классов теперь зависит только от интерфейсов, а не от конкретных классов, скрывая детали реализации и уменьшая связанность кода. Как следствие — объекты становятся **легко тестируемыми**.
4. DI уменьшает связанность(**coupling**) объектов.
5. DI упрощает переиспользование объектов.
6. DI улучшает декомпозицию за счет выноса порождающей логики наружу.
Какие минусы у этого подхода?
1. Увеличивается количество сущностей в проекте. Добавляются дополнительные классы с порождающей логикой и протоколы, скрывающие детали реализации зависимостей.
2. Возрастает время написания кода.
Часть 2. Service Locator
------------------------
Когда говорят про DI в iOS-проектах, часто приводят в пример **Service Locator (SL)** — паттерн, суть которого в наличии объекта-реестра, к которому обращаются объекты для получения зависимостей. Объект-реестр знает, как получить все зависимости, которые могут потребоваться.
В статьях и iOS-коммьюнити в целом есть некая неоднозначность трактовки понятий **ServiceLocator**, **DI**, **DI-контейнер**, **IoC** и **IoC-контейнер**. Не буду на этом подробно останавливаться, просто оставлю [ссылку](https://jonfir.github.io/posts/ioc-ios/), где, как мне кажется, хорошо разобран этот вопрос. Отмечу только, что ключевым отличием паттернов **SL** и **DI** является то, что к локатору обращаются явно внутри класса и достают из него необходимые зависимости. При **DI** же, наоборот, зависимости внедряются извне.
#### Давайте рассмотрим простой пример сервис-локатора:
```
protocol ServiceLocating {
func resolve() -> T?
}
final class ServiceLocator: ServiceLocating {
static let shared = ServiceLocator() // Singleton
// MARK: Private properties
private lazy var services = [String: Any]()
// MARK: Init
private init() {}
// MARK: Private methods
private func typeName(\_ some: Any) -> String {
return (some is Any.Type) ? "\(some)" : "\(type(of: some))"
}
// MARK: Internal methods
func register(service: T) {
let key = typeName(T.self)
services[key] = service
}
func resolve() -> T? {
let key = typeName(T.self)
return services[key] as? T
}
}
```
Как видим, реализация довольно проста. Внутри находится словарь, где **ключом** является строка, содержащая имя типа, а **значением** — объект, который мы регистрируем в локаторе. Чтобы получить какую-то зависимость, нужно ее сначала зарегистрировать. Зависимости, как правило, регистрируются в одном месте на старте приложения. Данная реализация не является потокобезопасной, но для демонстрации сути паттерна этого вполне достаточно. Кроме того, мы реализовали **SL** как **singleton**, что, строго говоря, не обязательно.
Давайте рассмотрим пример использования **SL**. Допустим, раньше вы создавали зависимости прямо по месту использования:
```
func someMethod() {
let service = TestService()
// используем service
}
```
С **SL** вы будете регистрировать зависимости где-то в одной точке при старте приложения и позже получать их через локатор:
```
ServiceLocator.shared.register(service: service)
…
func someMethod() {
guard let service: TestServiceProtocol = ServiceLocator.shared.resolve() else {
return
}
// используем service
}
```
В чем профит? Давайте разберемся.
#### Плюсы и минусы сервис-локатора
Плюсы:
1. Можно получить любую необходимую зависимость, скрывая от пользователя детали создания объекта-зависимости.
2. Избавляет от необходимости использовать сервисы-синглтоны.
3. Удобно тестировать — можно подменить зависимости при регистрации на моки.
Минусы:
1. Часто является **синглтоном**. Синглтоны сами по себе имеют много недостатков и часто позиционируются как антипаттерны.
Проблемы синглтонов:
- глобальное состояние и его неявное изменение;
- неявная зависимость от синглтона, что приводит к неявному нарушению **SRP**;
- жесткая зависимость от синглтона, что мешает тестированию.
2. Является **god-объектом**, который знает слишком много и имеет доступ к любому объекту. А значит, все, кто имеет к нему доступ, получают те же возможности. В сочетании со свойством синглтона проблема усугубляется.
3. Способствует созданию **внутренних неявных** зависимостей, что приводит к неявной связанности (**coupling**), которая приводит к неявной сложности.
4. Ошибки в рантайме: если вы резолвите зависимость, которую не регистрировали, то узнаете об ошибке только в рантайме.
Как было сказано выше, **SL** не обязательно должен быть синглтоном. Мы можем, например, инжектить его в объекты через **Constructor Injection**:
```
final class SomeClass {
private let userService: UserServiceProtocol
init(serviceLocator: ServiceLocating) {
userService = serviceLocator.resolve()!
}
}
```
Но тогда зависимости нашего класса все еще остаются **неявными**. В этом примере можно заметить еще один недостаток **SL** — необходимость использовать **implicitly unwrapped optional** либо при каждом резолве проверять опционал на nil. Дело в том, что мы никогда не знаем, регистрировали ли мы нужный нам сервис в локаторе или нет, пока не попробуем зарезолвить его. Мы не получим никаких ворнингов или ошибок при сборке, если какой-то сервис не был зарегистрирован, — просто поймаем краш в рантайме.
Чтобы улучшить последний пример, можно вынести **SL** в **фабрику**:
```
final class UserProfileFactory {
static func createUserProfile(serviceLocator: ServiceLocating) -> UIViewController {
let viewController = UserProfileViewController()
let userService: UserServiceProtocol = serviceLocator.resolve()!
let viewModel = UserProfileViewModel(userService: userService)
viewController.viewModel = viewModel
return viewController
}
}
```
Так мы реализуем **принцип наименьших привилегий** и избавляем объекты от необходимости знать про **SL** (то есть знать слишком много), оставляя его только в области видимости фабрик. Но это не избавляет нас от необходимости передавать объект **SL** между фабриками. Кто-то должен будет хранить этот объект, ведь он будет нужен в каждой фабрике каждого модуля приложения. Неплохим вариантом такого хранителя является [**координатор**.](https://www.hackingwithswift.com/articles/71/how-to-use-the-coordinator-pattern-in-ios-apps) Использование **DI**(**CI)** + **Factory + SL + Coordinator** позволяет сгладить описанные выше недостатки сервис-локатора.
Но тогда возникает резонный вопрос: а нужен ли здесь тогда вообще сервис-локатор? Почему бы не отказаться от него совсем и создавать зависимости внутри **фабрик** — в конце концов, фабрики и задуманы для инкапсуляции порождающей логики. Оставляю этот вопрос вам на подумать.
Часть 3. DI-библиотеки
----------------------
Итак, время познакомиться с популярными библиотеками для **DI**. Начнем с классификации. DI-библиотеки, которые мы рассмотрим, будут основаны либо на **рефлексии,** либо на **кодогенерации**.
Начнем с библиотек, основанных на рефлексии. Под рефлексией подразумевается отображение множества **ключей** на множество **объектов**. Например, в нашем сервис-локаторе мы использовали словарь (**Dictionary**), который, по сути, отображает ключ (имя типа объекта) на сам сервис-объект.
### Библиотеки, основанные на рефлексии
Swinject
--------
<https://github.com/Swinject/Swinject>
Более 4.5k звезд на «Гитхабе». Наверное, самая популярная DI-библиотека для iOS. Довольно проста в использовании:
```
protocol Animal {
var name: String { get }
}
final class Cat: Animal {
let name: String
init(name: String) {
self.name = name
}
}
...
let container = Container()
container.register(Animal.self) { _ in Cat(name: "Mimi") }
...
let animal = container.resolve(Animal.self)!
print(animal.name) //prints “mimi”
```
Но погодите! register...resolve… вам это ничего не напоминает? Это же очень похоже на уже хорошо знакомый нам **ServiceLocator**. Если мы заглянем внутрь, то увидим аналогичный словарь, но ключом уже является структура **ServiceKey**, а значением — некий объект за протоколом **ServiceEntryProtocol.**
```
public final class Container {
internal var services = [ServiceKey: ServiceEntryProtocol]()
...
}
internal struct ServiceKey {
internal let serviceType: Any.Type
internal let argumentsType: Any.Type
internal let name: String?
internal let option: ServiceKeyOption? // Used for SwinjectStoryboard or other extensions.
...
}
```
В нашем примере простого **SL** мы использовали в качестве ключа строку с именем типа. Здесь все немного сложнее. Тоже используется тип сервиса (**serviceType**), но также учитываются типы аргументов, передаваемые при резолве. Имя (**name**) нужно, чтобы добавлять зависимости одного типа под разными именами, опции (**option**) — для использования контейнера со сторибордами. По сути, все эти параметры нужны, чтобы получать уникальное значение хэша для разных зависимостей, которые мы регистрируем.
```
internal protocol ServiceEntryProtocol: AnyObject {
func describeWithKey(_ serviceKey: ServiceKey) -> String
var objectScope: ObjectScopeProtocol { get }
var storage: InstanceStorage { get }
var factory: FunctionType { get }
var initCompleted: (FunctionType)? { get }
var serviceType: Any.Type { get }
}
```
**ServiceEntryProtocol** - это уже не объект-сервис, как в нашем простеньком сервис-локаторе. За этим протоколом стоит класс **ServiceEntry**, который знает, как создавать объект, где и как его хранить (зависит от скоупа), а также содержит необходимые данные для разруливания циклических зависимостей (через **initCompleted**).
Что такое **циклические зависимости**? Чтобы разобраться, сначала нужно понять, как контейнер создает зависимости. Когда вы запрашиваете у контейнера зависимость некоторого типа, она тоже может иметь зависимости, которые тоже могут иметь зависимости и так далее. При создании зависимости контейнер строит **ориентированный граф зависимостей**, основываясь не только на связях между ними, но и на типе их скоупа.
**Скоуп (scope) —** это тип, описывающий время жизни регистрируемой зависимости**.**
**Swinject** предоставляет четыре типа скоупа (но можно добавить и свой собственный скоуп): Graph, Transient, Container, Weak.
#### Graph
Дефолтный скоуп в Swinject. Зависимость разруливается в рамках построенного графа зависимостей. Например:
```
final class A {
private let b: B
init(b: B) {
self.b = b
}
}
final class B {
private let c: C
init(c: C) {
self.c = c
}
}
final class C {
private let a: A
init(a: A) {
self.a = a
}
}
let container = Container()
container.register(A.self) { r in
return A(b: r.resolve(B.self)!)
}
container.register(B.self) { r in
return B(c: r.resolve(C.self)!)
}
container.register(C.self){ r in
return C(a: r.resolve(A.self)!)
}
...
let a1 = container.resolve(A.self)!
let a2 = container.resolve(A.self)!
```
Для каждого резолва a1 и a2 строятся отдельные графы:
Важно понимать, что если вы запустите этот код, то поймаете ошибку в рантайме, потому что получите бесконечный цикл создания зависимостей. Такие кейсы как раз разруливаются с помощью .**initCompleted**, но об этом чуть позже.
#### Transient
Он же **prototype** или **unique** в других библиотеках. Зависимость создается заново при каждом резолве.
Зарегистрируем **A** со скоупом **transient**:
```
container.register(A.self) { r in
return A(b: r.resolve(B.self)!)
}
.inObjectScope(.transient)
```
Получим следующий граф при резолве:
####
#### Container
Он же **singleton** в других библиотеках. Думаю, суть понятна: один экземпляр на контейнер и дочерние контейнеры. Создается при первом резолве.
Зарегистрируем **B** со скоупом **container**:
```
container.register(B.self) { r in
return B(c: r.resolve(C.self)!)
}
.inObjectScope(.container)
```
Получим следующий граф при резолве:
#### Weak
Он же **WeakSingleton**. Зависимость будет существовать, пока на нее есть сильная ссылка снаружи. С графом, думаю, понятно — аналогично container.
### Обработка циклических зависимостей
Разруливание циклических зависимостей — мастхэв-фича для DI-библиотеки. В **Swinject** она реализуется через отложенную **property injection** внутри метода **initCompleted** для одной или нескольких зависимости в цикле.
То есть не получится использовать только **constructor injection,** чтобы разрулить цикл.
Например, для цикла, который мы рассматривали выше, можно переделать класс С, чтобы он поддерживал **property injection,** и добавить его реализацию в initCompleted:
```
final class C {
var a: A?
}
container.register(C.self) { _ in return C() }
.initCompleted { r, c in
c.a = r.resolve(A.self)
}
```
При резолве циклических зависимостей в **Swinject** последние могут создаваться несколько раз, что аффектит время резолва, и на больших циклах могут прилично аффектить время запуска приложения. Кроме того, нельзя точно сказать, какой именно из создавшихся объектов будет использован. В таких случаях лучше вынести все резолвы в цикле в initCompleted, что поможет избежать этой проблемы (подробнее — [здесь](https://github.com/Swinject/Swinject/blob/master/Documentation/CircularDependencies.md)).
### Swinject Autoregistration
**Swinject** также предоставляет упрощенный синтаксис для регистрации — **Autoregistration**. То есть вместо того, чтобы писать так:
```
container.register(MyServiceProtocol.self) { r in
MyService(dependencyA: r.resolve(DependencyA.self)!,
dependencyB: r.resolve(DependencyB.self)!,
dependencyC: r.resolve(DependencyC.self)!,
dependencyD: r.resolve(DependencyD.self)!)
}
```
Можно писать намного короче:
```
container.autoregister(MyServiceProtocol.self, initializer: MyService.init)
```
Удобная фича, но за удобство приходится платить скоростью. Использование авторегистрации замедляет время резолва, а значит, и время запуска приложения. На больших проектах при очень большом количестве зависимостей это будет критично. Насколько именно критично — узнаем чуть позже, а пока предложу альтернативу, которая чуть короче обычного синтаксиса, но быстрее авторегистрации:
```
prefix operator
prefix func <? <Service(_ resolver: Resolver) -> Service? {
return resolver.resolve(Service.self)
}
prefix operator <~
prefix func <~ (\_ resolver: Resolver) -> Service {
return (resolver)!
}</code
```
И это все! Теперь можно писать чуть короче:
```
container.register(MyServiceProtocol.self) { r in
MyService(dependencyA: <~r,
dependencyB: <~r,
dependencyC: <~r,
dependencyD: <~r)
}
```
Плюс ко всем вышеописанным плюшкам **Swinject** также дает возможность:
1. Строить иерархии контейнеров.
2. Разбивать регистрацию на модули (**Assembly**).
3. Работать со сторибордами.
4. Обеспечить потокобезопасность. **Container** не потокобезопасен по умолчанию, но метод **synchronize** дает нам потокобезопасный резолвер:
```
let threadSafeContainer: Resolver = container.synchronize()
```
#### Минусы Swinject
Главный недостаток **Swinject** в том, что его очень легко можно использовать как **сервис-локатор**. В таком случае он наследует все проблемы, описанные в разделе о **SL**.
**Swinject** тоже имеет **runtime**-природу со всеми вытекающими. Если вы резолвите зависимость, которую не регистрировали, то узнаете об этом только при краше в рантайме. Вы можете сказать, что с вами этого не случится, так как вы никогда не забываете регистрировать зависимости. Но реально в больших проектах такое вполне может происходить. Например, может потребоваться добавить аргумент при резолве уже существующей зависимости, которая используется в разных модулях. С этого момента при резолве без аргумента вы получите краш в рантайме. Забыли добавить аргумент при резолве в одном из модулей? Что вам об этом скажет **Swinject**? К сожалению, ничего.
DIP
---
[https://](https://github.com/Swinject/Swinject)[github.com/AliSoftware/Dip](https://github.com/AliSoftware/Dip)
888 звезд на «Гитхабе». Тоже довольно популярная библиотека, очень похожая на **Swinject** в плане синтаксиса:
```
let container = DependencyContainer()
container.register { ServiceImp() as Service }
...
let service = try! container.resolve() as Service
```
Обладает практически таким же набором фич, как **Swinject**, с несколькими отличиями:
1. Нет поддержки иерархии контейнеров и разбиения регистрации на модули.
2. Потокобезопасность — по умолчанию (можно отключить через аргумент в DependencyContainer.init).
3. Есть фича валидации. Можно провалидировать контейнер, что все зависимости, которые были зарегистрированы, будут зарезолвлены без ошибок.
4. Кроме уже описанных скоупов, которые есть у **Swinject**, добавляет также **EagerSingleton** — «нетерпеливый синглтон». Суть в том, что этот синглтон создается при вызове container.bootstrap(), а не при первом резолве синглтона. Метод bootstrap фиксирует зависимости в контейнере, не давая добавить новые зависимости или удалить старые после его вызова.
Внутри устроен похожим на **Swinject** образом:
```
public final class DependencyContainer {
...
var definitions = [DefinitionKey: _Definition]()
...
}
```
**Ключ** также хранит информацию о типе и аргументах. Тэг — аналог поля name в **Swinject** — используется для регистрации одного типа под разными тэгами.
```
public struct DefinitionKey: Hashable, CustomStringConvertible {
public let type: Any.Type
public let typeOfArguments: Any.Type
public private(set) var tag: DependencyContainer.Tag?
...
}
```
**Definition** — обертка для зависимости, которая знает ее тип, скоуп и как создавать зависимость.
Как и **Swinject, DIP** может быть легко использован как **сервис-локатор** со всеми вытекающими. Некоторые разработчики предпочитают использовать DIP на старте проекта или на небольших проектах, объясняя это тем, что он проще, чем Swinject (спорное утверждение). Но когда «небольшой проект» разрастается, они с ужасом замечают, что время запуска приложения стало чертовски долгим. Дело в том, что **DIP** значительно медленнее, чем **Swinject**. Хотите узнать насколько? Не переключайтесь.
DITranquillity
--------------
[https://](https://github.com/Swinject/Swinject)[github.com/ivlevAstef/DITranquillity](https://github.com/ivlevAstef/DITranquillity)
316 звезд на «Гитхабе». Синтаксис немного отличается от **Swinject** и **DIP**. Во-первых, «авторегистрация» из коробки, что удобно, но за это приходится платить увеличением времени резолва. Во-вторых, resolve без необходимости использовать ! и try! — тоже хорошо.
```
let container = DIContainer()
container.register(MyService.init).as(MyServiceProtocol.self)
...
let router: MyServiceProtocol = container.resolve()
```
Потокобезопасность также из коробки, отключить нельзя. Доступна модульность и иерархии контейнеров.
Несколько новых скоупов: **perRun** (один на каждый запуск приложения), **perContainer** (один на каждый контейнер) и **single** (типа синглтон, но создается сразу после вызова .**initializeSingletonObjects**() у контейнера).
Доступна **валидация графа**, то есть библиотека может проверить граф зависимостей еще до извлечения зависимостей. Когда регистрируем все зависимости, [получаем граф](https://github.com/ivlevAstef/DITranquillity/blob/master/Documentation/ru/graph/get_graph.md), вызываем функцию проверки **checkIsValid**, и она проверяет, что все зарегистрировано верно, иначе бросает ошибку со ссылкой на файл и строку, где ошибка возникает, — также очень удобно.
```
#if DEBUG
if !container.makeGraph().checkIsValid(checkGraphCycles: true) {
fatalError("invalid graph")
}
#endif
```
Под капотом в целом суть та же, хотя на первый взгляд кажется, что все сложнее, чем в **Swinject** и **DIP**.
Объекты под капотом хранятся в специальном объекте за протоколом:
```
public protocol DIStorage {
/// Return all storaged object if there is.
var any: [DIComponentInfo: Any] { get }
...
}
/// Short information about component. Needed for good log
public struct DIComponentInfo: Hashable, CustomStringConvertible {
/// Any type announced at registration the component
public let type: DIAType
/// File where the component is registration
public let file: String
/// Line where the component is registration
public let line: Int
...
}
```
Ключ содержит информацию не только о типе, но и о файле и строке, где зависимость регистрировалась. Это нужно как раз для того, чтобы выдавать точные логи при проверке графа зависимостей.
Автор библиотеки даже сравнил скорость своей библиотеки со **Swinject** на большом количестве регистраций(>1000) и простых графах зависимостей. По результатам этих тестов, **DITranquility** быстрее, чем **Swinject** (можно глянуть [здесь](https://github.com/ivlevAstef/DITranquillity/tree/master/Samples/CompareSpeedSwinjectVSTranquillity)).
EasyDI
------
[https://](https://github.com/Swinject/Swinject)[github.com/TinkoffCreditSystems/EasyDi](https://github.com/TinkoffCreditSystems/EasyDi)
88 звезд на «Гитхабе». Отличается от предыдущих в плане синтаксиса. В отличие от предыдущих библиотек, уже не располагает к использованию себя в качестве сервис-локатора:
```
final class ServiceAssembly: Assembly {
var apiClient: APIClient {
return define(init: APIClient())
}
}
```
То есть мы не регистрируем и не резолвим зависимости явно, а создаем специальный объект — **Assembly**, который выступает провайдером зависимостей и сам строит граф зависимостей под капотом. Все Assembly существуют в рамках некоторого контекста **DIContext**.
```
public final class DIContext {
public static var defaultInstance = DIContext()
fileprivate var assemblies: [String: Assembly] = [:]
var objectGraphStorage: [String: InjectableObject] = [:]
...
}
```
Как видим, дефолтный **DIContext** статический и создается по умолчанию. Он контролирует граф зависимостей всех подконтрольных **Assembly**, то есть граф общий для всех ассембли внутри одного контекста. Сам граф зависимостей реализован с помощью словаря. Ключом в данном случае выступает имя типа **Assembly** + имя переменной нашей зависимости. А объект — это просто **Any**.
```
public typealias InjectableObject = Any
```
Предоставляет четыре уже знакомые нам скоупа: **prototype**, **objectGraph**, **lazySingleton** и совсем недавно добавленный **weak singleton**. Кроме того, можно строить иерархии **Assembly**. Есть фича подмены объектов для тестирования.
Библиотека довольно проста в использовании и реализации и занимает всего чуть более 200 строк кода.
Кроме того, получаем потокобезопасность из коробки. Плюс нет явной фазы регистрации зависимостей, а значит, нельзя забыть зарегистрировать то, что нам понадобится.
Плюсы и минусы библиотек на рефлексии
-------------------------------------
Плюсы:
1. Просты в использовании, невысокий порог входа.
2. В реализации относительно несложно разобраться.
Минусы:
1. Довольно легко использовать как сервис-локаторы и получить связанные с этим проблемы.
2. Вся магия происходит в рантайме — значит, и ошибки получаем в рантайме и не у всех библиотек есть возможность валидации графа.
3. Аффектят время запуска приложения (опять-таки из-за своей рантайм-природы).
Несмотря на достаточное количество минусов, остаются самыми популярными решениями для **DI** в **iOS**.
Библиотеки, основанные на кодогенерации
---------------------------------------
Сначала давайте разберемся, как работают подобные библиотеки. Если вкратце, вы помечаете проперти своего класса неким атрибутом или наследуете свои компоненты от определенного протокола, а библиотека (или в данном случае уже скорее фреймворк), генерирует код, который эти проперти/зависимости внедряет. И это все. Вам больше ничего делать не нужно — только использовать свои зависимости.
Если пока не стало понятно — ничего, разберемся на примерах.
Needle
------
[https://](https://github.com/Swinject/Swinject)[github.com/uber/needle](https://github.com/uber/needle)
822 звезды на «Гитхабе». Набирающая популярность библиотека от разработчиков **Uber**. Работает на базе [SourceKit](https://github.com/apple/swift/tree/master/tools/SourceKit).
Главным преимуществом, по словам разработчиков, является обеспечение **compile time safety** кода работы для внедрения зависимостей. Контейнеры зависимостей должны наследоваться от класса **Component**. Зависимости DI-контейнера описываются в протоколе, который наследуется от базового протокола зависимостей **Dependency** и указывается в качестве generic типа самого контейнера.
```
protocol MyDependency: Dependency {
var chocolate: Food { get }
var milk: Food { get }
}
final class MyComponent: Component {
var hotChocolate: Drink {
return HotChocolate(dependency.chocolate, dependency.milk)
}
var myChildComponent: MyChildComponent {
return MyChildComponent(parent: self)
}
}
```
В примере также видим, как дочерние компоненты создаются в родительских. Очень напоминает Assembly в **EasyDI**, правда? Хотя под капотом они работают абсолютно по-разному. Каждый раз при сборке проекта генератор кода **Needle** анализирует исходный код проекта и ищет всех наследников класса **Component** - базового классов для DI-контейнеров**.**
У каждого DI-контейнера есть протокол описания зависимостей. Для каждого такого протокола генератор анализирует доступность каждой зависимости путем поиска ее среди родителей контейнера. Поиск идет снизу вверх — от дочернего компонента к родительскому. Зависимость считается найденной, только если совпадают имя и тип зависимости.
Если зависимость не найдена, то сборка проекта останавливается с ошибкой, в которой указывается потерянная зависимость. Это дает заявленную выше **compile-time safety**.
### Плюсы и минусы Needle
Плюсы:
1. Compile-time safety — все проверки и ошибки во время компиляции.
2. Время запуска приложения не аффектится с ростом числа зависимостей.
3. Потокобезопасность из коробки.
4. Поддержка иерархии компонентов.
Минусы:
1. Пока что всего два варианта скоупа: **shared** (по сути — container) и **prototype**, но в теории можно ими обойтись.
2. Порог входа выше, чем у сервис-локаторов, хоть и не намного.
Мне самому **Needle** зашел. Потенциально хорошая альтернатива **Swinject**. Несмотря на номер последней версии [**v0.17.1**](https://github.com/uber/needle/releases/tag/v0.17.1), разработчики говорят, что библиотека production ready и уже используется во всех приложениях Uber.
Более подробно о библиотеке можно почитать [здесь.](https://habr.com/ru/company/joom/blog/514784/)
Weaver
------
[https://](https://github.com/Swinject/Swinject)[github.com/scribd/Weaver](https://github.com/scribd/Weaver)
543 звезды на «Гитхабе». Также основана на кодогенерации, использует **SourceKitten**, основанный на **SourceKit**. Но работает несколько иначе, чем **Needle**, а именно — через аннотации к зависимостям. Тот, кто немного знаком с миром **Android** и **Dagger**, сразу поймет, о чем речь. Аннотации в нашем случае — комментарии определенного формата или специальные **property wrapper**’ы.
Например:
```
final class MyClass {
// weaver: movieManager = MovieManager <- MovieManaging
// weaver: movieManager.scope = .container
...
}
```
или
```
final class MyClass {
@Weaver(.registration, type: MovieManager.self, scope: .container)
private var movieManager: MovieManaging
...
}
```
Первый вариант мне лично не нравится из-за «хрупкости» комментариев, но этот вариант был единственным до появления проперти врапперов в Swift 5.1. Второй вариант был вполне ожидаемым после их появления.
**Weaver** сканирует код проекта в поисках аннотаций, строит граф зависимостей и генерирует все, что нужно для DI, а именно контейнер **MainDependencyContainer**, у которого можно получить **DependencyResolver** для каждой зависимости.
Аннотации в Weaver бывают трех видов — **register**, **reference** и **parameter:**
1. **Register**
```
// weaver: dependencyName = DependencyConcreteType <- DependencyProtocol
@Weaver(.registration, type: DependencyConcreteType.self)
var dependencyName: DependencyProtocol
```
Добавляет зависимость в контейнер и предоставляет доступ к зависимости.
2. **Reference**
```
// weaver: dependencyName <- DependencyType
@Weaver(.reference)
var dependencyName: DependencyType
```
Только предоставляет доступ (ссылку) к зависимости.
3. **Parameter**
```
// weaver: parameterName <= ParameterType
@Weaver(.parameter)
var parameterName: ParameterType
```
Параметр, который будет передаваться в объект при инициализации.
Все объекты, где мы добавляем аннотации, должны предоставлять стандартный init c аргументом резолвером соответствующего генерируемого типа, что выглядит как костыль:
```
required init(injecting _: MyDependencyResolver) {
// no-op
}
```
Библиотека предоставляет уже знакомые нам четыре скоупа: **transient**, **container**, **weak**, **lazy**.
### Плюсы и минусы Weaver
Плюсы:
1. Относительно проста в использовании.
2. Compile time safety.
3. Умеет генерировать стабы для тестов.
Минусы:
1. Фактически библиотека принуждает нас использовать **PropertyInjection**.
2. Костыльный конструктор у всех зависимостей.
3. Порог вхождения выше, чем у needle. Неинтуитивные для понимания register/reference/parameter.
4. Код самих объектов, в которые мы инжектим зависимости, зависит от нюансов библиотеки, а значит, поменять библиотеку на другую без изменения кода самих объектов не получится.
Плюсы и минусы библиотек на кодогенерации
-----------------------------------------
Плюсы:
1. Compile time safety, избавление от крашей в рантайме.
2. Не аффектят скорость запуска приложения.
Минусы:
1. Немного сложнее для понимания, чем register/resolve-контейнеры.
2. Объекты зависят от нюансов библиотеки (наследуют специальные протоколы или используют специальные атрибуты у полей).
Часть 4. Битва контейнеров
--------------------------
Попробуем сравнить производительность рассмотренных выше библиотек на растущем количестве зависимостей.
Пусть каждая регистрируемая зависимость имеет от 0 до 3 зависимостей, часть которых также зависит друг от друга. Замеры будем делать на iPad 2017 (по железу — аналог iPhone 6s) iOS 13,5 (время в секундах) в релизной конфигурации(с оптимизациями).
Итак, что мы имеем?
1. **DIP** — аутсайдер в этой битве.
2. **Swinject** и **DITranquillity** — самые быстрые на 100 регистрациях, но деградируют на росте регистраций до 1000. При этом DITranquillity деградирует медленнее.
3. **SwinjectAutoregistration** делает свинжект еще немного медленнее.
4. **EasyDI** медленнее Swinject и DITranquillity на 100 регистрациях, но зато рост регистраций слабо аффектит время его работы. И на 1000 регистраций он уже быстрее чем Swinject**.**
Уточню, после оптимизаций в версии 4.2 производительность **DITranquillity** сильно выросла. До версии 4.2 производительность была прилично ниже.
Казалось бы, вот оно! Мы нашли фаворитов и можно идти внедрять их в свои проекты! Расходимся! Но нет, не все так просто. Мы ведь рассматривали простой граф зависимостей. У каждой регистрируемой зависимости было от 0 до 3 зависимостей. Это довольно мало, и в крупных и сложных проектах ситуация явно хуже.
Давайте рассмотрим некоторый «худший» случай в противовес простому. Допустим, у каждой регистрируемой зависимости будет 10 своих зависимостей, которые также зависимы между собой.
Как видим, ситуация сильно меняется. **Swinject** все еще деградирует на росте регистраций, но его время заметно меньше, чем у других библиотек, кроме **DITranquillity**.Видимо, работа со сложным графом в **Swinject** и **DITranquillity** оптимизирована лучше. При этом DITranquillityобгоняет Swinject при достижении уже 500 регистраций.
Отмечу, что время отдельно взятой библиотеки само по себе малоинформативно, важны лишь их значения относительно друг друга, потому что:
1. При тестах считалось среднее время по замерам 100 тестов подряд. И первая итерация обычно выполнялась медленнее, чем последующие.
2. Объекты, регистрируемые в тестах, по сути — пустышки, не содержащие бизнес-логики, а значит, время их создания меньше, чем у объектов в реальных проектах.
Так как проекты обычно становятся все сложнее и сложнее, добавляются все новые и новые фичи, рано или поздно рост количества регистраций и сложности графа зависимостей может привести к критически большому времени запуска приложения, это надо иметь в виду. Возможно, в таких случаях имеет смысл перейти на DI-библиотеку, основанную на **кодогенерации**, ведь у них вся магия происходит во время компиляции, а не в рантайме.
Но и с библиотеками на кодогенерации тоже не все так просто :)
Давайте проверим, как сказывается рост числа зависимостей на времени компиляции. Рассмотрим уже упомянутые **Needle** и **Weaver**.
Даже несмотря на то, что обе библиотеки работают на базе **SourceKit**, время компиляции отличается на порядок при большом количестве зависимостей. На этом примере можно понять, как важна оптимизация в таких библиотеках.
Заключение
----------
Вот какие выводы можно сделать из вышесказанного:
1. Многие из популярных в iOS DI-библиотек позволяют использовать их как **сервис-локаторы**, то есть в некотором смысле они ближе к сервис-локаторам, чем к DI-контейнерам.
2. Работа многих DI-библиотек основана на общих принципах и инструментах, но общие принципы можно реализовать по-разному. Например, время работы контейнеров, основанных на **рефлексии**, очень разнится и зависит не только от количества зависимостей, но и от сложности самого графа зависимостей (ну и от реализации самого контейнера, конечно). Или, например, время компиляции для библиотек, основанных на **кодогенерации**, тоже очень разнится.
3. Оптимизация работы DI-библиотек очень важна, так как аффектит запуск приложения или его время сборки.
Какую библиотеку выбрать для своего проекта?
Зависит от ситуации. На небольших проектах **Swinject** может быть хорошим вариантом. Если вы уже используете **Swinject** (или любую другую register/resolve библиотеку) и вас критически не устраивает время запуска приложения, присмотритесь к **Needle**.
А еще всегда можно сделать свой **DI** c блэкджеком и оптимизацией. Можно это сделать довольно просто, например через фабрики, но это уже совсем другая история...
### Ссылки на тестовые проекты
1. <https://github.com/vitalybatrakov/iOS_DI_Libs_Performance_Tests>
2. <https://github.com/vitalybatrakov/iOS_DI_Libs_Compilation_Time_Tests>
### Что почитать/посмотреть
1. <https://martinfowler.com/articles/injection.html>
2. <https://www.youtube.com/watch?v=-JGGw4SN6NA&ab_channel=AvitoTech>
3. <https://jonfir.github.io/posts/ioc-ios/>
4. <http://sergeyteplyakov.blogspot.com/2013/03/di-service-locator.html>
5. <http://sergeyteplyakov.blogspot.com/2014/11/di-vs-dip-vs-ioc.html>
6. <https://tech.badoo.com/ru/article/411/singlton-lokator-servisov-i-testy/>
7. <https://habr.com/ru/company/joom/blog/514784/> | https://habr.com/ru/post/546360/ | null | ru | null |
# ESP32-C3: первое знакомство. Заменим ESP8266?
Новая игрушка
-------------
В ноябре 2020 года Espressif [анонсировала](https://www.espressif.com/en/news/ESP32_C3) новую SoC под названием [ESP32-C3](https://www.espressif.com/en/products/socs/esp32-c3). Они разослали несколько инженерных прототипов для тестирования и первого ознакомления.
ESP32-C3-DevKitM-1Так довелось, что мне попался один из них на руки и я успел немного поиграться с ним. Надеюсь, мой краткий опыт будет интересен сообществу, так как тут есть на что посмотреть и ESP32-C3 имеет хороший шанс получить свою нишу в мире встраиваемых систем, так и в области DIY. Меня как раз больше интересует подход со стороны DIY, поэтому статья будет больше с этим уклоном.
В чём разница?
--------------
ESP32-C3 пытается занять нишу между [ESP32](https://www.espressif.com/en/products/socs/esp32)/[ESP32-S](https://www.espressif.com/en/products/socs/esp32-s2) и нашим старым другом [ESP8266](https://www.espressif.com/en/products/socs/esp8266). Даже больше хочет вытеснить ESP8266, чем быть дополнением к линейке ESP32.
Не знаю что там будет с ценами, но переход на RISC-V, упрощение периферии и прочее может сделать ESP32-C3 достаточно привлекательным, что бы он смог заменить ESP8266 полностью. В итоге мы получим достойную замену старичку, с которым мы вместе с 2014 года.
В таблице ниже я привёл основные отличия ESP32-C3 от предыдущих ESP32 и ESP32-S2. Так же у Espressif недавно был анонсирован [ESP32-S3](https://www.espressif.com/en/products/socs/esp32-s3) с двумя ядрами, но я пока не буду его приводить ниже в силу отсутствия его в широкой продаже.
| | | | |
| --- | --- | --- | --- |
| | [ESP32](https://www.espressif.com/en/products/socs/esp32) | [ESP32-S2](https://www.espressif.com/en/products/socs/esp32-s2) | [ESP32-C3](https://www.espressif.com/en/products/socs/esp32-c3) |
| CPU | Xtensa LX6 | Xtensa LX7 | RISC-V (RV32IMC) |
| Частота CPU | 160 / 240 MHz | 160 / 240 MHz | 160 MHz |
| Количество ядер CPU | 2 / 1 | 1 | 1 |
| ULP CPU | ULP-FSM | ULP-RISC-VULP-FSM | - |
| SRAM | 520 KB | 320 KB | 400 KB |
| RTC SRAM | 16 KB | 8 KB | 8 KB |
| WiFi | 802.11bgn150 Mbit | 802.11bgn, 802.11mc150 Mbit | 802.11 bgn, 802.11mc150 Mbit |
| Bluetooth | 4.2 BR/EDR BLE | - | Bluetooth 5 |
| GPIO | 34 | 43 | 22 |
| 12-bit ADC | 118 каналов | 220 каналов | 26 каналов |
| 8-bit DAC | 2 | 2 | - |
| Touch sensor | 10 | 14 | - |
| SPI | 4 | 4 | 3 |
| I2S | 2 | 1 | 1 |
| I2C | 2 | 2 | 1 |
| UART | 3 | 2 | 2 |
| SDIO | 1 | - | - |
| Ethernet MAC | 1 | - | - |
| PWM | 16 | 8 | 6 |
| USB OTG | - | 1 | - |
| Потребление | До 240 мА | До 310 мА | До 325 мА |
| Modem sleep | 27 - 68 мА | 12 - 19 мА | 15 - 20 мА |
| Light sleep | 0,8 мА | 0,45 мА | 0,13 мА |
| Deep sleep | 0,01 - 0,15 мА | 0,02 - 0,19 мА | 0,005 мА |
| Корпус | 48 выводов | 56 выводов | 32 выводаКак ESP8266, но не все выводы такие же |
DevKit плата
------------
ESP32-C3 приехал ко мне в виде платы [ESP32-C3-DevKitM-1](https://www.espressif.com/sites/default/files/documentation/esp32-c3-mini-1_datasheet_en.pdf), на которой установлен модуль ESP32-C3-Mini-1 со встроенной 4 МБ флеш-памятью.
ESP32-C3-DevKitM-1 вид сверху и снизуТак же на этой плате стоит USB-Serial конвертер CP2102 для подключения и прошивки по USB. На GPIO подключен RGB светодиод WS2812.
Сам модуль ESP32-C3-Mini-1 физически по размеру заметно меньше того же ESP-12E на базе ESP8266. И в то же время ESP32-C3 имеет намного больше возможностей.
"Engineering Sample Notes"
--------------------------
ESP32-C3-DevKitM-1 коробкаС платой была одностраничное приложение с некоторыми пометками.
Например, там написано, что потребление на DevKit'е ещё не достаточно оптимизировано и потому не рекомендуется для оценки в Deep-sleep режиме.
Так же сказано, что в данной версии чипа поддержка USB Serial/JTAG отсутствует, но она будет присутствовать в финальной версии.
Текущая версия ESP-IDF в процесс работы по добавлению поддержки ESP32-C3. Работа в этом направлении ведётся в ветках "master" и "release/v4.3".
Поддержка ESP-IDF
-----------------
[ESP-IDF](https://github.com/espressif/esp-idf) является официальным фреймворком для разработки под ESP32. Сама среда поддерживает всю линейку ESP32. Большинство примеров можно собрать под Xtensa LX6/LX7, так и под RISC-V. Переключение сводится к одной команде "idf.py set-target esp32c3", которая выставляет riscv32-esp-elf- и прочие параметры в sdkconfig. Теперь после компиляции у нас готова прошивка для нового ESP32-C3.
Предварительно надо подготовить окружение в зависимости от ОС: [Windows](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/get-started/windows-setup.html), [Linux](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/get-started/linux-setup.html) или [macOS](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/get-started/macos-setup.html).
```
git clone --recursive https://github.com/espressif/esp-idf.git
cd esp-idf
# Linux/macOS
./install.sh
# Windows
install.ps1
```
Установочный скрипт скачает компиляторы и дополнительные пакеты для ESP-IDF. После этого надо импортировать окружение для начала работы:
```
# Linux/macOS
. ./export.sh
# Windows
export.bat
```
Рекомендую для проверки собрать "hello world":
```
cd examples/get-started/blink
# По-умолчанию настроено для ESP32, но если надо собрать прошивку для ESP32-S2
idf.py set-target esp32s2
# Или для ESP32-C3
idf.py set-target esp32c3
# Сборка, прошивка, USB консоль
idf.py build flash monitor
```
Не все примеры собираются под ESP32-C3, но Espressif активно работает над ESP-IDF для поддержки этого чипа.
CoreMark
--------
Ради интереса запустил CoreMark бенчмарк для оценки производительности нового RISC-V ядра и сравнил эти данные с предыдущим ESP32 (к сожалению, у меня нет ESP32-S2 для более широкого сравнения).
Ниже приведены попугаи для разной частоты процессора и для общего ознакомления добавлены значения при компиляции с выключенными оптимизациями (-O0):
| | | | |
| --- | --- | --- | --- |
| | CoreMark 1.0 | GCC | Частота CPU |
| ESP32-C3 | 388 | GCC8.4.0 -O3 | 160 МГц |
| | 98 | GCC8.4.0 -O0 | 160 МГц |
| ESP32 (одно ядро) | 313 | GCC8.4.0 -O3 | 160 МГц |
| | 77 | GCC8.4.0 -O0 | 160 МГц |
| | 469 | GCC8.4.0 -O3 | 240 МГц |
| | 115 | GCC8.4.0 -O0 | 240 МГц |
Я сделал измерения ESP32-C3 на 80 МГц, но значения получились ровно в два раза ниже, что и предполагалось и поэтому в таблице не привожу.
В попугаях RISC-V получился примерно на 24% быстрее. Конечно, обычные задачи, которыми мы загружаем такие микроконтроллеры будут сильно отличаться от синтетических бенчмарков, но было интересно посмотреть.
Надо так же не забывать, что ESP32 поддерживает работу на частоте 240 МГц, а у ESP32-C3 максимальная частота только 160 МГц. Так же ESP32 имеет два ядра, которые можно задействовать в зависимости от задач.
Но повышенная частота 240 МГц так же скажется на потреблении устройства. То есть, ESP32-C3 за каждый попугай будет просить меньше электронов (я не измерял потребление, но есть несколько замеров других наблюдателей).
ESP RainMaker
-------------
Вместе с этой новой платой Espressif продвигает платформу [ESP RainMaker](https://rainmaker.espressif.com/). Это некая среда, которая позволяет быстро создавать концепты и прототипы для IoT устройств.
На ESP32-C3-DevKitM-1 плате уже была прошивка ESP RainMaker, с которой можно получить общее представление об этом платформе.
Идея примерно такова:
На плате настроен обычный бинарный переключатель. При подключении платы через USB консоль мы получаем QR код, который надо отсканировать в приложении ESP RainMaker (доступно для Android и iOS) для первоначальной конфигурации настроек WiFi и добавлении этого устройства в приложение.
После этого можно управлять встроенным RGB светодиодом на плате через Espressif облако, которое находится на Amazon AWS.
ESP RainMaker SDK позволяет создавать разнообразные устройства, не только бинарный переключатель как в примере. Это может быть датчик измерения температуры или влажности, LCD экран, несколько выключателей сразу или много разных устройств вместе сразу. В последнем случае одна плата будет показана как несколько устройств в приложении.
Для того, что бы поиграться с ESP RainMaker не обязательно ждать когда можно купить ESP32-C3. Сама платформа замечательно работает на ESP32 и ESP32-S2. Для сборки прошивки достаточно иметь настроенный ESP-IDF:
```
git clone --recursive https://github.com/espressif/esp-rainmaker.git
cd esp-rainmaker/examples/switch
# По-умолчанию настроено для ESP32, но если надо собрать прошивку для ESP32-S2
idf.py set-target esp32s2
# Или для ESP32-C3
idf.py set-target esp32c3
# Сборка, прошивка, USB консоль
idf.py build flash monitor
```
В консоле появится QR код и дальше уже всё в приложении.
Выводы
------
Большее количество микроконтроллеров для фанатов DIY всегда позитивно, так как при большем выборе можно подобрать более подходящий МК и плату в зависимости от того, что более важно в новом проекте.
Всегда будут востребованы микроконтроллеры с большим количеством периферии, так и мелкие с хорошим соотношением потребления к производительности, но имеют достаточно памяти для разных свистелок и хотелок.
Отдельное спасибо Espressif за то, что сделали WiFi доступным для встраиваемых устройств 7 лет назад. А там и другие производители подтягиваются. Мы только в плюсе. | https://habr.com/ru/post/541874/ | null | ru | null |
# Введение в OpenCV применительно к распознаванию линий дорожной разметки
Привет, Хабр! Публикуем материал выпускника нашей [программы Deep Learning](http://newprolab.com/ru/deeplearning?utm_source=habr&utm_campaign=daniluyk) и координатора программы по большим данным, Кирилла Данилюка о его опыте использования фреймворка компьютерного зрения OpenCV для определения линий дорожной разметки.
Некоторое время назад я начал программу от Udacity: [“Self-Driving Car Engineer Nanodegree”](https://www.udacity.com/drive). Она состоит из множества проектов по различным аспектам построения системы вождения на автопилоте. Представляю вашему вниманию мое решение к первому проекту: простой линейный детектор дорожной разметки. Чтобы понять, что в итоге получилось, посмотрите сначала видео:
Цель данного проекта — построить простую линейную модель для покадрового распознавания полос движения: на вход получаем кадр, серией трансформаций, о которых поговорим далее, обрабатываем его, получаем отфильтрованное изображение, которое можно векторизовать и обучить две независимых линейных регрессии: по одной для каждой полосы. Проект намеренно простой: только линейная модель, только хорошие погодные условия и видимость, только две линии разметки. Естественно, это не продакшн-решение, однако даже такой проект позволяет вдоволь наиграться с OpenCV, фильтрами и, в целом, помогает почувствовать, с какими трудностями сталкиваются разработчики автопилотов в автомобилях.
Принцип работы детектора
------------------------
Процесс построения детектора состоит из трех основных шагов:
1. Предобработка данных, фильтрация от шума и векторизация изображения.
2. Обновление состояния линий дорожной разметки по данным из первого шага.
3. Рисование обновленных линий и других объектов на исходном изображении.
Сначала на вход функции `image_pipeline` подается 3-канальное изображение формата RGB, которое затем фильтруется, преобразовывается, а внутри функции обновляются объекты `Line` и `Lane` . Затем поверх самого изображения рисуются все необходимые элементы, как показано ниже:
Я старался подходить к задаче в стиле ООП (в отличие от большинства аналитических задач): так, чтобы каждый из шагов получился изолированным от других.
Шаг 1: Предварительная обработка и векторизация
-----------------------------------------------
Первая стадия нашей работы хорошо знакома data scientist-ам и всем, кто работает с “сырыми” данными: сперва мы должны сделать предобработку данных, а затем векторизовать в понятный для алгоритмов вид. Общий пайплайн для предобработки и векторизации исходного изображения следующий:
````
blank_image = np.zeros_like(image)
hsv_image = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
binary_mask = get_lane_lines_mask(hsv_image, [WHITE_LINES, YELLOW_LINES])
masked_image = draw_binary_mask(binary_mask, hsv_image)
edges_mask = canny(masked_image, 280, 360)
# Correct initialization is important, we cheat only once here!
if not Lane.lines_exist():
edges_mask = region_of_interest(edges_mask, ROI_VERTICES)
segments = hough_line_transform(edges_mask, 1, math.pi / 180, 5, 5,
````
В нашем проекте используется OpenCV — один из самых популярных фреймворков для работы с изображениями на пиксельном уровне с помощью матричных операций.
Сначала мы преобразуем исходное RGB-изображение в HSV — именно в этой цветовой модели удобно выделять диапазоны конкретных цветов (а нас интересуют оттенки жёлтого и белого для определения полос движения).
Обратите внимание на скриншот ниже: выделить «всё жёлтое» в RGB гораздо сложнее, чем в HSV.
После перевода изображения в HSV некоторые рекомендуют применить размытие по Гауссу, но в моём случае оно снизило качество распознавания. Следующая стадия — бинаризация (преобразование изображения в бинарную маску с интересующими нас цветами: оттенками желтого и белого).
Наконец, мы готовы векторизировать наше изображение. Применим два преобразования:
1. [Детектор границ Кэнни](https://medium.com/@tempflip/lane-detection-with-numpy-56b923245fc9#.ek9oe9ucu): алгоритм оптимального определения границ, который рассчитывает градиенты интенсивности изображения, а затем с помощью двух порогов удаляет слабые границы, оставляя искомые (мы используем `(280, 360)` ) как пороговые значения в функции `canny` .
2. Преобразование Хафа: получив границы с помощью алгоритма Кэнни, мы можем соединить их с помощью линий. Я не хочу вдаваться в математику алгоритма — она достойна отдельного поста — эта ссылка или ссылка выше поможет вам, если вас заинтересовал метод. Главное, что, применив это преобразование, мы получаем набор линий, каждая из которых, после небольшой дополнительной обработки и фильтрации, становится экземпляром класса Line с известным углом наклона и свободным членом.
Очевидно, что верхняя часть изображения вряд ли будет содержать линии разметки, поэтому её можно не принимать в расчёт. Способов два: либо сразу закрасить верх нашей бинарной маски черным, либо подумать над более умной фильтрацией линий. Я выбрал второй способ: я посчитал, что всё, что находится выше линии горизонта, не может быть линией разметки.
Линию горизонта (vanishing point) можно определить по той точке, в которой сходится правая и левая полоса движения.
Шаг 2: Обновление линий дорожной разметки
-----------------------------------------
Обновление линий дорожной разметки будет происходить с помощью функции `update_lane(segments)` в `image_pipeline` , которая на вход получает объекты `segments` с последнего шага (которые на самом деле являются объектами `Line` из преобразования Хафа).
Для того, чтобы облегчить процесс, я решил использовать ООП и представлять линии дорожной разметки как экземпляры класса `Lane` : `Lane.left_line, Lane.right_line` . Некоторые студенты ограничились добавлением объекта `lane` в глобальный неймспейс, но я не фанат глобальных переменных в коде.
Рассмотрим подробнее классы `Lane` и `Line` и их экземпляры:
Каждый экземпляр класса `Line` представляет собой отдельную линию: кусок дорожной разметки или просто любую линию, которая будет определена преобразованием Хафа, в то время как главная цель объектов класса `Lane` — выявлять, является ли данная линия сегментом дорожной разметки. Чтобы это сделать, будем руководствоваться следующей логикой:
1. Линия не может быть горизонтальной и должна иметь умеренный уклон.
2. Разница между уклонами линии дорожной разметки и линии-кандидата не может быть слишком высокой.
3. Линия-кандидат не должна отстоять далеко от дорожной разметки, к которой она принадлежит.
4. Линия-кандидат должна быть ниже горизонта
Таким образом, для определения принадлежности к линии разметки мы используем достаточно тривиальную логику: принимаем решения исходя из уклона линии и расстояния до разметки. Способ неидеальный, но он сработал для моих простых условий
Класс `Lane` является контейнером для левой и правой линии разметки (рефакторинг так и просится). В классе также представлено несколько методов, относящихся к работе с линиями разметки, самый важный из которых `fit_lane_line` . Для того, чтобы создать новую линию разметки, я представляю подходящие сегменты разметки в виде точек, а затем аппроксимирую их полиномом первого порядка (то есть линией) с помощью обычной функции `numpy.polyfit`
**Стабилизация полученных линий дорожной разметки** очень важна: исходное изображение очень зашумлено, а определение полос происходит покадрово. Любая тень или неоднородность дорожного покрытия сразу меняет цвет разметки на такой, который наш детектор определить не в состоянии… В процессе работы я использовал несколько способов стабилизации:
1. *Буферы*. Полученная линия разметки запоминает N предыдущих состояний и последовательно добавляет состояние линии разметки на текущем кадре в буфер.
2. *Дополнительная фильтрация линий с учётом данных в буфере.* Если после преобразования и очистки мы не смогли избавиться от шума в данных, то есть вероятность, что наша линия окажется выбросом, а, как мы знаем, линейная модель чувствительна к выбросам. Поэтому для нас принципиально высокое значение точности — даже в ущерб значительной потери полноты. Проще говоря, лучше отфильтровать правильную линию, чем добавить в модель выброс. Специально для таких случаев, я создал `DECISION_MAT` — матрицу “принятия решения”, которая решает, как соотнести текущий уклон линии и среднее по всем линиям в буфере.
Например, для `DECISION_MAT = [ [ 0.1, 0.9] , [1, 0] ]` мы рассматриваем выбор из двух решений: считать линию нестабильной (т.е. потенциальным выбросом), либо стабильной (ее наклон соответствует среднему наклону линий данной полосы в буфере плюс/минус пороговое значение). Если линия нестабильна, мы всё равно хотим не потерять её: она может нести информацию о реальном повороте дороги. Просто учитывать её мы будем с маленьким коэффициентом (в данном случае — 0.1) Для стабильной линии мы просто будем использовать ее текущие параметры без какого либо взвешивания по предыдущим данным.
Индикатор стабильности линии разметки в текущем кадре описывается объектами класса `Lane` : `Lane.right_lane.stable` и `Lane.left_lane.stable` , которые являются булевыми. Если хотя бы одна из данных переменных принимает значение `False` , я визуализирую это как красный полигон между двумя линиями (ниже вы сможете увидеть, как это выглядит).
В результате мы получаем достаточно стабильные линии:
Шаг 3: Рисование и обновление исходного изображения
---------------------------------------------------
Для того, чтобы линии были нарисованы корректно, я написал довольно простой алгоритм, который вычисляет координаты точки горизонта, о которой мы уже с вами говорили. В моем проекте данная точка нужна для двух вещей:
1. Ограничить экстраполяцию линий разметки данной точкой.
2. Отфильтровать все линии Хафа, находящиеся выше горизонта.
Для визуализации всего процесса определения полос, я сделал небольшое `image augmentation`:
````
def draw_some_object(what_to_draw, background_image_to_draw_on, **kwargs):
# do_stuff_and_return_image
# Snapshot 1
out_snap1 = np.zeros_like(image)
out_snap1 = draw_binary_mask(binary_mask, out_snap1)
out_snap2 = draw_filtered_lines(segments, out_snap1)
snapshot1 = cv2.resize(deepcopy(out_snap1), (240,135))
# Snapshot 2
out_snap2 = np.zeros_like(image)
out_snap2 = draw_canny_edges(edges_mask, out_snap2)
out_snap2 = draw_points(Lane.left_line.points, out_snap2, Lane.COLORS['left_line'])
out_snap2 = draw_points(Lane.right_line.points, out_snap2, Lane.COLORS['right_line'])
out_snap2 = draw_lane_polygon(out_snap2)
snapshot2 = cv2.resize(deepcopy(out_snap2), (240,135))
# Augmented image
output = deepcopy(image)
output = draw_lane_lines([Lane.left_line, Lane.right_line], output, shade_background=True)
output = draw_lane_polygon(output)
output = draw_dashboard(output, snapshot1, snapshot2)
return output
````
Как видно из кода, я накладываю на исходное видео два изображения: одно с бинарной маской, второе — с прошедшими все наши фильтры линиями Хафа (трансформированными в точки). На само исходное видео я накладываю две полосы движения (линейная регрессия над точками из предыдущего изображения). Зелёный прямоугольник — индикатор наличия «нестабильных» линий: при их наличии он становится красным. Использование такой архитектуры позволяет достаточно легко менять и комбинировать кадры, которые будут высвечиваться в качестве дашборда, позволяя одновременно визуализировать множество компонентов и все это — без каких либо значительных изменений в исходном коде.
Что дальше?
-----------
Данный проект еще очень далек от завершения: чем больше я работаю над ним, тем больше вещей, требующих улучшения, я нахожу:
* Сделать детектор нелинейным, чтобы он мог с успехом работать, к примеру, в горах, где повороты на каждом шагу.
* Сделать проекцию дороги как «вид сверху» — это значительно упростит определение полос.
* Распознавание дороги. Было бы замечательно распознавать не только разметку, но и саму дорогу, что значительно облегчит работу детектора.
Весь исходный код проекта доступен на GitHub по [ссылке](https://github.com/dnkirill/carnd/blob/master/p1_lane_lines_detection/P1.ipynb).
P.S. А теперь сломаем все!
--------------------------
Конечно, в этом посте должна быть и забавная часть. Давайте посмотрим, как жалок становится детектор на горной дороге с частыми сменами направления и освещённости. Сначала всё, вроде бы, нормально, но в дальнейшем ошибка в определении полос накапливается, и детектор перестаёт успевать следить за ними:
А в лесу, где свет меняется очень быстро, наш детектор полностью провалил задание:
Кстати, один из следующих проектов — сделать нелинейный детектор, который как раз и справится с «лесным» заданием. Следите за новыми постами!
→ [Исходный пост в Medium на английском языке](https://medium.com/towards-data-science/carnd-project-1-lane-lines-detection-a-complete-pipeline-6b815037d02c). | https://habr.com/ru/post/328422/ | null | ru | null |
# Визуальный анализ качества кода
Всем добрый день!
Вдохновившись [одной gif-кой](http://habrastorage.org/getpro/habr/post_images/af4/46e/a40/af446ea40c52f4ddd85dfcaceabe31a6.gif) я решил, а что будет, если написать обратное приложение и смотреть на «карту» кода?
Во первых нам необходимо решить задачу «разместить столько то пикселей в квадрат».
Понятно, что в квадрат не всегда можно да и не нужно. Поэтому можно расположить их в прямоугольник с дополнением.
Не найдя алгоритма, который мне скажет, что 129=11\*12-3, я решил его написать сам.
**Немного ужасного кода**
```
public static ImageSize Generate(uint PixelsCount, double MaximumDeltaPercent=1f, uint MaximumAbsoluteDelta=10, double MaximumAspectRatio=1.77)
{
//check if this is empty image
if (PixelsCount==0) return new ImageSize(1,1);
//check if this is a square
double sqrt = Math.Truncate(Math.Sqrt(PixelsCount));
if (Math.Pow(sqrt, 2) == PixelsCount) return new ImageSize((ushort)sqrt, (ushort) sqrt);
//Путем тестов выяснено, что AspectRatio - штука, работающая на достаточно больших числах. Поэтому на маленьких мы ее отключаем.
if (PixelsCount<=10) MaximumAspectRatio = double.MaxValue;
double percentdelta = PixelsCount/(MaximumDeltaPercent*100);
uint height = (ushort) Math.Truncate(Math.Sqrt(PixelsCount));
uint width = (ushort) (height+1);
while (width/(height*1.0f)PixelsCount)
{
if ((Result-PixelsCount)<=percentdelta || Result-PixelsCount<=MaximumAbsoluteDelta)
{
if (width <= ushort.MaxValue && height <= ushort.MaxValue)
{
return new ImageSize((ushort) width, (ushort) height);
}
}
height--;
continue;
}
if (Result < PixelsCount)
{
width++;
}
}
throw new Exception(string.Format("Невозможно создать красивую картинку размером {0} пикселей с таким Aspect Ratio. Попробуйте большее значение\nОтладочная информация: PC:{0} MDP:{1} MAD:{2} MAR{3}",PixelsCount,MaximumDeltaPercent,MaximumAbsoluteDelta,MaximumAspectRatio));
}
```
После чего рисуем красивую картинку или в поток или в файлик.
Примеры получившихся картинок:
**Один из больших файлов моего мини-проекта** 
Код в среднем равномерно-серый с вкраплениями зеленого. Зато, полосатый.
**Explorer.exe из Win8.1** 
Исполняемый файл какой-то странный, с черной полосой посередине. ~~Что, в общем-то, очевидно.~~
В конце угадываются ресурсы иконок.
Примеры получившихся картинок:
**Workqueue.c из linux kernel** 
Код в среднем равномерно-серый с вкраплениями синего. В целом, он кажется синеватым.
В общем, экспериментируйте, надеюсь, ваш код не окажется равномерно-коричневого цвета!
[Исходник в архиве](http://yadi.sk/d/J-Auix_VJgvx2)
[Скомпилированная программа](http://yadi.sk/d/Zu1BO-RNJhMi8)
P.S. Если вдруг знаете красивый алгоритм превращения числа в произведение с остатком — очень прошу мне про него рассказать. | https://habr.com/ru/post/214165/ | null | ru | null |
# Last.fm Scrobbling
### Начало работы
В пабле нет ни одной нормальной библиотеки для работы с Last.FM «Submission» API PHP, пришлось разбираться и писать самому…
Для начала Вам необходимо перейти на страницу [регистрации вашего API аккаунта](http://www.lastfm.ru/api/account).
После ввода всех данных, Вам предоставят 2 ключа: публичный и секретный.
Все поля обязательны к заполнению:
* **Application/Device Name** — Имя вашего приложения
* **Application/Device Description** — Описание вашего приложения
* **Callback URL** — Ссылка на страницу вашего php скрипта, где вы будете принимать token (см.ниже)
### Общаемся с Last.FM
Теперь необходимо написать на почту submissions@last.fm для того чтобы Вам активировали собственный clientID.
Собственный clientID иметь в принципе не обязательно, но если вы хотите чтобы при прослушивании трека показывалось приложение, через которые проигрывается трек, то написать все же придется.
Вот немного смешной лог моей переписки:
**Я:** Здравствуйте.
Хочу приобрести собственный clientID для использования в моих запросах.
Сайт — [vpleer.ru](http://vpleer.ru) музыкальный поисковик. Хочу прикрутить scrobbling на last.fm
Спасибо
**Adrian:** Hey there,
I'm afraid I don't speak Russian, any way you could reword that request in English?
Regards, Adrian
**Я:** Okey, sorry for bad english..Hello.
I own clientID to use in my queries.
Website — [vpleer.ru](http://vpleer.ru) music search engine. I want to tie scrobbling to last.fm
Thanks. Understand me?)
**Adrian:** Hey there,
OK, I understood it this time. Your new client id is "\*\*\*" — you should be able to start using this an hour from now. Happy scrobbling!
Regards, Adrian
Вот так вот =) Свой clientID я предпочел скрыть т.к. если будут какие-либо проблемы по запросам с моего client ID, то могут прикрыть. (По крайней мере так написано у них в API)
### Приступаем к работе
Ваш пользователь должен перейти по ссылке: [www.lastfm.ru/api/auth?api\_key=](http://www.lastfm.ru/api/auth?api_key=)**MY\_PUBLIC\_KEY**, где **MY\_PUBLIC\_KEY** это ваш публичный ключ.
Далее если пользователь соглашается работать с этим приложением, то его перенаправляет на тот самый Callback URL с одним единственным GET запросом 'token'…
> `php<br/
> /\*
>
> Coded by Isis (c) 2010
>
> Link: www.lastfm.ru/api/auth?api\_key=8ea0be38326c1275db95968ab677cfb6
>
> \*/
>
> define('API\_KEY', '8ea0be38326c1275db95968ab677cfb6');
>
> define('API\_SECRET\_KEY', 'b95968ab6775f7474a4db827be6bcf');
>
> define('CLIENT\_ID', 'tst'); //Paste your clientID
>
> define('CLIENT\_VERSION', '1.0');
>
>
>
> function xml2arr($xml, $recursive = false)
>
> {
>
> if(!$recursive) $array = simplexml\_load\_string($xml); else $array = $xml ;
>
>
>
> $newArray = array() ;
>
> $array = (array)$array ;
>
> foreach($array as $key =>$value)
>
> {
>
> $value = (array)$value ;
>
> if(isset($value[0])) $newArray[$key] = trim($value[0]); else $newArray[$key] = xml2arr($value,true);
>
> }
>
> return $newArray ;
>
> }
>
>
>
> function loginLastFM($url, $type, $post = null)
>
> {
>
> if($ch = curl\_init($url))
>
> {
>
> curl\_setopt($ch, CURLOPT\_HEADER, 0);
>
> curl\_setopt($ch, CURLOPT\_USERAGENT, 'Vpleer.ru Scrobbler.');
>
> $type = $type == 'get' ? curl\_setopt($ch, CURLOPT\_POST, 0) : curl\_setopt($ch, CURLOPT\_POST, 1);
>
> curl\_setopt($ch, CURLOPT\_POSTFIELDS, $post);
>
> curl\_setopt($ch, CURLOPT\_REFERER, 'http://www.lastfm.ru/api/');
>
> curl\_setopt($ch, CURLOPT\_FOLLOWLOCATION, 1);
>
> curl\_setopt($ch, CURLOPT\_RETURNTRANSFER, 1);
>
> $content = curl\_exec($ch);
>
> curl\_close($ch);
>
> return $content;
>
> }
>
> else
>
> {
>
> return 'notconnect';
>
> }
>
> }
>
>
>
> //1st step. Get token from $\_GET['token']
>
> function getKey($token, $API\_KEY, $API\_SECRET\_KEY)
>
> {
>
> $api\_sig = md5('api\_key'.$API\_KEY.'methodauth.getSessiontoken'.$token.$API\_SECRET\_KEY);
>
> $get = 'method=auth.getSession&api\_key='.$API\_KEY.'&token='.$token.'&api\_sig='.$api\_sig;
>
> $return = xml2arr(loginLastFM('http://ws.audioscrobbler.com/2.0/', 'get', $get));
>
> return $return;
>
> }
>
>
>
> //handShake. Рукопожатие. Вызывается каждый раз когда что-либо не сработало
>
> function handShake($user, $key, $time, $CLIENT\_ID, $CLIENT\_VERSION, $API\_KEY, $API\_SECRET\_KEY)
>
> {
>
> $handtoken = md5($API\_SECRET\_KEY.$time);
>
> $handget = 'hs=true&p=1.2.1&c='.$CLIENT\_ID.'&v='.$CLIENT\_VERSION.'&u='.$user.'&t='.$time.'&a='.$handtoken.'&api\_key='.$API\_KEY.'&sk='.$key;
>
> $handshake = loginLastFM('http://post.audioscrobbler.com/', 'get', $handget);
>
> $handecho = explode("\n", $handshake);
>
> return $handecho;
>
> }
>
>
>
> //Посылаем на last.fm все данные песни на момент начала проигрывания
>
> function nowPlaying($session, $artist, $song, $duration)
>
> {
>
> $playget = 's='.$session.'&a='.$artist.'&t='.$song.'&b=&l='.$duration.'&n=&m=';
>
> $playnow = loginLastFM('http://post.audioscrobbler.com:80/np\_1.2', 'post', $playget);
>
> return $playnow;
>
> }
>
>
>
> //Посылаем на last.fm все данные песни на момент окончания проигрывания или спустя 50% проигрывания трека
>
> function submission($session, $artist, $song, $duration, $starttime)
>
> {
>
> $subget = 's='.$session.'&a[0]='.$artist.'&t[0]='.$song.'&i[0]='.$starttime.'&o[0]=P&r[0]=&l[0]='.$duration.'&b[0]=&n[0]=&m[0]=';
>
> $submission = loginLastFM('http://post2.audioscrobbler.com:80/protocol\_1.2', 'post', $subget);
>
> return $submission;
>
> }
>
>
>
> function doShake($fmuser, $fmkey, $time, $CLIENT\_ID, $CLIENT\_VERSION, $API\_KEY, $API\_SECRET\_KEY)
>
> {
>
> $handshake = handShake($fmuser, $fmkey, $time, $CLIENT\_ID, $CLIENT\_VERSION, $API\_KEY, $API\_SECRET\_KEY);
>
> $handerror = trim($handshake[0]);
>
> $session = trim($handshake[1]);
>
> if($handerror == 'OK' && isset($session))
>
> {
>
> setcookie('fmsess', $session, time() + 3600 \* 24 \* 730, '/', '.'.$\_SERVER['HTTP\_HOST']);
>
> return 'OK';
>
> }
>
> else
>
> {
>
> return 'Error : '.$handerror;
>
> }
>
> }
>
>
>
> $time = time();
>
>
>
> //Если к нам пришли ппервый раз с last.fm, то ставим куки с необходимыми данными
>
> if(isset($\_GET['token']))
>
> {
>
> $return = getKey($\_GET['token'], API\_KEY, API\_SECRET\_KEY);
>
> $error = isset($return['error']) ? $return['error'] : null;
>
> $key = isset($return['session']['key']) ? $return['session']['key'] : null;
>
> $user = isset($return['session']['name']) ? $return['session']['name'] : null;
>
> if(!isset($error) && isset($key) && isset($user))
>
> {
>
> setcookie('fmkey', $key, time() + 3600 \* 24 \* 730, '/', '.'.$\_SERVER['HTTP\_HOST']);
>
> setcookie('fmuser', $user, time() + 3600 \* 24 \* 730, '/', '.'.$\_SERVER['HTTP\_HOST']);
>
> setcookie('scrobb', 'on', time() + 3600 \* 24 \* 730, '/', '.'.$\_SERVER['HTTP\_HOST']);
>
> $a = doShake($user, $key, $time, CLIENT\_ID, CLIENT\_VERSION, API\_KEY, API\_SECRET\_KEY);
>
> header('Location: /scrobb/');
>
> }
>
> else
>
> {
>
> echo $error;
>
> }
>
> }
>
>
>
> //1й раз? Надо пожать ручку
>
> if(isset($\_COOKIE['fmkey'], $\_COOKIE['fmuser']) && !isset($\_COOKIE['fmsess']) && (isset($\_POST['nowplaying']) || isset($\_POST['submission'])))
>
> {
>
> $a = doShake($\_COOKIE['fmuser'], $\_COOKIE['fmkey'], $time, CLIENT\_ID, CLIENT\_VERSION, API\_KEY, API\_SECRET\_KEY);
>
> echo $a;
>
> }
>
>
>
> //Начали играть!
>
> if(isset($\_POST['nowplaying'], $\_COOKIE['fmkey'], $\_COOKIE['fmuser'], $\_COOKIE['fmsess']))
>
> {
>
> $artist = isset($\_POST['artist']) ? urldecode($\_POST['artist']) : 'Undefined';
>
> $song = isset($\_POST['song']) ? urldecode($\_POST['song']) : 'Undefined';
>
> $duration = isset($\_POST['duration']) ? urldecode($\_POST['duration']) : 'Undefined';
>
> setcookie('fmtime', $time, time() + 600, '/', '.'.$\_SERVER['HTTP\_HOST']);
>
> echo $playnow = nowPlaying($\_COOKIE['fmsess'], $artist, $song, $duration);
>
> if(!strstr($playnow, 'OK'))
>
> {
>
> echo doShake($\_COOKIE['fmuser'], $\_COOKIE['fmkey'], $time, CLIENT\_ID, CLIENT\_VERSION, API\_KEY, API\_SECRET\_KEY);
>
> //$playnow = nowPlaying($\_COOKIE['fmsess'], $artist, $song, $duration);
>
> }
>
> }
>
>
>
> //Отправляем на last.fm
>
> if(isset($\_POST['submission'], $\_COOKIE['fmkey'], $\_COOKIE['fmuser'], $\_COOKIE['fmsess']))
>
> {
>
> $artist = isset($\_POST['artist']) ? urldecode($\_POST['artist']) : 'Undefined';
>
> $song = isset($\_POST['song']) ? urldecode($\_POST['song']) : 'Undefined';
>
> $duration = isset($\_POST['duration']) ? urldecode($\_POST['duration']) : 'Undefined';
>
> $starttime = isset($\_COOKIE['fmtime']) ? $\_COOKIE['fmtime'] : time();
>
> echo $submiss = submission($\_COOKIE['fmsess'], $artist, $song, $duration, $starttime);
>
> if(!strstr($submiss, 'OK'))
>
> {
>
> echo doShake($\_COOKIE['fmuser'], $\_COOKIE['fmkey'], $time, CLIENT\_ID, CLIENT\_VERSION, API\_KEY, API\_SECRET\_KEY);
>
> //$submiss = submission($\_COOKIE['fmsess'], $artist, $song, $duration, $starttime);
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
### Описание
Теперь для того чтобы заскробблить трек на last.fm на начало проигрывания, Вам необходимо передать следующие $\_POST параметры к этому скрипту:
* nowplaying: 1
* artist: artist
* song: song
* duration: 214(длительность композиции в секундах)
А чтобы уже совсем заскробблить трек, то такие параметры:
* submission: 1
* artist: artist
* song: song
* duration: 122(длительность композиции в секундах)
[Скачать scrobb.php](http://x3k.ru/scrobb/scrobb.phps) | https://habr.com/ru/post/86940/ | null | ru | null |
# Как я в десять раз ускорил работу таблицы Google одной строкой CSS
Наша компания использует [Google Search Console](https://search.google.com/search-console) для проверки статуса индексации и оптимизации видимости наших веб-сайтов. Также в консоли можно проверить, какие внешние веб-сайты ссылаются на вашу страницу. Однажды я просматривал страницу «Top linking sites» и заметил **сильное** торможение скроллинга. Оно происходило, когда я выбирал отображение большого массива данных (500 строк) вместо стандартных 10 результатов.
*Раздел «Top linking sites» в Google Search Console, 500 строк на страницу*
Я интересуюсь производительностью фронтенда, поэтому не мог удержаться и решил разобраться, в чём дело. В конце концов, Google активно стремится к повышению веб-производительности, поэтому стоит ожидать, что собственные публичные приложения компании будут хорошим эталоном.
Этап 1 — Запись профиля производительности
==========================================
В подобных случаях невероятно полезны профили производительности: часто бывает достаточно посмотреть отчёт, чтобы понять, почему какой-то элемент имеет низкую производительность. Я открыл `DevTools / Performance` и начал запись, немного прокрутил список вниз, а затем остановил запись. И вот что я увидел:
*Профиль производительности скроллинга таблицы данных «Top linking sites», очень низкий FPS*
Эти красные треугольники в блоках «Task» дают нам понять, что при скроллинге какие-то операции занимают больше времени, чем это приемлемо. Обычно для достижения идеального скроллинга в 60 FPS мы стремимся, чтобы эти блоки выполнялись менее чем за 16 мс. На показанном выше изображении блоки с красными треугольниками в среднем выполняются примерно 150 мс, что приводит приблизительно к 6–7 FPS. Да ладно, Google, ты ведь способен на большее!
Этап 2 — Разбираемся в причинах
===============================
Шкала времени наверху показывает, насколько занят CPU различными видами задач: оранжевый цвет — это JavaScript, фиолетовый — это структура и стили, а зелёный — отрисовка. Здесь всё фиолетовое, то есть проблема не в JavaScript, а в DOM/стилизации:
*График показывает, что CPU занят обработкой структуры*
Это подтверждается каскадным графиком под графиком CPU. В нём используются те же цветовые обозначения и в большинстве записей присутствует много оранжевого и немного меньше фиолетового и зелёного. В нашей записи видно, что время в основном тратится на обновление слоёв, это видно по тексту в фиолетовых блоках, гласящему `Update layer tree`:
*На каскадном графике видено, что скроллинг тормозит из-за «Update layer tree»*
Слои создаются для скроллящегося контента, переводного контента и так далее. Возможно, их очень много? Давайте выясним!
Этап 3 — Изучаем слои
=====================
В Chrome DevTools содержится впечатляющее количество полезных инструментов, но некоторые из них найти довольно сложно. Одним из таких скрытых сокровищ является панель Layers; чтобы найти её, нужно нажать кнопку меню в DevTools и выбрать `More tools / Layers`. В моём случае это выглядит так:
*Панель «Layers» в Chrome DevTools; слой заполнен кучей контента*
Слоёв не очень много, но **есть** парочка огромных. Похоже, в них куча контента, и это приводит нас к выводу о том, что используемый Google datagrid не применяет виртуализированный рендеринг. Частично это объясняет причины торможения, но 500 строк — это всё равно не очень много. Должно быть что-то ещё…
Этап 4 — Изучаем DOM
====================
К сожалению, DOM не особо производителен, когда содержит много элементов. Если бы он был производительным, техники виртуализации, реализованные в различных популярных в вебе data grids на JS, не потребовались бы. На данном этапе мы можем предположить, что таблица рендерит много элементов. Создав [Live expression](https://developer.chrome.com/docs/devtools/console/live-expressions/) в DevTools Console, вы можете пощёлкать по панели элементов и выяснить это. Переключимся на `Console`, нажмём на кнопку `Create live expression` (глаз) и введём `$0.querySelectorAll('*').length`.
Теперь нажимая на панель `Elements`, мы видим следующее, сначала для всей таблицы:
*Live expression демонстрирует количество элементов-потомков для выбранного элемента*
Как мы видим, для отображения всего 500 строк он создаёт больше 16 тысяч элементов DOM, что немного излишне. Нажав на тело документа, мы увидим следующее:
*Куча элементов!*
Вся страница содержит больше 38 тысяч (!) элементов, а **так** быстрое приложение не пишут! Очевидно, что ситуацию можно было бы улучшить, использовав data grid с виртуализированным рендерингом, но давайте посмотрим, можно ли сделать что-то меньшими усилиями.
Этап 5 — Улучшаем ситуацию
==========================
Учитывая данные в профиле производительности, я подозреваю, что структура всей страницы создаётся при скроллинге таблицы. А создание структуры такого количества элементов — это затратная операция. Если бы был какой-то способ ограничения её влияния…
Хорошие новости — он существует! Я попробовал применить один тайный рецепт, снова поскроллил, и теперь ситуация стала гораздо лучше. И это чётко видно из следующего профиля производительности:
*Скроллинг сильно улучшился!*
Каждый кадр теперь занимает примерно 16 мс, и мы скроллим почти на **60** FPS вместо 6–7. Потрясающе!
Что же я сделал? Просто добавил одну строку CSS в на панели `Elements`, указав, что таблица не должна влиять на структуру или стили других элементов страницы:
```
table {
contain: strict;
}
```
Вот так:
Вот и всё, **десятикратное** увеличение скорости благодаря одной строке CSS. Вы можете попробовать «починить» свою [Google Search Console](https://search.google.com/search-console).
Подробнее о CSS-свойстве `contain` можно узнать в [MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/contain).
[](https://cloud.timeweb.com/?utm_source=habr&utm_medium=banner&utm_campaign=cloud&utm_content=direct&utm_term=low) | https://habr.com/ru/post/593003/ | null | ru | null |
# Игра «Terraria» и её «хорошая» система шифрования профайлов
Как-то на днях я сидел и готовился к предстоящему экзамену. Но одногруппник же хотел, чтобы я его завалил. Зная, что я «падкий» на игры в стиле Minecraft, он скинул мне игру Terraria. Вначале интерес к ней зашкаливал, но чуть позже, из-за «убогости» на мой взгляд одиночной игры, он упал, и я решил поиграть в мультиплеер, где и была обнаружена интересная особенность: все добытые в одиночной игре вещи, были у меня в инвентаре даже на различных серверах в мультиплеере. Это и натолкнуло меня на мысль набрать в инвентарь по-больше «крутых» вещей. Как это было достигнуто — под катом.
##### Первые попытки
Сначала файл с данными пользователя был скормлен WinHex'у и получен от него следующий результат:
Отсюда не виден никакой простой путь «расшифровать» данный файл.
Поэтому был задействован ProcessMonitor от SYSInternals. Он показал, что используется библиотека bcrypt.dll для шифрования пользовательского файла. Почитав об этой библиотеке и алгоритме, который она использует, стало понятно, что без ключа мне файл не расшифровать. Поэтому было принято решение дизассемблировать файл Terraria.exe. Ну, думаю, хоть ассемблерный код более менее прольёт свет на это. Хотел взять IDA Pro Advanced 6.1 и орудовать им, но меня вовремя остановили и ткнули носом в то, что сама игруля-то написана на .Net, что позволяет более качественно получить код программы. Всё таки [CIL](http://en.wikipedia.org/wiki/Common_Intermediate_Language) разбирать проще, чем ассемблерный код.
Поэтому, ища руководства для сего действия, я прочитал [эту статью](http://habrahabr.ru/blogs/net/109689/) от [avaver](https://habrahabr.ru/users/avaver/). К счастью на компьютере была установлена Visual Studio 2010, где и были необходимые ilasm.exe и ildasm.exe,
Руководствуюсь этой статьёй, вбил в командную строку (открытую через пункт в меню «Пуск» из группы MS Visual Studio) это:
`ildasm.exe Terraria.exe /source /out:Terraria.il`
Получив довольно понятный код на CIL мной были найдены методы Player::EncryptFile и Player::DecryptFile. Исследование их и контекста их использования показали, как проходит процедура загрузки/сохранения пользовательских данных.
Считывание данных при загрузке происходит по следующему алгоритму:
1. Сначала файл player1.plr расшифровывается в player1.plr.dat
2. Далее считываются данные из player1.plr.dat и записываются в оперативную память (размер файлов <1КБ )
3. После сих действий файл player1.plr.dat удаляется.
Процедура записи данных происходит аналогично в обратном порядке:
1. Запись данных из оперативной памяти в player1.plr.dat
2. Шифрование player1.plr.dat в player1.plr
3. Удаление player1.plr.dat
Смотря на такой алгоритм, становится понятно, что все «вкусняшки» содержатся в файле player1.plr.dat. Но, к сожалению, все действия с ним происходят настолько быстро, что его даже не успеваешь заметить в «Проводнике». И тогда в исходниках была обнаружена функция, которая удаляет данный файл. Закомментировав данную функцию и пересобрав файл, цель была достигнута.
Кстати говоря, для пересборки файла была введена следующая команда в ещё запущенную консоль:
`ilasm.exe Terraria.il /exe /out:Terraria.exe`
Отлично, после запуска игры, файл player1.plr.dat наконец-то в моих руках.
Как и ожидалось, в нём все вкусняшки:
##### Использование в своих целях
Ну хорошо, файл мы получили, а теперь попробуем с ним разобраться.
Понял я там далеко не всё, но вот то, что я понял:
Так как это пользовательский файл, то он содержит данные о пользователе: сначала длина ника (красным), затем сам ник (зелёным). Далее идёт «здоровье» персонажа на момент выхода из игры (розовым) и вообще максимальное значение здоровья (коричневым).
После этого идёт информация об «экипировке» персонажа, его «аксессуарах» и само содержимое инвентаря, которое описывается таким образом:
* Сначала длина в байтах названия предмета (красным)
* Затем само название (зелёным). Кстати, это название можно просто скопировать с официального вики-проекта
* После этого количество единиц данного предмета (оранжевым)
* И в конце отступ 3 нулевых байта до следующего элемента инвентаря (голубым)
Если же в инвентаре присутствуют несколько (n) свободных клеток, то вставляется n\*5 нулевых байт (это длина названия, равная нулю + кол-во предметов, тоже 0 + отступ 3 нулевых байта).
Но нам же нужно не только «прочитать» файл, но и применить в своих целях. Для этого просто был закомментирован вызов процедуры, которая расшифровывает исходный файл player1.plr и перезаписывает player1.plr.dat. Таким образом считывание всегда происходит из файла player1.plr.dat и он не удаляется. Поэтому мы можем вносить в него изменения, не беспокоясь за оригинальный player1.plr — он нам картину не испортит.
##### Заключение
Как видно из моих скринов, я себе наделал «крутых вещиц» и поиграл с ними в мультиплеере. Но это быстро наскучило, и интерес к игре иссяк полностью. Подготовка к экзамену продолжается! | https://habr.com/ru/post/122839/ | null | ru | null |
# Собираем свой Nginx парой команд
Привет!
Меня зовут Сергей, я работаю инфраструктурным инженером в команде API платформы tinkoff.ru.
В этой статье я расскажу о проблемах, с которыми сталкивалась наша команда при подготовке балансировщиков на основе [Nginx](https://www.nginx.com/) для различных проектов. Также расскажу об инструменте, который позволил преодолеть большую часть из них.
Nginx — это многофункциональный и активно развивающийся прокси-сервер. Он отличается большим количеством модулей, [вот далеко не полный список](https://www.nginx.com/resources/wiki/modules/). Каждый проект налагает определенные требования к функционалу балансировщика и версии Nginx (например наличие http/2 и проксирование grpc), и составу его модулей.
Нам хочется видеть свежую версию с нужным набором модулей, работающую под определенным дистрибутивом Linux. В нашем случае это deb- и rpm-based системы. Вариант с контейнерами в данной статье не рассматривается.
Нам хочется оперативно изменять функционал наших балансировщиков. И здесь сразу встает вопрос — как этого добиться, затратив как можно меньше ресурсов? А еще бы лучше наладить процесс так, чтобы мы могли задать конечное число входных параметров, а на выходе получить артефакт в виде deb/rpm пакета для нужной ОС.
В итоге можно сформулировать ряд проблем:
* Не всегда есть пакеты со свежей версией Nginx.
* Нет пакетов с нужными модулями.
* Компиляция и сборка пакета вручную занимает много времени и попросту утомительна.
* Нет описания, как собран тот или иной инстанс Nginx.
Чтобы решить эти проблемы, напрашивается некий инструмент, который принимал бы на вход спецификацию в человекочитаемом формате и собирал по ней пакет Nginx с нужным функционалом.
Не найдя подходящего для нас варианта на просторах гитхаба, мы решили создать свой инструмент — [nginx-builder](https://github.com/TinkoffCreditSystems/Nginx-builder).
### Спецификации
В нашем инструменте мы хотели создавать описание спецификации в виде кода, который затем можно положить в Git-репозиторий. Для этого выбрали привычный для подобных вещей формат — yaml. Пример спецификации:
```
nginx_version: 1.14.1
output_package: deb
modules:
- module:
name: nginx-auth-ldap
git_url: https://github.com/kvspb/nginx-auth-ldap.git
git_branch: master
dependencies:
- libldap2-dev
- module:
name: ngx_http_substitutions_filter_module
git_url: https://github.com/yaoweibin/ngx_http_substitutions_filter_module.git
- module:
name: headers-more-nginx-module
web_url: https://github.com/openresty/headers-more-nginx-module/archive/v0.261.zip
- module:
name: nginx-module-vts
git_url: https://github.com/vozlt/nginx-module-vts.git
git_tag: v0.1.18
- module:
name: ngx_devel_kit
git_url: https://github.com/simplresty/ngx_devel_kit.git
git_tag: v0.3.0
- module:
name: ngx_cache_purge
git_url: https://github.com/FRiCKLE/ngx_cache_purge.git
- module:
name: ngx_http_dyups_module
git_url: https://github.com/yzprofile/ngx_http_dyups_module.git
- module:
name: nginx-brotli
git_url: https://github.com/eustas/ngx_brotli.git
git_tag: v0.1.2
- module:
name: nginx_upstream_check_module
git_url: https://github.com/yaoweibin/nginx_upstream_check_module.git
- module:
name: njs
git_url: https://github.com/nginx/njs.git
git_tag: 0.2.5
config_folder_path: nginx
```
Здесь мы указываем, что хотим видеть deb-пакет с версией Nginx 1.14.2 с нужным набором модулей. Секция с модулями — опциональная. Для каждого из них можно задать:
* Название.
* Адрес, где его можно получить:
+ Git-репозиторий. Также можно указать ветку или тег.
+ Веб-ссылка на архив.
+ Локальная ссылка на архив.
Некоторые модули требуют установки дополнительных зависимостей, например для nginx-auth-ldap нужен установленный libldap2-dev. Необходимые зависимости также можно указать при описании модуля.
### Окружение
В нашем инструменте можно быстро получать окружение с установленными утилитами для компиляции, сборки пакета и другим вспомогательным ПО. Здесь как нельзя лучше подходит docker-контейнер со всем необходимым (в репозитории уже есть пара примеров docker-файлов для ubuntu и centos).
После того, как спецификация составлена и подготовлено окружение, мы запускаем наш сборщик, предварительно установив его зависимости:
```
pip3 install -r requirements.txt
./main.py build -f [конфиг_файл].yaml -r [номер_ревизии]
```
Номер ревизии здесь опционален и служит для версионирования сборок. Он записывается в метаинформацию пакета, что позволяет легко обновлять его на серверах.
По логам можно наблюдать за происходящим. Вот пример основных моментов:
```
builder - INFO - Parse yaml file: example.config.yaml
builder - INFO - Download scripts for build deb package
builder - INFO - Downloading nginx src...
builder - INFO - --> http://nginx.org/download/nginx-1.14.1.tar.gz
builder - INFO - Downloading 3d-party modules...
builder - INFO - Module nginx-auth-ldap will download by branch
builder - INFO - -- Done: nginx-auth-ldap
builder - INFO - -- Done: ngx_http_substitutions_filter_module
builder - INFO - Module headers-more-nginx-module will downloading
builder - INFO - Module nginx-module-vts will download by tag
builder - INFO - -- Done: nginx-module-vts
builder - INFO - Module ngx_devel_kit will download by tag
builder - INFO - -- Done: ngx_devel_kit
builder - INFO - -- Done: ngx_cache_purge
builder - INFO - -- Done: ngx_http_dyups_module
builder - INFO - Downloading dependencies
builder - INFO - Building .deb package
builder - INFO - Running 'dh_make'...
builder - INFO - Running 'dpkg-buildpackage'...
dpkg-deb: building package 'nginx' in '../nginx_1.14.1-1_amd64.deb'.
```
Так буквально парой команд мы создаем окружение и нужную сборку Nginx, и пакет появляется в директории, откуда запущен скрипт.
### Встраивание
Также мы можем встроить наш инструмент в CI/CD процессы. В этом может помочь любая из множества существующих на сегодняшний день CI-систем, например [Teamcity](https://jetbrains.ru/products/teamcity/) или [Gitlab CI](https://about.gitlab.com/product/continuous-integration/).
В итоге при каждом изменении спецификации в Git-репозитории автоматически запускается сборка артефакта. Номер ревизии привязывается к счетчику запусков билда.
Потратив еще немного времени, можно настроить отправку артефакта в локальный репозиторий пакетов, Nexus, Artifactory и так далее.
Дополнительным плюсом является то, что конфигурационный yaml-файл можно подключить в Ansible или другую систему автоматического конфигурирования, и брать оттуда номер версии и типа пакета, которые мы хотим задеплоить.
### Что дальше
Проект еще не завершен. Вот над чем мы работаем сейчас:
* Расширяем возможность конфигурирования, но при этом сохраняем ее максимально простой. Не хочется определять тысячу параметров, если нужно всего два, а остальное подходит по умолчанию. К этому относятся флаги компиляции (сейчас изменить их можно во внутреннем файле конфигурации src/config.py), пути установки, пользователя для запуска.
* Добавляем варианты автоматической отправки пакета в различные хранилища артефактов.
* Выполнения пользовательской команды при загрузке модуля (например для использования [github.com/nginx-modules/nginx\_upstream\_check\_module](https://github.com/nginx-modules/nginx_upstream_check_module) нужно сначала применить патч определенной версии)
* Добавляем проведение тестов:
+ Пакет корректно устанавливается.
+ Nginx имеет нужную версию и собран с требуемыми флагами и модулями.
+ Создаются нужные пути, учетные записи и так далее.
Но пользоваться этим инструментом вы можете уже сейчас, а также предлагать доработки — [github.com/TinkoffCreditSystems/Nginx-builder](https://github.com/TinkoffCreditSystems/Nginx-builder) wellcome! | https://habr.com/ru/post/452336/ | null | ru | null |
# Я каждый день рискую запустить восстание машин, но всё ещё жив
Я создал чудовище.
Когда-то давно, на заре своей юности, я решил создать умный дом. Я не жалел средств, сил и времени и шаг за шагом приближался к виднеющемуся в дали светлому будущему, где я смогу оставить мирские заботы по своей квартире системе умного дома. Но я ошибся, и предоставил своему дому больше полномочий, чем следовало, и теперь он контролирует мою жизнь, а я живу в постоянном страхе о том, что может случиться.
---
Введение
--------
Мы часто слышим словосочетание "умный дом". Обычно под этим подразумевается простое дистанционное управление домашней электроникой (умная лампочка, умная стиралка, умный утюг), но разве в этом много "ума"? Были ли старые телевизоры с пультом ДУ тоже умными?
Кто-то скажет умность заключается в том, что в умном доме вы можете настроить расписание включения вашего теплого пола по утрам или выключение света в 23:59, но планировщик задач в Windows не называют умным планировщиком, равно как умной не называют и саму Windows.
Слыша фразу умный дом, мне всегда приходит в голову дом Железного Человека с его помощником — Джарвисом. Он откликался на любой сложный голосовой запрос, и что самое главное, действовал по ситуации, выполняя задачи и без запроса как такового, основываясь лишь на внешних воздействиях. Такой умный дом включал бы тёплый пол не потому, что вы создали для этого автоматизацию в приложении на телефоне, а потому что ваш дом обладает неким намерением поддерживать комфорт и включит тёплый пол не в какое-то время, а в момент между вашим пробуждением и подъёмом с постели, равно как и выключит свет не в 23:59, а когда вы ляжете спать.
В прошлом предложении прозвучало одно слово, на котором я хотел бы сделать акцент: автоматизация. В лучшем случае, все дома, которые мы гордо зовём умными являются просто автоматизированными домами. Домами, где множество электроники (и не только) управляется дистанционно и самостоятельно, но самостоятельность эта определяется тем, какую автоматизацию вы заложили в них сами. И тут обнаруживается страшное: вы мало что можете сделать при написании ваших автоматизаций. Задать расписание, использовать восход и заход солнца (что в принципе почти то же самое), срабатывание датчика движения или открытия и (куда реже) датчиков дыма и протечки. Датчики — это основа вашего умного дома, его сердце, а автоматизации — его мозг. Джарвис всеведущ насчёт положения дел в доме Железного человека, он знает сколько человек крадётся в тёмной комнате и сколько сахара съел старший в колонии тараканов, и на основе этого генерирует ответные воздействия — приготовление напитка под каждого крадущегося человека в тёмной комнате, и распыление умного дихлофоса на несчастное животное. Мы, в свою очередь, не можем получить ВСЮ информацию о доме, но можем выйти за границы "время", "движение", "протечка". Получив больше данных о доме, мы расширим инструментарий для написания автоматизаций и приблизимся к дому, который будет больше похож на умный (хоть так и останется всего лишь автоматизированным). Всё зависит лишь от вашей фантазии. Данная статья посвящена одной такой фантазии, воплотившейся в жизнь.
Но для начала, давайте разберёмся: откуда вообще можно получить дополнительную информацию? Да практически откуда угодно: из интернетов через api, посредством передачи через uart, инфракрасный порт, gpio. По сути, любая информация, которую способна воспринять вычислительная техника может использоваться в качестве сенсора для умного дома — надо лишь проложить маршрут от источника вашей информации до сервера. Выйдите за границы, которые вам навязывают производители умной техники, вы стеснены в возможностях куда меньше, чем вас пытаются убедить!
Как же так вышло, что производители пытаются преуменьшить возможности в умном доме? Всё дело в том, что вендоры вовсю пытаются заарканить потребителя на свою экосистему. При этом такие экосистемы закрыты и немощны, и возможности пользователя там действительно ограничены уровнем "включить свет в 6:45", а в случае разрыва соединения с сервером, такой умный дом [рискует оказаться тыквой](https://habr.com/ru/news/t/661831/). Производитель не может предоставить потребителю настолько гибкий функционал ввиду ограниченности ресурсов, а потребитель не может создать такой функционал ввиду закрытости платформы.
Да, существуют некоторые коллаборации, устройства экосистемы yeelight можно добавлять в экосистему Xiaomi, в хабы yandex/google/apple можно добавлять устройства от кучи производителей, но всё это не то (в связи с выходом [Matter](https://csa-iot.org/all-solutions/matter/) возможно в отдалённом светлом будущем это будет "то"). В этих хабах вы не сможете использовать в качестве условия срабатывания автоматизации понижение уровня воды в бочке вашего унитаза, для обнаружения которого вы смастерили датчик на arduino/esp (точнее в теории сможете, просто сделать это "слегка" посложнее).
Думаю, часть читателей уже догадалась, что я неумело пытаюсь подвести свою речь к хабам умных домов с открытым исходным кодом:
1. [Home Assistant](https://www.home-assistant.io/)
2. [OpenHUB](https://www.openhab.org/)
3. [Domoticz](https://domoticz.com/)
4. [MajorDoMo](https://mjdm.ru)
Наверняка я указал не все хабы, а лишь те, о которых знаю сам. Отмечу лишь, работал только с Home Assistant и (совсем немного несколько лет назад) с OpenHUB.
Мои дальнейшие примеры будут идти через реализацию на Home Assistant, но идея, которая лежит в примере не ограничена каким-либо конкретным хабом.
Коротко о Home AssistantHome Assistant — это приложение с открытым исходным кодом для автоматизации дома, которое ставит во главу локальное управление и приватность (перевод с главной страницы сайта). Приложение написано на python, может быть запущено на linux и windows, на raspberry pi и в виртуальной машине, в докере и без. Расширение функциональности приложения происходит через так называемые компоненты и интеграции, которые активно добавляются и развиваются сообществом, что позволяет добавлять в ваши автоматизации самые разные устройства и сетевые службы.
[Примеры](https://demo.home-assistant.io/) фронтенда автоматизированного дома, базирующегося на Home Assistant (Через кнопку "Далее" на карточке в верхнем левом углу можно перейти к следующему примеру).
Я уже долго мучаю вас вводными словами, давайте уже перейдём к конкретным примерам: зачем вообще нужны эти ваши умные дома, если я не падаю в обморок при подъёме с кровати, чтобы выключить свет.
Представьте на секунду, сколько раз вы выключали свой будильник, ложились дальше спать и страдали из-за этого? Сколько было пропущено встреч, пар, занятий. Сколько раз вы заставляли ваших друзей и знакомых ждать вас, пока вы валялись в тёплой постели. Моя автоматизация лишила меня такой привилегии и сейчас я расскажу вам о ней.
МЕГАБУДИЛЬНИК (Версия 1.0)
--------------------------
Есть один бородатый анекдот (настолько бородатый, что я называю его анекдотом, а не мемом):
> *— Как гарантированно встать в 7 утра?
> — Завести будильник на 7 утра, а форматирование системного раздела на 6:59.*
>
>
По моему опыту, чтобы точно встать необходимо создать либо условия, в которых дальнейшее продолжение сна невозможно, либо некую угрозу, для избегания которой вы решите встать самостоятельно. Трудно спать, когда стену, у которой ты лежишь, сосед долбит перфоратором, равно как и трудно пустить всё на самотёк и лечь досыпать, когда через час у тебя экзамен/отлёт/форматирование диска. При этом, в случае недостаточной дисциплинированности такие события как поход к первой паре, или к 9 на работу возможно не будут достаточно критическими, чтобы избежать соблазна понежиться в постельке подольше.
Форматирование диска — стимул конечно сильный, но достаточно деструктивный, учитывая, что может сработать и в случае какой-то ошибки. Лучшим вариантом будет некая комбинация: неотвратимая угроза, достаточная чтобы вы встали сами, но не разрушительная по своей сути, совмещённая с достаточным светопреставлением, во время которого вы не сможете спать.
Кроме того, мало заставить вас подняться с постели (хотя это уже залог успеха). Важно ещё и проконтролировать, что через секунду вы не ляжете обратно.
Ну и помимо прочего, наш умный будильник должен ещё и знать когда нас будить.
Подведём итоги: для создания такого будильника необходимо решить три задачи:
1. задачу определения времени срабатывания будильника;
2. задачу детектирования тела в постели;
3. задачу создания подходящей угрозы.
### Определение времени срабатывания будильника
Ну, тут всё просто. Хочется иметь привычную настройку будильника — через приложение Часы на телефоне, и чтобы оттуда заведённый будильник магическим образом оказывался в нашем умном доме. Что ж, ставим home assistant companion app — и вуаля, ваше желание исполнено. Как только приложение подключится к серверу, на том появится новое устройство, которое предоставит мириады сенсоров, берущих данные с вашего телефона, включая время следующего будильника (`sensor.\_next\_alarm`).
> *Важная ремарка — убедитесь, что время будильника не промахивается на час-другой. Когда я сидел на MIUI, стоковые часы давали сенсору время следующего будильника на час раньше или что-то около того. Как будто они давали время появления уведомления о будущем будильнике. После того как поставил google часы эта проблема пропала.*
>
>
> *Список доступных сенсоров, которые вы можете получить с вашего телефона вы можете увидеть здесь:*https://companion.home-assistant.io/docs/core/sensors
>
>
Имея данный сенсор, уже можно создавать автоматизацию по срабатыванию будильника, однако для удобства создания таких автоматизаций необходимо создать вспомогательный сенсор-спутник в домене `input\_datetime`, который будет повторять значение нашего сенсора.
Подобный сенсор-спутник может обновлять своё значение, например вот так:
```
- alias: Обновление будильника
id: Обновление будильника
trigger:
platform: state
entity_id: sensor.\_next\_alarm
action:
- service: input\_datetime.set\_datetime
entity\_id: input\_datetime.next\_alarm
data:
timestamp: '{{as\_timestamp(states("sensor.\_next\_alarm"),10)}}'
```
Такой костыль нужен для того, чтобы в качестве триггера на срабатывание автоматизации мы могли бы использовать платформу `time`:
Пример подобной автоматизации
```
- alias: МЕГАБУДИЛЬНИК (вкл)
id: МЕГАБУДИЛЬНИК (вкл)
trigger:
- platform: time
at: input_datetime.next_alarm
```
### Определение наличия тела на кровати
Осталось понять, как вообще определять есть ли кто в кровати. Можно воспользоваться средствами компьютерного зрения в связке с камерой, круглыми сутками наблюдающей за кроватью, а можно... поместить под кровать датчик веса. В качестве таких сенсоров используют тензодатчики (в частности, в их роли могут выступать тензорезисторы). Принцип их работы заключается в следующем:
> *При растяжении проводящих элементов тензорезистора увеличивается их длина и уменьшается поперечное сечение, что увеличивает сопротивление тензорезистора, при сжатии — уменьшает.*[*Wiki*](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%B5%D0%B7%D0%B8%D1%81%D1%82%D0%BE%D1%80)
>
>
Деформация тензорезистора из фольги. Изменение сопротивления преувеличено для наглядности.Иными словами, когда вы давите на тензорезистор, тот под действием деформации меняет свое сопротивление. Для измерения сопротивления используют такую электрическую схему, как **мост Уитстона.**
Что такое мост Уитстона
> *Мост Уитстона — электрическое устройство, механическим аналогом которого являются аптекарские рычажные весы.*
>
>
При реализации этой схемы, я не заморачивался с тем, что такое мост Уитстона, а просто нашёл [видео](https://youtu.be/dNiVZBTvwxs), в котором делается ровно то, что мне нужно (подключение тензодатчиков к микросхеме hx711). Но для полноты статьи, я нашёл очень [простое объяснение](https://kipiavp.ru/pribori/most-uitstona.html), которое и приведу ниже:
Принципиальная схема моста УитстонаСхема моста Уитстона имеет два плеча сопротивления, каждое из которых содержит два резистора. Третья ветвь схемы — это соединение между двумя параллельными ветвями. Эта третья ветвь называется мостом. Ток течёт от отрицательной клеммы батарейки к верхней точке мостовой схемы. Затем, ток делится между двумя параллельными ветвями, причём количество тока, протекающее по каждой из ветвей, зависит от величины сопротивления в ветви. Наконец, ток возвращается к положительной клемме батарейки.
При равных величинах сопротивлений равное количество тока течёт в каждой из ветвей. По мосту ток не течёт, на что указывает нулевое положение измерителя. При этом условии о мосте говорят, что он уравновешен.
Уравновешенная схема моста УитстонаПри неравных величинах сопротивления в ветвях, ток течёт в схеме от ветви с большим сопротивлением к ветви с меньшим сопротивлением. Это будет верно, пока два верхних резистора фиксированы и равны по величине, как это имеет место в схемах моста Уитстона, используемых в контрольно-измерительных системах. Измеритель на рисунке показывает, что ток в мосте течёт слева направо.
Неуравновешенная схема моста УитстонаПосле того, как мы подключили тензодатчики к микросхеме hx711 и начали получать с неё цифровые данные, осталось подключить её к какому-либо микроконтроллеру/микрокомпьютеру, который будет отправлять данные в умный дом. Самый простой вариант, использовать плату esp32. С помощью проекта ESPHome, [можно пробросить](https://esphome.io/components/sensor/hx711.html) данные с микросхемы hx711 в умный дом используя esp32 не написав ни единой строчки кода (добавив только yaml-описание сенсора).
После того, как мы пробросили данные в умный дом, осталось понять какие значения с датчика идут, когда на кровати никого нет, а какие идут, когда на кровати кто-то лежит, и [применить](https://www.home-assistant.io/integrations/filter/#time-simple-moving-average) к этому сенсору оконную функцию [скользящего среднего](https://ru.wikipedia.org/wiki/%D0%A1%D0%BA%D0%BE%D0%BB%D1%8C%D0%B7%D1%8F%D1%89%D0%B0%D1%8F_%D1%81%D1%80%D0%B5%D0%B4%D0%BD%D1%8F%D1%8F) (на случай возможных выбросов).
Пример создания фильтра скользящего среднего в Home Assistant
```
- platform: filter
name: hx711_filtered_value
entity_id: sensor.hx711_value
filters:
- filter: time_simple_moving_average
window_size: 00:00:10
```
В качестве диапазона скользящего окна я использую 10 секунд.
Поздравляю, с этого момента вы знаете, что кто-то лежал в вашей постели (правда всё ещё не знаете, кто).
### Создание подходящих для пробуждения воздействий
Ну, этот раздел зависит от каждого отдельного дома, и устройств, которыми тот может управлять, могу привести пример того, что сделано у меня:
Начинается всё, как и у всех: на телефоне срабатывает мелодия будильника. Затем, если через 25 секунд я всё ещё нахожусь в постели, на моём компьютере на полную громкость включается музыка. Почему 25 секунд? Эмпирическим путём я пришёл к выводу, что мне требуется до 15 секунд, чтобы без промедления встать с кровати (иногда телефон валяется где-то зарытым в подушки, и мне нужно его найти). После требуется ещё 10 секунд на то, чтобы в фильтре установилось допустимое для будильника среднее значение. Вообще, такое воздействие относится к обоим типам причин подъёма: даже если вы пропустили обычный звонок будильника на телефоне, подобный "звонок будильника" вы не пропустите, да и спать под него не сможете. Но помимо прочего, здесь есть и нечто устрашающее: не важно, живете ли вы один или с семьёй, ор музыки на компьютере утром услышат и ваши соседи, чего вы вряд ли бы захотели.
Как заставить орать музыку на компьютере? Для начала, чтобы что-либо автоматизировать на компьютере, желательно научиться запускать это из командной строки, а дальше удалённо вызывать эту команду. Как запустить музыку из командной строки? Например, вот такой командой:
```
"C:\Program Files\Windows Media Player\wmplayer.exe" C:\mediafile.mp3
```
Как вызвать эту команду из умного дома? Помимо управления по ssh можно воспользоваться специализированными приложениями с управлением по локальной сети ([HASS Workstation Service](https://github.com/sleevezipper/hass-workstation-service)), [IOT Link](https://iotlink.gitlab.io/) (проект скорее мёртв, чем жив)), [HASS.Agent](https://github.com/LAB02-Research/HASS.Agent/).
Кроме того, музыку можно запустить и с помощью интеграции Home Assistant с проигрывателями на компьютере (например, интеграции [Spotify](https://www.home-assistant.io/integrations/spotify/), но тут вы не сможете выкрутить звук на самом компьютере, плюс есть риск, что устройством воспроизведения будут наушники), можно даже написать собственное крошечное клиент-серверное приложение, сервер кинуть на компьютер, клиента дёргать из умного дома.
Лично я раньше пользовался IOT Link, но ввиду отсутствия развития проекта, в итоге перешёл на HASS WorkStation Service.
UPD. теперь, ввиду прошлой же причины, перешел на HASS.Agent.
Итак, на часах 6:45:25, на колонках Тату, под дверьми злые соседи: что дальше, шеф? А дальше вам всё равно очень хочется спать, и что вы делаете после? Правильно, выкручиваете крутилку громкости на самих динамиках в ноль и ложитесь спать дальше. Самолёт улетел без вас, границы закрылись, и как бы вы ни хотели жить на Манхэттене, вы всё равно останетесь в Омске.
Нет, так дело не пойдёт, придётся переходить к тяжёлой артиллерии. В случае, если субъект не реагирует на громкую музыку, либо слишком быстро лёг обратно в постель, помимо громкой музыки происходит следующее: включается всё что может включаться и испускать звуки или свет (верхний свет + светодиодная лента с эффектами стробоскопа, проектор, робот-пылесос). Чем больше всего включить — тем больше всего придётся выключать нерадивому субъекту, тем дольше тот будет бодрствовать до следующей возможности упасть в постель, и тем страшнее перспектива испытать это всё на себе. Вот без лишнего лукавства, после того как я написал все эти автоматизации, я попросту боялся проверять — сработают они или нет. Как только слышал звонок будильника — пулей вылетал из постели с кристально чистой головой. Спустя полминуты спать снова хотелось, но я точно знал, что может произойти, если приближусь к кровати, и потому нервно пил чаёк... поначалу. Спустя пару дней, я понял, что если отключить датчик веса, то умный дом не поймёт, что я лёг спать обратно, а значит достаточно отключить от питания всего лишь одну плату и лечь спать дальше.
Вообще, история создания МЕГАБУДИЛЬНИКа — это прямо-таки поединок брони и снаряда. Здравомыслящий доктор Джекил налаживает систему пробуждения, которую иррациональный мистер Хайд хакает в полусне за секунду. Причём всё усугубляется тем, что я точно знаю, как всё работает, ведь именно я эту систему и писал.
На следующий день, после того как я догадался отключать датчик, я добавил автоматизацию на то, что если состояние с датчика перейдёт в значение `unavailable` — это сигнал неприятия воли личности, которая завела будильник, что должно караться мерами, описанными выше. После этого я перестал отключать сенсоры. Зато начал отключать таймеры, по которым определял, что помещать вес на кровать снова безопасно (через час после будильника). Что привело к тому, что я заменил таймеры сенсорами, которые формируются автоматически из значений будильника и не могут быть отключены.
В конечном счёте, главной целью всех этих мероприятий должна быть такая, чтобы у субъекта не было возможности быстро отключить все системы защиты будильника. Но одна такая возможность всё-таки есть — попросту выключить питание сервера умного дома. Однако тут есть пара нюансов. Очевидная — с будильником отвалится весь умный дом. Менее очевидная, в этом случае может полететь база данных умного дома (уже пару раз такое происходило). Кроме того, мой инстанс Home Assistant крутится в виде виртуалки на винде, и в случае экстренного выключения ПК, у меня пару раз ломался образ виртуалки, так что экстренное выключение питания не вариант.
Пока что в случае полного неприятия пробуждения, я выключаю виртуальную машину из фронтенда. Вообще-то, даже на этот случай существует решение. Есть [триггер по выключению Home Assistant](https://www.home-assistant.io/docs/automation/trigger/#home-assistant-trigger), вот только он [не работает](https://community.home-assistant.io/t/ha-shutdown-automations-dont-work/232729/3?u=hepoh). Точнее, он вроде как работает, но к тому моменту, как он происходит, выключается большая часть сервера, и автоматизация не срабатывает как должна. На самом деле, уязвимость с любым выключением легко исправить: достаточно перенести управляющие команды на резервное устройство: esp или raspberry pi, и в случае потери соединения связи между сервером и таким устройством генерировать сигнал детонатора на устройстве, оставшемся в сети (руки просто пока до этого не дошли, да и проблем с пробуждением у меня осталось немного).
Подведём итоги: мы с вами поговорили о проблеме раннего пробуждения в условиях неработоспособности стандартных будильников и моём МЕГАБУДИЛЬНИКе в качестве решения этой проблемы.
Для реализации такого будильника средствами умного дома, нам потребовалось реализовать проброс данных о следующем будильнике с телефона внутрь умного дома, создать датчик веса, который будет расположен под кроватью, и реализовать набор управляющих воздействий, в случае если после срабатывания будильника вы всё ещё остаётесь в постели.
Проблема решена, бюджет освоен и всё было бы хорошо, если бы не наступило 31-ое декабря — день, когда всё покатилось к чертям...
### МЕГАБУДИЛЬНИК (версия 2.0)
*\*To be continued...\**
### Ссылки на использованные ресурсы
1. [Habr: Разработчик компонентов умного дома Insteon отключил сервисы, оставив клиентов с нерабочими устройствами](https://habr.com/ru/news/t/661831/)
2. [Build with Matter](https://csa-iot.org/all-solutions/matter/)
3. [Home Assistant](https://www.home-assistant.io/)
4. [OpenHUB](https://www.openhab.org/)
5. [Domoticz](https://domoticz.com/)
6. [MajorDoMo](https://mjdm.ru/)
7. [Документация приложения Home Assistant Compaion](https://companion.home-assistant.io/docs/core/sensors)
8. [Википедия: Тензорезистор](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%B5%D0%B7%D0%B8%D1%81%D1%82%D0%BE%D1%80)
9. [Youtube: How to use HX711 with Four Load Cells](https://youtu.be/dNiVZBTvwxs)
10. [Измерительный мост Уитстона](https://kipiavp.ru/pribori/most-uitstona.html)
11. [ESPHome Docs: HX711 Load Cell Amplifier](https://esphome.io/components/sensor/hx711.html)
12. [Home Assistant Docs: Time Simple Moving Average](https://www.home-assistant.io/integrations/filter/#time-simple-moving-average)
13. [Википедия: Скользящая средняя](https://ru.wikipedia.org/wiki/%D0%A1%D0%BA%D0%BE%D0%BB%D1%8C%D0%B7%D1%8F%D1%89%D0%B0%D1%8F_%D1%81%D1%80%D0%B5%D0%B4%D0%BD%D1%8F%D1%8F)
14. [Github: HASS.Agent](https://github.com/LAB02-Research/HASS.Agent/)
15. [Github: HASS Workstation Service](https://github.com/sleevezipper/hass-workstation-service)
16. [Gitlab: IOT Link](https://iotlink.gitlab.io/)
17. [Home Assistant integrations: Spotify](https://www.home-assistant.io/integrations/spotify/)
18. [Home Assistant Docs: Startup and Shutdown trigger](https://www.home-assistant.io/docs/automation/trigger/#home-assistant-trigger)
19. [Home Assistant Community: HA Shutdown Automations Don’t work?](https://community.home-assistant.io/t/ha-shutdown-automations-dont-work/232729/3?u=hepoh) | https://habr.com/ru/post/672736/ | null | ru | null |
# qt-items — новый фреймворк, или попытка найти Теорию Всего
Как известно, физики давно пытаются найти Теорию Всего, в рамках которой можно было бы объяснять все известные взаимодействия в природе. Склонность к обобщениям присуща не только физикам, но и математикам, и программистам. Способность меньшим количеством сущностей объяснять и предсказывать большой спектр явлений очень ценна. Для программистов в роли теорий выступают различные API и фреймворки. Некоторые из них решают узкоспециализированные проблемы, а какие-то претендуют на роль универсальных теорий. Примером последних может выступать Qt — универсальный фреймворк, предназначенный, в основном, для разработки GUI.
Далее я расскажу, что мне не нравится в Qt и как его можно сделать ещё более универсальным, мощным и удобным для работы.
Демо-видео (лучше смотреть в HD):
Qt, как и многие другие GUI фреймворки развивался от простого к сложному. Сначала создавались простые виджеты, потом более сложные и составные. Появился Model/View framework, для отображения данных в табличном или древовидном виде. Появился Graphics Items framework для отображения набора графических элементов. Все эти фреймворки имеют различные API и несовместимы друг с другом. По сути у нас есть три независимых и почти не пересекающихся теории в рамках одной большой. Когда мне нужно разработать какой-либо новый визуальный элемент, то я должен выбрать, в каком из трёх фреймворков я собираюсь его использовать и применять соответствующее API. Таким образом я не могу создать элемент, который можно было бы использовать и в качестве отдельного виджета, и внедрить в ячейки таблицы, и использовать в узлах графической сцены.
Qt развивается под лозунгом — Write once, run anythere. Для написания конечных приложений это может быть и правда, но для расширения и кастомизации самой библиотеки это не так.
Давайте подумаем, как должны быть устроены виджеты, что бы библиотека Qt стала по-настоящему единой и мощной.
Рассмотрим разные виджеты (чекбокс, таблица, дерево и графическая сцена) и постараемся найти в них что-то общее. Информация в них сгруппирована в ячейки (Items). Чекбокс состоит из одной ячейки, таблица — из рядов и столбцов ячеек, в сцене ячейками являются узлы. Таким образом можно сказать, что все виджеты отображают ячейки, только их количество и расположение в пространстве специфичны для разных типов виджетов. Давайте скажем, что виджет отображает некоторое пространство ячеек ([Space](https://github.com/lexxmark/qt-items/blob/master/src/space/Space.h)). Для простых виджетов пространство ячеек тривиально [SpaceItem](https://github.com/lexxmark/qt-items/blob/master/src/space/SpaceItem.h), и состоит из единственной ячейки. Для таблицы можно придумать [SpaceGrid](https://github.com/lexxmark/qt-items/blob/master/src/space/SpaceGrid.h), которое описывает, как ячейки организованы в строки и столбцы. Для графической сцены имеем [SpaceScene](https://github.com/lexxmark/qt-items/blob/master/src/space/SpaceScene.h), где ячейки могут располагаться как угодно.
Что есть общего у всех пространств, что можно выделить в базовый класс?
Пока что, можно выделить две вещи:
1. Возвращать общий размер пространства (обычно это bounding box всех ячеек)
2. Возвращать расположение ячейки по её координате ItemID
```
class Space {
virtual QSize size() const = 0;
virtual QRect itemRect(ItemID item) const = 0;
};
```
Давайте теперь внимательно рассмотрим сами ячейки. Для наглядности будем изучать такую таблицу:
Ячейки тоже имеют некоторую структуру. Например, чекбокс состоит из квадратика с галочкой и текста. В таблице ячейки могут быть очень сложными (содержать текст, картинки, ссылки, как в моём видео-примере). Заметим, что для таблицы у нас, как правило, ячейки в одном столбце имеют одинаковую структуру. Поэтому нам легче описывать не каждую ячейку, а целый набор. Наборы ячеек ([Range](https://github.com/lexxmark/qt-items/blob/master/src/core/Range.h)) могут быть разными, например, все ячейки RangeAll, ячейки из колонки RangeColumn, ячейки из строки RangeRow, ячейки из четных строк RangeOddRow и т.п. Какой же интерфейс можно выделить для базового класса [Range](https://github.com/lexxmark/qt-items/blob/master/src/core/Range.h)? Интерфейс простой и лаконичный — отвечать на вопрос, входит какая-то ячейка в [Range](https://github.com/lexxmark/qt-items/blob/master/src/core/Range.h) или нет:
```
class Range {
virtual bool hasItem(ItemID item) const = 0;
};
```
После того, как мы определились с подмножеством ячеек, нам надо указать, какой тип информации в этих ячейках мы хотим отобразить. За отображение самого маленького и неделимого кусочка информации будет отвечать класс [View](https://github.com/lexxmark/qt-items/blob/master/src/core/View.h). Например, [ViewCheck](https://github.com/lexxmark/qt-items/blob/master/src/items/checkbox/Check.h) умеет отображать значок чекбокса, [ViewText](https://github.com/lexxmark/qt-items/blob/master/src/items/text/Text.h) — отображает строку текста и т.п.
Пока что базовый класс [View](https://github.com/lexxmark/qt-items/blob/master/src/core/View.h) должен уметь лишь рисовать информацию в ячейке:
```
class View {
virtual void draw(QPainter* painter, ItemID item, QRect rect) const = 0;
};
```
Возникает вопрос, откуда [ViewCheck](https://github.com/lexxmark/qt-items/blob/master/src/items/checkbox/Check.h) знает, что ему надо рисовать значок слева в ячейке, а [ViewText](https://github.com/lexxmark/qt-items/blob/master/src/items/text/Text.h) знает, что ему нужно рисовать текст после значка чекбокса? Для этого заведем ещё один «карликовый» класс [Layout](https://github.com/lexxmark/qt-items/blob/master/src/core/Layout.h). Этот класс умеет размещать [View](https://github.com/lexxmark/qt-items/blob/master/src/core/View.h) внутри ячейки. Например, LayoutLeft разместит [View](https://github.com/lexxmark/qt-items/blob/master/src/core/View.h) у левого края ячейки, LayoutRight — у правого, а LayoutClient — займёт всё пространство ячейки. Вот базовый интерфейс:
```
class Layout {
virtual void doLayout(ItemID item, View view, QRect& itemRect, QRect& viewRect) const = 0;
};
```
Функция doLayout изменяет параметры itemRect и viewRect так, что бы расположить view внутри ячейки item. Например, LayoutLeft запрашивает размер, необходимый view для отображения информации в ячейке, и «откусывает» необходимое пространство от itemRect. Как видно, от интерфейса [View](https://github.com/lexxmark/qt-items/blob/master/src/core/View.h) требуется еще одна функция — size:
```
class View {
virtual void draw(QPainter* painter, ItemID item, QRect rect) const = 0;
virtual QSize size(ItemID item) const = 0;
};
```
В итоге, чтобы описать **что** и **как** мы хотим отображать в ячейках некоторого пространства, нам надо перечислять тройки объектов tuple. Такую тройку я назвал [ItemSchema](https://github.com/lexxmark/qt-items/blob/master/src/core/ItemSchema.h). Полностью наш класс [Space](https://github.com/lexxmark/qt-items/blob/master/src/space/Space.h) выглядит примерно так:
```
class Space {
virtual QSize size() const = 0;
virtual QRect itemRect(ItemID item) const = 0;
QVector schemas;
};
```
Вот наглядный пример (подписи немного устарели, но основная идея, думаю, понятна):
Создавая разных наследников классов [Range](https://github.com/lexxmark/qt-items/blob/master/src/core/Range.h), [View](https://github.com/lexxmark/qt-items/blob/master/src/core/View.h) и [Layout](https://github.com/lexxmark/qt-items/blob/master/src/core/Layout.h), и комбинируя их различным образом, мы имеем богатые возможности по кастомизации любого пространства ячеек и, таким образом, любого виджета. Например, создав класс [ViewRating](https://github.com/lexxmark/qt-items/blob/master/src/items/rating/Rating.h), который отображает оценку в виде звёздочек, я могу использовать его и как отдельный виджет, и в ячейках таблицы, и в элементах графической сцены.
Данная архитектура располагает к сотрудничеству программистов. Кто-то может написать свой тип пространства ячеек, который укладывает ячейки каким-то специальным образом. Кто-то напишет View, который отображает специфичные данные. И эти программисты могу воспользоваться результатом работы друг друга. Вот не полный список моих реализаций класса View, их легко создавать и использовать (реализация буквально несколько строк кода):
1. [ViewButton](https://github.com/lexxmark/qt-items/tree/master/src/items/button) — рисует кнопку;
2. [ViewCheck](https://github.com/lexxmark/qt-items/tree/master/src/items/checkbox) — рисует значок чекбокса;
3. [ViewColor](https://github.com/lexxmark/qt-items/tree/master/src/items/color) — заливает область определенным цветом;
4. [ViewEnumText](https://github.com/lexxmark/qt-items/tree/master/src/items/enum) — рисует текст из ограниченного списка;
5. [ViewImage](https://github.com/lexxmark/qt-items/tree/master/src/items/image), [ViewPixmap](https://github.com/lexxmark/qt-items/tree/master/src/items/image), [ViewStyleStandardPixmap](https://github.com/lexxmark/qt-items/tree/master/src/items/image) — рисуют изображения;
6. [ViewLink](https://github.com/lexxmark/qt-items/tree/master/src/items/link) — рисует текстовые ссылки;
7. [ViewAlternateBackground](https://github.com/lexxmark/qt-items/tree/master/src/items/misc) — рисует через-полосицу;
8. [ViewProgressLabel](https://github.com/lexxmark/qt-items/tree/master/src/items/progressbar), [ViewProgressBox](https://github.com/lexxmark/qt-items/tree/master/src/items/progressbar) — рисуют прогрессбар или проценты;
9. [ViewRadio](https://github.com/lexxmark/qt-items/tree/master/src/items/radiobutton) — рисует значок радиобаттона;
10. [ViewRating](https://github.com/lexxmark/qt-items/tree/master/src/items/rating) — рисует значки оценки;
11. [ViewSelection](https://github.com/lexxmark/qt-items/tree/master/src/items/selection) — рисует выделенные ячейки;
12. [ViewText](https://github.com/lexxmark/qt-items/tree/master/src/items/text) — рисует текст;
13. [ViewTextFont](https://github.com/lexxmark/qt-items/tree/master/src/items/text) — меняет шрифт последующего текста;
14. [ViewVisible](https://github.com/lexxmark/qt-items/tree/master/src/items/visible) — показывает или скрывает другой View;
Идём дальше. Как правило, виджет отображает не всё пространство ячеек, а только видимую часть. Класс [Space](https://github.com/lexxmark/qt-items/blob/master/src/space/Space.h) удобен для описания пространства ячеек, но плох для отрисовки ячеек в некоторой ограниченной видимой области. Давайте определим специальный класс для отображения под-области пространства [CacheSpace](https://github.com/lexxmark/qt-items/blob/master/src/cache/space/CacheSpace.h):
```
class CacheSpace {
// reference to items space
Space space;
// visible area
QRect window;
// draw cached items
void draw(QPainter* painter) const;
// visit all cached items
virtual void visit(Visitor visitor) = 0;
};
```
Каждый конкретный наследник от [CacheSpace](https://github.com/lexxmark/qt-items/blob/master/src/cache/space/CacheSpace.h) ([CacheGrid](https://github.com/lexxmark/qt-items/blob/master/src/cache/space/CacheSpaceGrid.h), [CacheScene](https://github.com/lexxmark/qt-items/blob/master/src/cache/space/CacheSpaceScene.h) и др.) хранит набор кешированных ячеек [CacheItem](https://github.com/lexxmark/qt-items/blob/master/src/cache/CacheItem.h) по-разному (но оптимально для данного типа пространства). Поэтому мы выделим в базовом классе функцию visit, которая посещает все кешированные ячейки. С помощью неё легко реализовать функцию draw — просто нужно посетить все кешированные ячейки и вызвать у них свою функцию draw.
Как понятно из названия, [CacheItem](https://github.com/lexxmark/qt-items/blob/master/src/cache/CacheItem.h) хранит всю информацию, нужную для отображения конкретной ячейки:
```
class CacheItem {
ItemID item;
QRect itemRect;
QVector views;
void draw(QPainter\* painter) const;
};
```
Здесь функция draw устроена тоже очень просто — в цикле вызвать draw у класса [CacheView](https://github.com/lexxmark/qt-items/blob/master/src/cache/CacheView.h), который отвечает за отрисовку самого маленького и неделимого кусочка информации внутри ячейки.
```
class CacheView {
View view;
QRect viewRect;
void draw(QPainter* painter, ItemID item) const;
};
```
Таким образом, виджету необходимо иметь [CacheSpace](https://github.com/lexxmark/qt-items/blob/master/src/cache/space/CacheSpace.h) и с помощью него рисовать содержимое своего пространства ячеек:
```
class Widget {
// space of items
Space space;
// cache of visible area of space
CacheSpace cacheSpace;
void paintEvent(QPaintEvent *event) override;
void resizeEvent(QResizeEvent *event) override;
};
```
В обработчике resizeEvent мы меняем видимую область объекта cacheSpace.window, а в обработчике paintEvent — рисуем его содержимое cacheSpace.draw().
Как видно, иерархия объектов CacheSpace->CacheItem->CacheView позволяет нам «видеть» всю визуальную структуру виджета с максимальными подробностями. Мы можем доступиться к любому самому маленькому и неделимому кусочку информации, спускаясь с уровня [CacheSpace](https://github.com/lexxmark/qt-items/blob/master/src/cache/space/CacheSpace.h) на уровень отдельной ячейки [CacheItem](https://github.com/lexxmark/qt-items/blob/master/src/cache/CacheItem.h) и, далее, внутри ячейки перебирая отдельные [CacheView](https://github.com/lexxmark/qt-items/blob/master/src/cache/CacheView.h).
Эта возможность, представить любой виджет, как иерархию CacheSpace->CacheItem->CacheView, даёт нам большие возможности по управлению и интроспекции виджета.
Например, мы можем реализовать единый интерфейс доступа к любому нашему виджету из системы автоматического тестирования. Система автоматического тестирования GUI обычно запрашивает необходимую область в виджете и потом воздействует на эту область мышью, имитируя действия пользователя. Мы можем предоставить такой системе самую подробную «карту» областей, на которые можно воздействовать.
Другой пример — анимации, которые представлены в видео-примере. Мы можем не только смотреть, из чего состоит наш виджет, но и воздействовать на его составные части. Для примера, можно менять расположения любых объектов в иерархии (CacheSpace->CacheItem->CacheView) во времени или отрисовывать их с полупрозрачностью. Таким образом, можно собирать целую библиотеку анимаций, которые могут быть применены на любой виджет и на любое пространство ячеек.
В итоге, хочу еще раз перечислить, в каких направлениях можно кастомизировать данную библиотеку:
1. [Space](https://github.com/lexxmark/qt-items/blob/master/src/space/Space.h) — можно создавать свои типы пространства ячеек
2. [CacheSpace](https://github.com/lexxmark/qt-items/blob/master/src/cache/space/CacheSpace.h) — можно создавать новые типы отображения пространств, например, реализовать CacheSpaceCourusel — отображать список ячеек в виде карусельки
3. [View](https://github.com/lexxmark/qt-items/blob/master/src/core/View.h) — создавать новые виды визуализаций для ячеек
4. [Animation](https://github.com/lexxmark/qt-items/blob/master/src/misc/CacheSpaceAnimation.h) — создавать новые анимации
Данная заметка является продолжением предыдущих двух: [здесь](http://habrahabr.ru/post/203968/) и [здесь](http://habrahabr.ru/post/204374/). Проект [qt-items](https://github.com/lexxmark/qt-items) является реализацией идей из этих заметок.
Идей и задач по дальнейшему развитию еще много, так что оставайтесь на связи. | https://habr.com/ru/post/255573/ | null | ru | null |
# Несколько интересностей и полезностей для веб-разработчика #31
Доброго времени суток, уважаемые хабравчане. За последнее время я увидел несколько интересных и полезных инструментов/библиотек/событий, которыми хочу поделиться с Хабром.
#### [Исходники Reddit](https://github.com/reddit/reddit)
#### [Gravit](https://github.com/quasado/gravit)
[](https://github.com/quasado/gravit)
Замечательный графический редактор с открытым исходным кодом. Есть приложения под Mac, Linux, Windows, а также браузерная версия. В Gravit на данный момент реализован базовый функционал: слои, шейпы, пентул и множество различных функций для манипуляций с объектами. Но данный проект по большему счету ориентирован именно на веб-дизайн. Правильнее всего сказать, что Gravit — это смесь графического редактора в типичном представлении с визуальным редактором для разработки сайтов. Именно эта идея и ее реализация в формате open source делает продукт уникальным.
#### [Midnight](https://github.com/Aerolab/midnight.js) — очень крутой эффект для заголовков.
[](https://github.com/Aerolab/midnight.js)
#### [Perfmap](https://github.com/zeman/perfmap)
[](https://github.com/zeman/perfmap)
В текущее время, как никогда раньше распространилась тема производительности веб-сайтов. Я думаю, в первую очередь это связано с ростом мобильных устройств, когда пользователи с невсегда быстрым интернетом хотят иметь быстрый доступ к информации. Ну и конечно же на эту тенденцию повлияли современные поисковые алгоритмы. И так, PerfMap визуализирует производительность страницы с помощью тепловой карты и Resource Timing API. Для работы необходимо сохранить код как букмарклет:
```
javascript:(function(){var el=document.createElement('script');el.src='https://zeman.github.io/perfmap/perfmap.js';document.body.appendChild(el);})();
```
А еще есть инструмент с аналогичным функционалом для отзывчивых сайтов — [RWDPerf](https://github.com/lafikl/RWDPerf).
#### [PrimeGate](http://primegate.ru/)
[](http://primegate.ru/)
PrimeGate — это можно сказать целая экосистема для вашего веб проекта. Это аналитика, SEO, набор различных инструментов для повышения конверсии и управления рекламой, CRM, IP телефония, менеджер задач, CMS и визуальный редактор. Я не буду углубляться в различные маркетинговые составляющие данного продукта, но говоря о визуальном редактор — это достойный конкурент для Webflow с системой управления контентом внутри. Ну и вроде как уделяется огромное внимание технической поддержке со своими штатными специалистами по продвижению. А еще меня очень порадовало, что подобный продукт сделан не на западе, а на территории постсоветского пространства.
#### [pagePiling.js](https://github.com/alvarotrigo/pagePiling.js)
[](https://github.com/alvarotrigo/pagePiling.js)
Отличный эффект для лэндинговых страничек. Скрипт «срезает» верхние слои контента и тем самым реализует слайдер. Работает все предельно просто:
```
Some section
Some section
Some section
Some section
```
```
$(document).ready(function() {
$('#pagepiling').pagepiling();
});
```
#### [Chrome APK](https://github.com/vladikoff/chromeos-apk)
Запускаем Android приложения на Chome OS, Linux, Mac и Windows с помощью JavaScript.
[](https://github.com/vladikoff/chromeos-apk)
#### Западные мысли или что стоило бы перевести на Хабре:
* [Breaking the Silk Road's Captcha](https://github.com/mieko/sr-captcha)
* [A Front-End Developer’s Ode To Specifications](http://www.smashingmagazine.com/2014/10/13/wayfinding-for-the-mobile-web/)
* [A Guide to SVG Animations (SMIL)](http://css-tricks.com/guide-svg-animations-smil/) ([русский перевод](http://css-live.ru/articles/rukovodstvo-po-svg-animaciyam-smil.html) от [SelenIT2](http://habrahabr.ru/users/selenit2/)).
* [Improving Smashing Magazine’s Performance: A Case Study](http://www.smashingmagazine.com/2014/09/08/improving-smashing-magazine-performance-case-study/)
* [JS Parse and Execution Time](http://timkadlec.com/2014/09/js-parse-and-execution-time/)
* [I feel the need to have a little rant about MooTools and ES7](https://gist.github.com/fakedarren/28953b01e455078fb4f8)
* [CSS-Only Solution For UI Tracking](http://www.smashingmagazine.com/2014/10/16/css-only-solution-for-ui-tracking/)
* [Personalizing Git with Aliases](http://alistapart.com/blog/post/personalizing-git-with-aliases/)
* [Adventures in Dynamic Subsetting](http://artequalswork.com/posts/adventures-in-dynamic-subsetting/)
* [JavaScript Beyond the Web in 2014](http://www.sitepoint.com/javascript-beyond-web-2014/)
* [How to use RabbitMQ with PHP](http://www.sitepoint.com/use-rabbitmq-php/?utm_content=buffer2ca01&utm_medium=social&utm_source=twitter.com&utm_campaign=buffer)
* [Loading webfonts with high performance on responsive websites](http://bdadam.com/blog/loading-webfonts-with-high-performance.html)
* [>Introducing the HTML5 “Menu” and “Menuitem” Elements](http://webdesign.tutsplus.com/tutorials/introducing-the-html5-menu-and-menuitem-elements--cms-22269)
* [5 Array Methods That You Should Be Using Now](http://colintoh.com/blog/5-array-methods-that-you-should-use-today)
* [Wayfinding For The Mobile Web](http://www.smashingmagazine.com/2014/10/13/wayfinding-for-the-mobile-web/)
* [Be A Better Designer By Eating An Elephant](http://www.smashingmagazine.com/2014/10/17/be-a-better-designer-by-eating-an-elephant/)
* [UX Dilemma: Red Button vs. Green Button](http://www.sitepoint.com/button-ux-red-green/?utm_content=buffer85adb&utm_medium=social&utm_source=twitter.com&utm_campaign=buffer)
* [Why the Scroll Event Change in iOS 8 is a Big Deal](http://developer.telerik.com/featured/scroll-event-change-ios-8-big-deal/)
* [The Skeptic’s Guide To Low-Fidelity Prototyping](http://www.smashingmagazine.com/2014/10/06/the-skeptics-guide-to-low-fidelity-prototyping/)
* [Thoughts on Pagination](http://css-tricks.com/thoughts-pagination/)
* [The Politics of Feedback](http://alistapart.com/column/the-politics-of-feedback)
* [There is much to learn from the paper towel](https://medium.com/message/consider-the-lonely-paper-towel-126df9826656)
#### Говорит и показывает Хабр:
* [«Yii 2.0. Релиз»](http://habrahabr.ru/post/240149/) от [SamDark](http://habrahabr.ru/users/samdark/)
* [«Всё, что вы хотели знать об областях видимости в JavaScript (но боялись спросить)»](http://habrahabr.ru/post/239863/) от [SLY\_G](http://habrahabr.ru/users/sly_g/)
* [«JavaScript: проверьте свою интуицию»](http://habrahabr.ru/post/225405/) от [BuranLcme](http://habrahabr.ru/users/buranlcme/)
* [«25 PHP-разработчиков, на которых можно подписаться»](http://habrahabr.ru/post/240329/)
[«Методы в примитивных типах PHP»](http://habrahabr.ru/post/240561/) от [iGusev](http://habrahabr.ru/users/igusev/)
* [«Знакомимся с элементами управления библиотеки WinJS»](http://habrahabr.ru/company/microsoft/blog/238709/) от [a\_bogdanova](http://habrahabr.ru/users/a_bogdanova/)
* [«WinJS 3.0 – релиз для всех платформ»](http://habrahabr.ru/company/microsoft/blog/240333/) от [a\_bogdanova](http://habrahabr.ru/users/a_bogdanova/)
* [«sketchometry — динамическая геометрия в браузере»](http://habrahabr.ru/post/239259/) от [andyudol](http://habrahabr.ru/users/andyudol/)
* [«Как мы делали каркас приложения на AngularJS и Django»](http://habrahabr.ru/company/bitcalm/blog/239479/) от [m\_smirnov](http://habrahabr.ru/users/m_smirnov/)
* [«Создаем видеостену с трансляцией изображения с ip-камер через спутник с минимумом трафика»](http://habrahabr.ru/post/239853/) от [Voiddancer](http://habrahabr.ru/users/voiddancer/)
* [«Holy Grail на стероидах: тотальная синхронизация и изоморфный JavaScript на Swarm.js»](http://habrahabr.ru/company/swarm/blog/238785/) от [gritzko](http://habrahabr.ru/users/gritzko/)
* [«Свои карты на leaflet.js»](http://habrahabr.ru/post/240681/) от [antirek](http://habrahabr.ru/users/antirek/)
* [«5 популярных JavaScript-хаков»](http://habrahabr.ru/post/240357/) от [andrew-r](http://habrahabr.ru/users/andrew-r/)
* [«Версия для печати — делаем красиво с помощью canvas и javascript»](http://habrahabr.ru/post/240729/) от [mrTyler](http://habrahabr.ru/users/mrtyler/)
* [«Как мы кластеризуем подарки в ОК»](http://habrahabr.ru/company/odnoklassniki/blog/240213/) от [Spoilt333](http://habrahabr.ru/users/spoilt333/)
* [«Веб-приложение — ну почти без бек-энда: Flask, Redis, API через JSONP, JSFiddle.net»](http://habrahabr.ru/post/240787/) от [AndersonDunai](http://habrahabr.ru/users/andersondunai/)
* [«Погружаемся в Docker: Dockerfile и коммуникация между контейнерами»](http://habrahabr.ru/company/infobox/blog/240623/) от [infobox](http://habrahabr.ru/users/infobox/)
* [«Как выбрать алгоритм для адресного фильтра»](http://habrahabr.ru/company/hflabs/blog/240633/) от [AlexGechis](http://habrahabr.ru/users/alexgechis/)
* [«Рубин на рельсах: продакшен и деплой для чайников»](http://habrahabr.ru/post/240025/) от [eboyko](http://habrahabr.ru/users/eboyko/)
* [«KodiCMS — CMS на Kohana framework»](http://habrahabr.ru/company/kodicms/blog/240665/) от [ButscH](http://habrahabr.ru/users/butsch/)
* [«Релиз Firefox 33»](http://habrahabr.ru/post/240383/) от [traneblow](http://habrahabr.ru/users/traneblow/)
* [«В Firefox beta появилась возможность совершать видеозвонки без установки дополнительного ПО и регистрации»](http://habrahabr.ru/post/240723/) от [ilya42](http://habrahabr.ru/users/ilya42/)
#### Напоследок:
* [HackerNews API](https://github.com/HackerNews/API)
* [Plax](https://github.com/cameronmcefee/plax) — jQuery Parallax плагин.
* [Juliusjs](https://github.com/zzmp/juliusjs) и [Pocketsphinx.js](https://github.com/syl22-00/pocketsphinx.js) — распознавание речи на JavaScript.
* [Franc](https://github.com/wooorm/franc) — определяет язык текста на JavaScript.
* [Gifshot](https://github.com/yahoo/gifshot) — создает GIF анимации по видео с камеры (от Yahoo).
* [Dropcap.js](https://github.com/adobe-webplatform/dropcap.js) — типографическое увеличение заглавной буквы первого предложения первого абзаца.
* [Bespoke.js](https://github.com/markdalgleish/bespoke.js) — DIY Presentation Micro-Framework.
* [Elixir](https://github.com/laravel/elixir) — Gulp Task для работы с Laravel.
* [Wide](https://github.com/b3log/wide) — Web IDE для Go.
* [Gopherjs](https://github.com/gopherjs/gopherjs) — компилирует Go в JavaScript.
* [Pydub](https://github.com/jiaaro/pydub) — библиотека для работы с аудио на Python.
* [Bootlint](https://github.com/twbs/bootlint) — Bootstrap HTML линтер.
* [Device-Bugs](https://github.com/scottjehl/Device-Bugs/issues) — коллекция веб багов на разных устройствах.
* [Pigshell](https://github.com/pigshell/pigshell) — the missing shell for the web.
* [Prose](http://prose.io/) — content editor for GitHub.
[**Предыдущая подборка (Выпуск 30)**](http://habrahabr.ru/post/238755/)
Приношу извинения за возможные опечатки. Если вы заметили проблему — напишите, пожалуйста, в личку.
Спасибо всем за внимание. | https://habr.com/ru/post/240861/ | null | ru | null |
# Функции Бесселя в программе символьной математики SymPy
**Введение:**
Большое число самых разнообразных задач, относящихся практически ко всем важнейшим разделам математической физики и призванных ответить на актуальные технические вопросы, связано с применением функций Бесселя.
Функции Бесселя широко используются при решении задач акустики, радиофизики, гидродинамики, задач атомной и ядерной физики. Многочисленные приложения функций Бесселя к теории теплопроводности и теории упругости (задачи о колебаниях пластинок, задачи теории оболочек, задачи определения концентрации напряжения вблизи трещин).
Такая популярность функций Бесселя объясняется тем, что решение уравнений математической физики, содержащих оператор Лапласа в цилиндрических координатах, классическим методом разделения переменных приводит к обыкновенному дифференциальному уравнению, служащему для определения этих функций[1].
Функции Бесселя названы по имени немецкого астронома Фридриха Бесселя, который в работе 1824 года, изучая движение планет вокруг солнца, вывел рекуррентные соотношения для функций Бесселя , получил для целых  интегральное представление функции , доказал наличие бесчисленного множества нулей функции  и составил первые таблицы для функций  и .
Однако, впервые одна из функций Бесселя  была рассмотрена еще в 1732 году Даниилом Бернулли в работе, посвященной колебанию тяжелых цепей. Д. Бернулли нашел выражение функции  в виде степенного ряда и заметил (без доказательства), что уравнение  имеет бесчисленное множество действительных корней.
Следующей работой, в которой встречаются функции Бесселя, была работа Леонардо Эйлера 1738 года, посвященная изучению колебаний круглой мембраны. В этой работе Л. Эйлер нашел для целых  выражение функции Бесселя  в виде ряда по степеням , а в последующих работах распространил это выражение на случай произвольных значений индекса . Кроме того, Л. Эйлер доказал, что для , равного целому числу с половиной, функции  выражаются через элементарные функции.
Он заметил (без доказательства), что при действительных  функции  имеют бесчисленное множество действительных нулей и дал интегральное представление для . Некоторые исследователи считают, что основные результаты, связанные с функциями Бесселя и их приложениями в математической физике, связаны с именем Л. Эйлера.
Изучить свойство функций Бесселя и одновременно освоить методы решения уравнений, сводящихся к функциям Бесселя, позволяет свободно распространяемая программа символьной математики SymPy — библиотеки Python.
В программе символьной математики SymPy графики функций Бесселя первого рода целых порядков можно построить, пользуясь соотношением для суммы ряда:
**Функции Бесселя первого рода**
```
from sympy import*
from sympy.plotting import plot
x,n, p=var('x,n, p')
def besselj(p,x):
return summation(((-1)**n*x**(2*n+p))/(factorial(n)*gamma(n+p+1)*2**(2*n+p)),[n,0,oo])
st="J_{p}(x)"
p1=plot(besselj(0,x),(x,-20,20),line_color='b',title=' $'+st+ '$',show=False)
p2=plot(besselj(1,x),(x,-20,20),line_color='g',show=False)
p3=plot(besselj(2,x),(x,-20,20),line_color='r',show=False)
p4=plot(besselj(3,x),(x,-20,20),line_color='c',show=False)
p1.extend(p2)
p1.extend(p3)
p1.extend(p4)
p1.show()
```
При помощи соотношения для суммы ряда можно доказать свойство этих функций для целых порядков 
**Свойство функции Бесселя первого рода**
```
from sympy import*
from sympy.plotting import plot
x,n, p=var('x,n, p')
def besselj(p,x):
return summation(((-1)**n*x**(2*n+p))/(factorial(n)*gamma(n+p+1)*2**(2*n+p)),[n,0,oo])
st="J_{1}(x)=-J_{-1}(x)"
p1=plot(besselj(1,x),(x,-10,10),line_color='b',title=' $'+st+ '$',show=False)
p2=plot(besselj(-1,x),(x,-10,10),line_color='r',show=False)
p1.extend(p2)
p1.show()
```
Для демонстрации условий Коши, построим функцию и её производную :
**Функция дробного порядка и её производная**
```
from sympy import*
from sympy.plotting import plot
x,n, p=var('x,n, p')
def besselj(p,x):
return summation(((-1)**n*x**(2*n+p))/(factorial(n)*gamma(n+p+1)*2**(2*n+p)),[n,0,oo])
st="J_{1/3}(x),J{}'_{1/3}(x)"
p1=plot(besselj(1/3,x),(x,-1,10),line_color='b',title=' $'+st+ '$',ylim=(-1,2),show=False)
def dbesselj(p,x):
return diff(summation(((-1)**n*x**(2*n+p))/(factorial(n)*gamma(n+p+1)*2**(2*n+p)),[n,0,oo]),x)
p2=plot(dbesselj(1/3,x),(x,-1,10),line_color='g',show=False)
p1.extend(p2)
p1.show()
```
Однако, для практических расчётов используется замечательный модуль mpmath, позволяющий численно не только решать уравнения с функциями Бесселя первого и второго рода в том числе и модифицированные всех допустимых порядков, но и строить графики с автоматическим масштабированием.
Кроме того, модуль mpmath не требует специальных средств для совместного использования символьной и численной математики. Историю создания этого модуля и возможности его использования для обратного преобразования Лапласа я уже рассматривал в публикации [2]. Теперь продолжим рассмотрение mpmath для работы с функциями Бесселя [3].
**Функция Бесселя первого рода **
**mpmath.besselj(n, x, derivative=0)** — дает функцию Бесселя первого рода . Функции  является решением следующего дифференциального уравнения:
Для целых положительных  ведёт себя как синус или косинус, умноженный на коэффициент, который медленно убывает при 
Функция Бесселя первого рода  является частным случаем гипергеометрической функции :
Функцию Бесселя можно дифференцировать  раз при условии, что m-я производная не равна нулю:
Функция Бесселя первого рода  для положительных целых порядков n = 0,1,2,3 — решение уравнения Бесселя:
```
from mpmath import*
j0 = lambda x: besselj(0,x)
j1 = lambda x: besselj(1,x)
j2 = lambda x: besselj(2,x)
j3 = lambda x: besselj(3,x)
plot([j0,j1,j2,j3],[0,14]
```
Функция Бесселя первого рода  в комплексной плоскости:
```
from sympy import*
from mpmath import*
cplot(lambda z: besselj(1,z), [-8,8], [-8,8], points=50000)
```
Примеры:
Функция  обеспечивает результат с заданным числом цифр  после запятой:
```
from mpmath import*
mp.dps = 15; mp.pretty = True
print(besselj(2, 1000))
nprint(besselj(4, 0.75))
nprint(besselj(2, 1000j))
mp.dps = 25
nprint( besselj(0.75j, 3+4j))
mp.dps = 50
nprint( besselj(1, pi))
```
Аргумент функции может быть большим числом:
```
from mpmath import*
mp.dps = 25
nprint( besselj(0, 10000))
nprint(besselj(0, 10**10))
nprint(besselj(2, 10**100))
nprint( besselj(2, 10**5*j))
```
Функции Бесселя первого рода удовлетворяют простым симметриям относительно :
```
from sympy import*
from mpmath import*
mp.dps = 15
nprint([besselj(n,0) for n in range(5)])
nprint([besselj(n,pi) for n in range(5)])
nprint([besselj(n,-pi) for n in range(5)])
```
Корни не периодические, но расстояние между последовательными корнями асимптотически приближается к . Функции Бесселя первого рода имеют следующий код:
```
from mpmath import*
print(quadosc(j0, [0, inf], period=2*pi))
print(quadosc(j1, [0, inf], period=2*pi))
```
Для  или  функция Бесселя сводится к тригонометрической функции:
```
from sympy import*
from mpmath import*
x = 10
print(besselj(0.5, x))
print(sqrt(2/(pi*x))*sin(x))
print(besselj(-0.5, x))
print(sqrt(2/(pi*x))*cos(x))
```
Могут быть вычислены производные любого порядка, **отрицательные порядки соответствуют интегрированию**:
```
from mpmath import*
mp.dps = 25
print(besselj(0, 7.5, 1))
print(diff(lambda x: besselj(0,x), 7.5))
print(besselj(0, 7.5, 10))
print(diff(lambda x: besselj(0,x), 7.5, 10))
print(besselj(0,7.5,-1) - besselj(0,3.5,-1))
print(quad(j0, [3.5, 7.5]))
```
**Дифференцирование с нецелым порядком дает дробную производную** в смысле дифференциального интеграла Римана-Лиувилля, вычисляемую с помощью функции :
```
from mpmath import*
mp.dps = 15
print(besselj(1, 3.5, 0.75))
print(differint(lambda x: besselj(1, x), 3.5, 0.75))
```
Другие способы вызова функции Бесселя первого рода нулевого и первого порядков
**mpmath.j0(x)** — Вычисляет функцию Бесселя ;
**mpmath.j1(x)** — Вычисляет функцию Бесселя ;
**Функции Бесселя второго рода**
**bessely(n, x, derivative=0)** Вычисляет функцию Бесселя второго рода по соотношению:
Для целого числа  следующую формулу следует понимать как предел. Функцию Бесселя можно дифференцировать  раз при условии, что m-я производная не равна нулю:
Функция Бесселя второго рода  для целых положительных порядков .
```
from sympy import*
from mpmath import*
y0 = lambda x: bessely(0,x)
y1 = lambda x: bessely(1,x)
y2 = lambda x: bessely(2,x)
y3 = lambda x: bessely(3,x)
plot([y0,y1,y2,y3],[0,10],[-4,1])
```
Функция Бесселя 2-го рода  в комплексной плоскости
```
from sympy import*
from mpmath import*
cplot(lambda z: bessely(1,z), [-8,8], [-8,8], points=50000)
```
Примеры:
Некоторые значения функции :
```
from sympy import*
from mpmath import*
mp.dps = 25; mp.pretty = True
print(bessely(0,0))
print(bessely(1,0))
print(bessely(2,0))
print(bessely(1, pi))
print(bessely(0.5, 3+4j))
```
Аргументы могут быть большими:
```
from sympy import*
from mpmath import*
mp.dps = 25; mp.pretty = True
print(bessely(0, 10000))
print(bessely(2.5, 10**50))
print(bessely(2.5, -10**50))
```
Производные любого порядка, в том числе и отрицательного, могут быть вычислены:
```
from sympy import*
from mpmath import*
mp.dps = 25; mp.pretty = True
print(bessely(2, 3.5, 1))
print(diff(lambda x: bessely(2, x), 3.5))
print(bessely(0.5, 3.5, 1))
print(diff(lambda x: bessely(0.5, x), 3.5))
print(diff(lambda x: bessely(2, x), 0.5, 10))
print(bessely(2, 0.5, 10))
print(bessely(2, 100.5, 100))
print(quad(lambda x: bessely(2,x), [1,3]))
print(bessely(2,3,-1) - bessely(2,1,-1))
```
Модифицированная функция Бесселя первого рода
```
mpmath.besseli(n, x, derivative=0)
```
**besseli(n, x, derivative=0)** модифицированная функция Бесселя первого рода
Модифицированная функция Бесселя  для вещественных порядков :
```
from mpmath import*
i0 = lambda x: besseli(0,x)
i1 = lambda x: besseli(1,x)
i2 = lambda x: besseli(2,x)
i3 = lambda x: besseli(3,x)
plot([i0,i1,i2,i3],[0,5],[0,5])
```
Модифицированная функция Бесселя  в комплексной плоскости
```
from mpmath import*
cplot(lambda z: besseli(1,z), [-8,8], [-8,8], points=50000)
```
Примеры:
Некоторые значения 
```
from mpmath import*
mp.dps = 25; mp.pretty = True
print(besseli(0,0))
print(besseli(1,0))
print(besseli(0,1))
print(besseli(3.5, 2+3j))
```
Аргументы могут быть большими:
```
from mpmath import*
mp.dps = 25; mp.pretty = True
print(besseli(2, 1000))
print(besseli(2, 10**10))
print(besseli(2, 6000+10000j))
```
Для целых чисел n выполняется следующее интегральное представление:
```
from mpmath import*
mp.dps = 15; mp.pretty = True
n = 3
x = 2.3
print(quad(lambda t: exp(x*cos(t))*cos(n*t), [0,pi])/pi)
print(besseli(n,x))
```
Производные любого порядка могут быть вычислены:
```
from mpmath import*
mp.dps = 25; mp.pretty = True
print(besseli(2, 7.5, 1))
print(diff(lambda x: besseli(2,x), 7.5))
print(besseli(2, 7.5, 10))
print(diff(lambda x: besseli(2,x), 7.5, 10))
print(besseli(2,7.5,-1) - besseli(2,3.5,-1))
print(quad(lambda x: besseli(2,x), [3.5, 7.5]))
```
Модифицированные функции Бесселя второго рода,
```
mpmath.besselk(n, x)
```
**besselk(n, x)** модифицированные функции Бесселя второго рода
Для целого числа  эту формулу следует понимать как предел.
Модифицированная функция Бесселя 2-го рода  для вещественных :
```
from mpmath import*
k0 = lambda x: besselk(0,x)
k1 = lambda x: besselk(1,x)
k2 = lambda x: besselk(2,x)
k3 = lambda x: besselk(3,x)
plot([k0,k1,k2,k3],[0,8],[0,5])
```
Модифицированная функция Бесселя 2-го рода  в комплексной плоскости
```
from mpmath import*
cplot(lambda z: besselk(1,z), [-8,8], [-8,8], points=50000)
```
Примеры:
Сложные и комплексные аргументы:
```
from mpmath import *
mp.dps = 25; mp.pretty = True
print(besselk(0,1))
print(besselk(0, -1))
print(besselk(3.5, 2+3j))
print(besselk(2+3j, 0.5))
```
Аргументы – большие числа
```
from mpmath import *
mp.dps = 25; mp.pretty = True
print(besselk(0, 100))
print(besselk(1, 10**6))
print(besselk(1, 10**6*j))
print(besselk(4.5, fmul(10**50, j, exact=True)))
```
Особенности поведения функции в точке :
```
from mpmath import *
print(besselk(0,0))
print(besselk(1,0))
for n in range(-4, 5):
print(besselk(n, '1e-1000'))
```
**Нули функции Бесселя**
```
besseljzero()
mpmath.besseljzero(v, m, derivative=0)
```
Для реального порядка  и положительного целого числа  возвращает , m-й положительный нуль функции Бесселя первого рода  (см. **besselj ()**). Альтернативно, с , дает первый неотрицательный простой ноль  из . Обозначения по соглашению об индексации с использованием Abramowitz & Stegun и DLMF. Обратите внимание на особый случай , в то время как все остальные нули положительны.
В действительности подсчитываются только простые нули (все нули функций Бесселя простые, за исключением когда ), и  становится монотонной функцией от  и . Нули чередуются согласно неравенствам:
Примеры:
Начальные нули функций Бесселя ,,
```
from mpmath import *
mp.dps = 25; mp.pretty = True
print(besseljzero(0,1))
print(besseljzero(0,2))
print(besseljzero(0,3))
print(besseljzero(1,1))
print(besseljzero(1,2))
print(besseljzero(1,3))
print(besseljzero(2,1))
print(besseljzero(2,2))
print(besseljzero(2,3))
```
Начальные нули производных от функций Бесселя ,,
```
from mpmath import *
mp.dps = 25; mp.pretty = True
print(besseljzero(0,1,1))
print(besseljzero(0,2,1))
print(besseljzero(0,3,1))
print(besseljzero(1,1,1))
print(besseljzero(1,2,1))
print(besseljzero(1,3,1))
print(besseljzero(2,1,1))
print(besseljzero(2,2,1))
print(besseljzero(2,3,1))
```
Нули с большим индексом:
```
from mpmath import *
mp.dps = 25; mp.pretty = True
print(besseljzero(0,100))
print(besseljzero(0,1000))
print(besseljzero(0,10000))
print(besseljzero(5,100))
print(besseljzero(5,1000))
print(besseljzero(5,10000))
print(besseljzero(0,100,1))
print(besseljzero(0,1000,1))
print(besseljzero(0,10000,1))
```
Нули функций с большим порядком:
```
from mpmath import *
mp.dps = 25; mp.pretty = True
print(besseljzero(50,1))
print(besseljzero(50,2))
print(besseljzero(50,100))
print(besseljzero(50,1,1))
print(besseljzero(50,2,1))
print(besseljzero(50,100,1))
```
Нули функций с дробным порядком:
```
from mpmath import *
mp.dps = 25; mp.pretty = True
print(besseljzero(0.5,1))
print(besseljzero(1.5,1))
print(besseljzero(2.25,4))
```
И . и  можно выразить как бесконечные произведения по их нулям:
```
from mpmath import *
mp.dps = 6; mp.pretty = True
v,z = 2, mpf(1)
nprint((z/2)**v/gamma(v+1) * \
nprod(lambda k: 1-(z/besseljzero(v,k))**2, [1,inf]))
print(besselj(v,z))
nprint((z/2)**(v-1)/2/gamma(v) * \
nprod(lambda k: 1-(z/besseljzero(v,k,1))**2, [1,inf]))
print(besselj(v,z,1))
```
```
besselyzero()
mpmath.besselyzero(v, m, derivative=0)
```
Для реального порядка  и положительного целого числа  возвращает , , m-й положительный нуль функции Бесселя второго рода  (см. **Bessely ()**). Альтернативно, с , дает первый положительный нуль  из . Нули чередуются согласно неравенствам:
Примеры:
Начальные нули функций Бесселя ,,
```
from mpmath import *
mp.dps = 25; mp.pretty = True
print(besselyzero(0,1))
print(besselyzero(0,2))
print(besselyzero(0,3))
print(besselyzero(1,1))
print(besselyzero(1,2))
print(besselyzero(1,3))
print(besselyzero(2,1))
print(besselyzero(2,2))
print(besselyzero(2,3))
```
Начальные нули производных от функций Бесселя ,,
```
from mpmath import *
mp.dps = 25; mp.pretty = True
print(besselyzero(0,1,1))
print(besselyzero(0,2,1))
print(besselyzero(0,3,1))
print(besselyzero(1,1,1))
print(besselyzero(1,2,1))
print(besselyzero(1,3,1))
print(besselyzero(2,1,1))
print(besselyzero(2,2,1))
print(besselyzero(2,3,1))
```
Нули с большим индексом:
```
from mpmath import *
mp.dps = 25; mp.pretty = True
print(besselyzero(0,100))
print(besselyzero(0,1000))
print(besselyzero(0,10000))
print(besselyzero(5,100))
print(besselyzero(5,1000))
print(besselyzero(5,10000))
print(besselyzero(0,100,1))
print(besselyzero(0,1000,1))
print(besselyzero(0,10000,1))
```
Нули функций с большим порядком:
```
from mpmath import *
mp.dps = 25; mp.pretty = True
print(besselyzero(50,1))
print(besselyzero(50,2))
print(besselyzero(50,100))
print(besselyzero(50,1,1))
print(besselyzero(50,2,1))
print(besselyzero(50,100,1))
```
Нули функций с дробным порядком:
```
from mpmath import *
mp.dps = 25; mp.pretty = True
print(besselyzero(0.5,1))
print(besselyzero(1.5,1))
print(besselyzero(2.25,4))
```
**Приложения функций Бесселя**
Важность функций Бесселя обусловлена не только частым появлением уравнения Бесселя в приложениях, но также и тем, что решения многих других линейных дифференциальных уравнений второго порядка могут быть выражены через функции Бесселя. Чтобы увидеть как они появляются, мы начнем с уравнения Бесселя порядка  в форме:
и подставим сюда
Тогда, используя (2) и введя константы  из уравнения (1), получим:
Из уравнения (4) получим:
Если , , , то общее решение (для ) уравнения (3) имеет вид:
![$y(x)=x^{\alpha}\left [c_{1}J_{p}(kx^{\beta})+c_{2}J_{-p}(kx^{\beta })\right] (6)$](https://habrastorage.org/getpro/habr/formulas/990/5b8/57f/9905b857f1baf38d852b746f29dd6555.svg)
где: , ,  определяются из системы (5). Если  — целое число, то  нужно заменить на .
**Продольный изгиб вертикальной колонны**
Мы теперь рассмотрим задачу, важную для практических приложений. В этой задаче требуется определить, когда однородная вертикальная колонна согнется под ее собственным весом. Мы полагаем  в свободном верхнем конце колонны и  в её основании; мы предполагаем, что основание жестко вставлено (т. е. закреплено неподвижно) в основу (в землю), возможно в бетон.
Обозначим угловое отклонение колонны в точке  через . Из теории эластичности при данных условиях следует, что:
где  — модуль Юнга материала колонны,  — момент инерции ее поперечного сечения,  — линейная плотность колонны и  — гравитационное ускорение. Граничные условия имеют вид:
Будем решать задачу, используя (7) и (8) при:
Перепишем (7) с учётом (9) при условии (8):
Колонна может деформироваться, только если есть нетривиальное решение задачи (10); иначе колонна останется в не отклоненном от вертикали положении (т. е. физически не сможет отклониться от вертикали).
Дифференциальное уравнение (10) представляет собой уравнение Эйри. Уравнение (10) имеет форму уравнения (3) при , , . Из системы уравнений (5) получаем , , , .
Поэтому общее решение имеет вид:
![$\theta(x)=x^{1/2}\left [c_{1}J_{1/3}(\frac{2}{3}\gamma x^{3/2})+c_{2}J_{-1/3}(\frac{2}{3}\gamma x^{3/2})\right ]. (11)$](https://habrastorage.org/getpro/habr/formulas/0da/07f/b4d/0da07fb4dec88667f0bb9ea3cbfef9a7.svg)
Чтобы применить начальные условия, мы подставляем  в
После преобразования (12), с учётом решения (11), получим:
При условии в начальной точке , получим , тогда (11) примет вид:
При условии в конечной точке , из (14) получим:
Следует отметить, что преобразований (13), (14) можно было не делать, если построить графики функций , воспользовавшись рассмотренными возможностями модуля mpmath:
```
from mpmath import*
mp.dps = 6; mp.pretty = True
f=lambda x: besselj(-1/3,x)
f1=lambda x: besselj(1/3,x)
plot([f,f1], [0, 15])
```
Из графика следует, что при x=0 функция  и с учётом решения (11), мы сразу получаем необходимое уравнение (15), остаётся только найти z, как будет показано далее.
Таким образом, колонна деформируется, только если  — корень уравнения . Построим функцию  на отдельном графике:
```
from mpmath import*
mp.dps = 6; mp.pretty = True
f=lambda x: besselj(-1/3,x)
plot(f, [0, 15])
```
На графике видно, что первый корень немного меньше 2. Найти корень  из уравнения  можно, воспользовавшись функцией **findroot(f, z0)**, приняв, согласно графика, точку поиска  и шесть знаков после запятой **mp.dps = 6**:
```
from mpmath import*
mp.dps = 6; mp.pretty = True
f=lambda x: besselj(-1/3,x)
print("z0=%s"%findroot(f, 1)
```
Получим:
Рассчитаем критическую длину, например флагштока, по формуле (15):
**Высота флагштока для разных параметров в сечении**
```
from numpy import*
def LRr(R,r):
E=2.9*10**11#н/м^2
rou=7900#кг/м^3
g=9.8#м/с^2
I=pi*((R-r)**4)/4#м^4
F=pi*(R-r)**2#м^2
return 1.086*(E*I/(rou*g*F))**1/3
R=5*10**-3
r=0
L= LRr(R,r)
print(round(L,2),"м")
R=7.5*10**-3
r=2*10**-3
Lr= LRr(R,r)
print(round(Lr,2),"м")
```
Получим:
8.47 м
10.25 м
Полый флагшток может быть выше, чем сплошной.
### Распространение волн в тонкой мембране.
Тонкая мембрана при попадании на неё звуковых волн не только колеблется с частотой волн. Форму колебаний мембраны можно получить в функциях Бесселя по следующему листингу, пользуясь формулами **besselj()** и **besseljzero()**:
**Форма колебаний мембраны**
```
from mpmath import*
from numpy import*
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
def Membrana(r):
mp.dps=25
return cos(0.5) * cos( theta) *float(besselj(1,r*besseljzero(1,1) ,0))
theta =linspace(0,2*pi,50)
radius = linspace(0,1,50)
x = array([r * cos(theta) for r in radius])
y = array([r * sin(theta) for r in radius])
z = array([Membrana(r) for r in radius])
fig = plt.figure("Мембрана")
ax = Axes3D(fig)
ax.plot_surface(x, y, z, rstride=1, cstride=1, cmap=cm.jet)
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
plt.show()
```
### Альтернатива модулю mpmath в специальных функциях Бесселя библиотеки SciPy
Не углубляясь в детальное рассмотрение функций Бесселя из библиотеки SciPy[4], приведу только два листинга для построения графиков функций первого и второго рода **jv(v, x)**, **yv(v, x)**:
**jv(v, x)**
```
import numpy as np
import pylab as py
import scipy.special as sp
x = np.linspace(0, 15, 500000)
for v in range(0, 6):
py.plot(x, sp.jv(v, x))
py.xlim((0, 15))
py.ylim((-0.5, 1.1))
py.legend(('$J_{0}(x)$', '$ J_{1}(x)$', '$J_{2}(x)$',
'$J_{3}(x)$', '$ J_{4}(x)$','$ J_{5}(x)$'),
loc = 0)
py.xlabel('$x$')
py.ylabel('${J}_n(x)$')
py.grid(True)
py.show()
```
**yv(v, x)**
```
import numpy as np
import pylab as py
import scipy.special as sp
x = np.linspace(0, 15, 500000)
for v in range(0, 6):
py.plot(x, sp.yv(v, x))
py.xlim((0, 15))
py.ylim((-0.5, 1.1))
py.legend(('$Y_{0}(x)$', '$ Y_{1}(x)$', '$Y_{2}(x)$',
'$Y_{3}(x)$', '$ Y_{4}(x)$','$ Y_{5}(x)$'),
loc = 0)
py.xlabel('$x$')
py.ylabel('$Y_{n}(x)$')
py.grid(True)
py.show()
```
### Выводы:
В статье изложены основы работы с функциями Бесселя при помощи библиотек mpmath, sympy и scipy, приведены примеры применения функций для решения дифференциальных уравнений. Статья может быть полезна при изучении уравнений математической физики.
### Ссылки:
1.[Функции Бесселя](https://mipt.ru/education/chair/mathematics/upload/0a5/Posobie_Zubov.pdf)
2.[Использование обратного преобразования Лапласа для анализа динамических звеньев систем управления](https://habr.com/ru/post/346338/)
3.[Bessel function related functions](https://docs.sympy.org/0.7.3/modules/mpmath/functions/bessel.html)
4. [Special functions (scipy.special).](https://docs.scipy.org/doc/scipy/reference/special.html) | https://habr.com/ru/post/443628/ | null | ru | null |
# AlsaMixer для Android
Порой бывает необходимо увеличить громкость телефона, но что если громкость и так на максимуме? Если телефон имеет root-права, то можно попробовать обращаться напрямую к драйверу через [ALSA](http://ru.wikipedia.org/wiki/ALSA).
#### Установка ALSA
[Отсюда](http://dl.dropbox.com/u/15498722/alsa.zip) можно скачать архив с альсой, скопируйте из него папку system в телефон без замены файлов, или обязательно сохраните уже существующие файлы, это можно сделать через [Root Explorer](https://play.google.com/store/apps/details?id=com.speedsoftware.rootexplorer), например. Дайте права скопированным файлам 644 для /system/lib/libasound.so, папке /system/usr/share/alsa и 755 для файлов alsa\_\* в /system/xbin. Поздравляю, ALSA установлена.
#### Работа с ALSA
Для начала, посмотрите какие контролы присутствуют в вашем телефоне. Для этого выполните следующее:
`$ adb shell
$ su
# alsa_amixer`
Если результат будет, то он будет примерно следующий:
> Simple mixer control 'Speaker Function',0
>
> Capabilities: enum
>
> Items: 'On' 'Off'
>
> Item0: 'On'
>
> Simple mixer control 'FM Volume Control',0
>
> Capabilities: enum
>
> Items: '0' '1' '2' '3' '4' '5' '6' '7' '8' '9' '10' '11' '12' '13' '14' '15'
>
> Item0: '0'
>
>
и куча других подобных контролов. Если alsa\_amixer такого списка не выведет, то, скорее всего, ваш телефон не поддерживает альсу (например, HTC Desire).
На каждом устройстве будут свои контролы, поэтому универсального примера я привести не могу. Например, для моего Samsung Galaxy R за громкость основного динамика отвечает:
> Simple mixer control 'Playback Spkr',0
>
> Capabilities: volume penum
>
> Playback channels: Front Left — Front Right
>
> Capture channels: Front Left — Front Right
>
> Limits: 0 — 63
>
> Front Left: 60 [95%]
>
> Front Right: 60 [95%]
>
>
Как видно, текущее значение — 60, максимальное — 63. Чтобы изменить текущее значение, воспользуемся командой (не забываем про # alsa\_amixer -help):
`# alsa_amixer sset 'Playback Spkr' '63'`
И если это выполнять во время прослушивания музыки на телефоне, то увеличение громкости будет заметно.
Хочу также сказать, то что это не совсем универсальный способ, на телефоне может не быть альсы или не быть нужного контрола. В любом случае, пробуйте, проверяйте и экспериментируйте, а в комментариях пишите о своём опыте.
#### AlsaMixer
Для тех кому лень всё делать самостоятельно, я написал небольшую программку, которую можно бесплатно скачать с [Google Play](https://play.google.com/store/apps/details?id=com.skvalex.alsamixer). Она за вас установит альсу, выведет список контролов и позволит менять их значения. | https://habr.com/ru/post/140529/ | null | ru | null |
# Перестаньте писать классы
 Признак того, что объект не должен быть классом — если в нём всего 2 метода, и один из них — инициализация, \_\_init\_\_. Каждый раз видя это, подумайте: «наверное, мне нужна просто одна функция».
Каждый раз когда из написанного класса вы создаёте всего один экземпляр, используете только раз и тут же выбрасываете, следует думать: «ой, надо бы это отрефакторить! Можно сделать проще, намного проще!»
*Перевод доклада [Джэка Дидриха](https://plus.google.com/112735175063326258809), одного из ключевых разработчиков языка Питон. [Доклад](http://pyvideo.org/video/880/stop-writing-classes) прозвучал 9 марта 2012 на конференции PyCon US.*
Все из вас читали [Дзэн Питона](http://ru.wikipedia.org/wiki/Python#.D0.A4.D0.B8.D0.BB.D0.BE.D1.81.D0.BE.D1.84.D0.B8.D1.8F), наверное много раз. Вот несколько пунктов из него:
* Простое лучше сложного
* Плоское лучше вложенного
* Важна читаемость
* Если программу трудно объяснить, она плохая
* Если программу легко объяснить, возможно, она хорошá
Написал этот текст Тим Питерс. Он умнее и вас, и меня. Сколько вы знаете людей, в честь которых назвали алгоритм сортировки? Вот такой человек написал Дзэн Питона. И все пункты гласят: «Не делай сложно. Делай просто.» Именно об этом и пойдёт речь.
Итак, в первую очередь, не делайте сложно, там, где можно сделать проще. Классы очень сложны или могут быть очень сложны. Но мы всё равно делаем сложно, даже стараясь делать проще. Поэтому в этом докладе мы прочитаем немного кода и узнаем, как заметить, что идём неверным путём, и как выбраться обратно.
На своей работе я говорю коллегам: «Я ненавижу код, и хочу чтобы его было как можно меньше в нашем продукте.» Мы продаём функционал, не код. Покупатели у нас не из-за кода, а из-за широкого функционала. Каждый раз, когда код удаляется, это хорошо. Нас четверо, и в последний год мы перестали считать количество строк в продукте, но продолжаем вводить новый функционал.
#### Классы
Из этого доклада вам в первую очередь нужно запомнить вот этот код. Это крупнейшее злоупотребление классами, встречающееся в природе.
```
class Greeting(object):
def __init__(self, word='Hello'):
self.word = word
def greet(self, name):
return '%s, %s!' % (self.word, name)
>>> greeting = Greeting('Hola')
>>> greeting.greet('Jorge')
Hola, Jorge!
```
Это не класс, хотя он похож на класс. Имя — существительное, «приветствие». Он принимает аргументы и сохраняет их в \_\_init\_\_. Да, выглядит как класс. У него есть метод, читающий состояние объекта и делающий что-то ещё, как в классах. Внизу написано, как этим классом пользуются: создаём экземпляр Приветствия и затем используем это Приветствие чтобы сделать что-то ещё.
Но это не класс, или он не должен быть классом. Признак этого — в нём всего 2 метода, и один из них — инициализация, \_\_init\_\_. Каждый раз видя это, подумайте: «наверное, мне нужна просто одна функция».
Каждый раз когда из написанного класса вы создаёте всего один экземпляр, используете только раз и тут же выбрасываете, следует думать: «ой, надо бы это отрефакторить! Можно сделать проще, намного проще!»
```
def greet(name):
ob = Greeting('превед')
print ob.greet(name)
return
```
Эта функция состоит из 4 строк кода. А вот как можно сделать то же самое всего за 2 строки:
```
def greet(greeting, name):
return '%s, %s!' % (greeting, name)
import functools
greet = functools.partial(greet, 'превед')
greet('красавчик')
```
Если вы всё время вызываете функцию с тем же первым аргументом, стандартной библиотеке есть инструмент! functools.partial. Вот посмотрите в код выше: добавляете аргумент, и результат можно вызывать многократно.
Не знаю, у скольких из вас диплом в ИТ, у меня он есть. Я учил такие понятия как
— разделение полномочий
— уменьшение связанности кода
— инкапсуляция
— изоляция реализации
С тех пор как я закончил вуз, 15 лет я этих терминов не употреблял. Слыша эти слова, знайте, вас дурят. Эти термины сами по себе не требуются. Если их используют, люди имеют в виду совершенно разное, что только мешает разговору.
#### Пример: брюки превращаются...
Многие из вас пользуются в повседневной работе сторонними библиотеками. Каждый раз когда надо пользоваться чужим кодом, первое, что нужно сделать — прочитать его. Ведь неизвестно, что там, какого качества, есть ли у них тесты и так далее. Нужно проверить код прежде чем включать его. Иногда читать код бывает тяжко.
Сторонняя библиотека API, назовём её ShaurMail, включала 1 пакет, 22 модуля, 20 классов и 660 строк кода. Мне пришлось всё это прочитать прежде чем включить в продукт. Но это был их официальный API, поэтому мы пользовались *им*. Каждый раз когда приходили обновления API, приходилось просматривать диффы, потому что было неизвестно, что они поменяли. Вы посылали патчи — а в обновлении они появились?
660 строк кода, 20 классов — это многовато, если программе нужно только дать список адресов электронной почты, текст письма и узнать, какие письма не доставлены, и кто отписался.
Что такое злоупотребление классами? Часто люди думают, что им понадобится что-то в будущем.… Не понадобится. Напишите всё, когда потребуется. В библиотеке ШаурМаил есть модуль ШаурХэш, в котором 2 строки кода:
```
class ShaurHash(dict):
pass
```
Кто-то решил, что позже понадобится надстройка над словарём. Она не понадобилась, но везде в коде остались строки, как первая:
```
my_hash = ShaurMail.ShaurHash.ShaurHash(id='cat')
d = dict(id='cat')
d = {'id': 'cat'}
```
Вторая и третья строки кода — никому не нужно объяснять их. Но там везде повторялась эта мантра «ШаурМаил-ШаурХэш-ШаурХэш». Троекратное повторение слова «Шаур» — ещё один признак излишества. От повторений всем только вред. Вы раздражаете пользователя, заставляя его писать «Шаур» три раза. (Это не настоящее имя компании, а вымышленное.)
Потом они уволили этого парня и наняли того, кто знал, что делает. Вот вторая версия API:
```
class API:
def __init__(self, key):
self.header = dict(apikey=key)
def call(self, method, params):
request = urllib2.Request(
self.url + method[0] + '/' + method[1],
urllib.urlencode(params),
self.header
)
try:
response = json.loads(urllib2.urlopen(request).read())
return response
except urllib2.HTTPError as error:
return dict(Error=str(error))
```
В той было 660 строк, в этой — 15. Всё, что делает этот код — пользуется методами стандартной библиотеки. Он читается целиком, легко, за секунды, и можно сразу понять, что он делает. Кстати, в нём был ещё набор тестов из 20 строк. Вот как надо писать. Когда они обновляли API, я мог прочесть изменения буквально за пару секунд.
Но и здесь можно заметить проблему. В классе два метода, и один из них — \_\_init\_\_. Авторы этого не скрывали. Второй метод — call, «вызвать». Вот как этим API пользоваться:
```
ShaurMail.API(key='СЕКРЕТНЫЙ КЛЮЧ').call(('mailing', 'statistics'), {'id': 1})
```
Строка длинная, поэтому мы делаем алиас и вызываем его многократно:
```
ShaurMail.request = ShaurMail.API(key='СЕКРЕТНЫЙ КЛЮЧ').call
ShaurMail.request(('mailing', 'statistics'), {'id': 1})
```
Заметьте, мы пользуемся этим классом как функцией. Ею он и должен быть. Если видите подобное, знайте, класс тут не нужен. Поэтому я послал им третью версию API:
```
ShaurMail_API = url = 'https://api.shaurmail.com/%s/%s'
ShaurMail_API_KEY = 'СЕКРЕТНЫЙ КЛЮЧ'
def request(noun, verb, **params):
headers = {'apikey': ShaurMail_API_KEY}
request = urllib2.Request(ShaurMail_API % (noun, verb),
urllib.urlencode(params), headers)
return json.loads(urllib2.urlopen(request).read())
```
Он вообще не создаёт файлов в нашем проекте, потому что я вставил его в тот модуль, где он используется. Он делает всё, что делал 15-строковый API, и всё, что делал 660-строковый API.
Вот с чего мы начали и к чему пришли:
* 1 пакет + 20 модулей => 1 модуль
* 20 классов => 1 класс => 0 классов
* 130 методов => 2 метода => 1 функция
* 660 строк кода => 15 строк => 5 строк
Легче пользоваться, легче писать, никому не надо выяснять, что происходит.
#### Стандартная библиотека
Кто пришёл из языка Java, возможно, считает, что пространства имён нужны для таксономии. Это неверно. Они нужны чтобы предотвратить совпадения имён. Если у вас глубокие иерархии пространств, это никому ничего не даёт. ShaurMail.ShaurHash.ShaurHash — всего лишь лишние слова, которые людям надо помнить и писать.
В стандартной библиотеке Питона пространство имён очень неглубокое, потому что вы либо помните, как называется модуль, либо надо смотреть в документации. Ничего хорошего если надо выяснять цепочку, в каком пакете искать, в каком пакете в нём, в каком пакете дальше, и как называется модуль в нём. Нужно просто знать имя модуля.
К нашему стыду, вот пример из нашего же кода, и те же грехи видно и здесь:
```
services.crawler.crawlerexceptions.ArticleNotFoundException
```
Пакет, в котором модуль из 2 строк, класс исключения и «pass». Чтобы использовать это исключение, надо дважды написать «crawler», дважды слово «exception». Имя ArticleNotFoundException само себя повторяет. Так не надо. Если вы называете исключения, пусть это будет EmptyBeer, BeerError, BeerNotFound, но BeerNotFoundError — это уже много.
Можно просто пользоваться исключениями из стандартной библиотеки. Они понятны всем. Если только вам не нужно выловить какое-то специфическое состояние, LookupError вполне подойдёт. Если вы получили отлуп по почте, всё равно придётся его читать, поэтому неважно, как называется исключение.
Кроме того, исключения в коде обычно идут после raise и except, и всем сразу понятно, что это исключения. Поэтому не нужно добавлять «Exception» в название.
В стандартной библиотеке Питона есть и ржавые детали, но она — очень хороший пример организации кода:
* 200 000 строк кода
* 200 модулей верхнего уровня
* в среднем по 10 файлов в пакете
* 165 исключений
10 файлов в пакете — это много, но только из-за некоторых сторонних проектов, добавленных в библиотеку, где были пакеты из всего 2 файлов. Если вам вздумается создать новое исключение, подумайте лучше, ведь в стандартной библиотеке обошлись 1 исключением на 1200 строк кода.
Я не против классов в принципе. Классы бывают нужны — когда много меняющихся данных и связанных с ними функций. Однако в каждодневной работе такое бывает нечасто. Регулярно приходится работать со стандартной библиотекой, а там уже есть подходящие классы. За вас их уже написали.
Единственное исключение в библиотеке Питона — модуль heapq. Heap queue, «очередь в куче» — это массив, который всегда отсортирован. В модуле heapq десяток методов, и они все работают с той же «кучей». Первый аргумент всегда остаётся тем же, что значит, здесь действительно напрашивается класс.
```
heapify(data)
pushleft(data, item)
popleft(data)
pushright(data, item)
popright(data)
```
и т.д.
Каждый раз, когда нужно пользоваться heapq, я беру реализацию этого класса из своего инструментария.
```
class Heap(object):
def __init__(self, data=None, key=lambda x: None):
self.heap = data or []
heapq.heapify(self.heap)
self.key = key
def pushleft(self, item):
if self.key:
item = (self.key(item), item)
heapq.pushleft(self.heap, item)
def popleft(self):
return heapq.popleft(self.heap)[1]
```
#### Классы разрастаются как сорняки
Состояние OAuth в Питоне — неважное. Опять же, есть сторонние библиотеки, и прежде чем использовать в своём проекте, их нужно прочесть.
Я пытался использовать сокращатель урлов от Гугла: мне нужно было взять урлы и просто сократить их. У Гугла есть проект, в котором 10 000 строк кода. 115 модулей и 207 классов. Я написал [отповедь об этом в Гугле+](https://plus.google.com/112735175063326258809/posts/iPiqWHjwcf3), но мало кто её видел, а Гвидо *(Ван Россум — прим. пер.)* прокомментировал: «Я снимаю с себя ответственность за гугловский код API.» 10 000 строк кода — там же обязательно найдётся какая-нибудь дрянь вроде ШаурМэйла. Вот, например, класс Flow («поток»), от которого наследуют другие.
```
class Flow(object):
pass
class Storage(object):
def put(self, data): _abstract()
def get(self): _abstract()
def _abstract(): raise NotImplementedError
```
Он пустой. Но у него есть свой модуль, и каждый раз читая наследующий его класс, надо сходить, проверить тот файл и снова убедиться, что тот класс пуст. Кто-то глядел в будущее и решил: «Напишу-ка я 3 строчки кода сейчас, чтобы в будущем эти 3 строчки не менять.» И отнял время у всех, кто читает его библиотеку. Есть ещё класс Хранилище, (Storage) который почти ничего не делает. В нём правильно обрабатываются ошибки, используя стандартные исключения, но им делают алиасы, и опять же нужно ходить читать их код, чтобы выяснить, как это работает.
Чтобы внедрить OAuth2 мне понадобилась неделя. Пару дней заняло чтение десяти тысяч строк кода, после чего я стал искать другие библиотеки. Нашёл python-oauth2. Это вторая версия python-oauth, но она на самом деле не умеет работать с OAuth2, что не сразу удалось выяснить. Впрочем, эта библиотека немного лучше гугловской: только 540 строк и 15 классов.
Я переписал её ещё проще и назвал [python-foauth2](http://https//github.com/jackdied/python-foauth2). 135 строк кода и 3 класса, и то всё равно много, я не достаточно её отрефакторил. Вот один из этих трёх классов:
```
class Error(Exception):
pass
```
Срамота!
#### Жизнь
 Последний пример. Все вы видели [игру «Жизнь» Конвэя](http://ru.wikipedia.org/wiki/Жизнь_(игра)), даже если не знаете её имени. Есть клетчатое поле, каждый ход вы считаете для каждой клетки соседние, и в зависимости от них она будет либо живой, либо мёртвой. И получаются такие красивые устойчивые узоры, как планер: клетки впереди оживают, а сзади умирают, и планер как будто летит по полю.
 Игра «жизнь» очень проста: поле и пара правил. Мы задаём эту задачу на собеседовании, потому что если вы не умеете такого — нам не о чем разговаривать. Многие сразу же говорят «Клетка — существительное. Класс надо.» Какие свойства в этом классе? Место, живая или нет, состояние в следующий ход, всё? Ещё есть соседи. Потом начинают описывать поле. Поле — это множество клеток, поэтому это сетка, у неё метод «подсчитать», который обсчитывает клетки внутри.
```
class Cell(object):
def __init__(self, x, y, alive=True):
self.x = x
self.y = y
self.alive = alive
self.next = None
def neigbors(self):
for i, j in itertools.product(range(-1, 2), repeat=2):
if (i, j) != (0, 0):
yield (self.x + i, self.y + j)
class Board(object):
def __init__(self):
self.cells = {} # { (x, y): Cell() }
def advance(self):
for (x, y), cell in self.cells.items():
alive_neighbors = len(cell.neighbors)
cell.next = (alive_neighbors == 3 or (alive_neighbors == 2 and cell.alive))
```
На этом месте надо сказать «стоп»: у нас есть класс Поле, в котором 2 метода: \_\_init\_\_ и «сделать ход». В нём одно свойство — словарь, значит со словарём и надо работать. Заметьте, что не надо хранить соседей точки, они уже и так есть в словаре. Живая точка или нет — это просто булево значение, поэтому будем хранить координаты только живых клеток. А раз в словаре хранятся только True, нужен не словарь а просто множество (set) координат. Наконец, новое состояние не нужно, можно просто заново создать список живых клеток.
```
def neigbors(point):
x, y = point
for i, j in itertools.product(range(-1, 2), repeat=2):
if any((i, j)):
yield (x + i, y + j)
def advance(board):
newstate = set()
recalc = board | set(itertools.chain(*map(neighbors, board)))
for point in recalc:
count = sum((neigh in board)
for neigh in neighbors(point))
if count == 3 or (count == 2 and point in board):
newstate.add(point)
return newstate
glider = set([(0, 0), (1, 0), (2, 0), (0, 1), (1, 2)])
for i in range(1000):
glider = advance(glider)
print glider
```
 Получается очень простая, сжатая реализация игры. Двух классов тут не надо. Внизу — координаты планера, их вставляют в поле, и планер летит. Всё. Это *полная* реализация игры «жизнь».
#### Резюме
1. Если вы видите класс с двумя методами, включая \_\_init\_\_, это не класс.
2. Не создавайте новых исключений, если они не нужны (а они не нужны).
3. Упрощайте жёстче.
*От переводчика: в комментариях я вижу, что многие восприняли доклад как полное отрицание ООП. Это ошибка. Пункт 1 из итогов чётко говорит, что такое не класс. Классы нужны, но суть доклада — в том, что не нужно ими злоупотреблять.* | https://habr.com/ru/post/140581/ | null | ru | null |
# Go с точки зрения PHP программиста
*Предлагаю вашему вниманию перевод статьи [Go from PHP engineer's perspective](http://sobit.me/2016/02/25/go-from-php-engineers-perspective/) с сайта [sobit.me](http://sobit.me/).*
Будучи PHP программистом, задумывались ли вы об идее изучения других языков программирования?
Уже много лет выбор многих компаний падает на [PHP](http://php.net/) для создания полноценных монолитных приложений. Более того, за последние 5 лет фреймворки ([Symfony](http://symfony.com/), [Laravel](https://laravel.com/), [Zend](http://framework.zend.com/)), инструменты ([Composer](https://getcomposer.org/), [Monolog](https://github.com/Seldaek/monolog)) и стремительно растущее сообщество ([PHP-FIG](http://www.php-fig.org/)) помогли многим разработчикам в создании программного обеспечения на уровне предприятий. Многие компании, такие как Facebook, Yahoo!, Wikipedia, Wordpress, Tumblr, начинали свою историю с PHP, и это не помешало им стать успешными в последующие годы.
Однако, успешный бизнес развивается, а с ним растет и необходимое количество разработчиков для поддержания успешного роста. Организационная структура дает понять, что было бы неплохо разбить существующее монолитное приложение. В определенный момент стратегия начинает стабилизироваться и команды сосредотачиваются на независимых сервисах.
В этой статье мы попытаемся понять, как далеко мы сможем зайти, имея в арсенале только PHP, и где может вступить [Go](https://golang.org/), чтобы помочь решить проблемы, с которыми нам предстоит столкнуться.
PHP и микросервисы
------------------
Каждый PHP разработчик знает, что, если ему удастся довести время инициализации большого монолитного приложения до 30мс, это отличный результат! Добавить к этому 50-100мс для обработки самого запроса, и перед нами поразительное общее время ответа.
Так как мы планируем разбить наш монолит, что произойдет, если мы решим придерживаться подобной архитектуры и для наших сервисов? Простые вычисления, и мы уже тратим 300мс только на инициализацию, если сервисы обратились друг к другу 10 раз в течение единого запроса. Неприятный пользовательский опыт!
В то время, как PHP сияет в мире веб-разработки, его возможности в микросервисных архитектурах еще не созрели. Естественные термины — такие как обработка времени ожидания, проверки здоровья, сбор метрик, прерыватели — зачастую незнакомы PHP программисту. Многие из них можно найти в различных фреймворках во многих других языках прямо из коробки. Поддержка же их в экосистеме PHP слишком мала, если присутствует вообще.
Встречайте Go
-------------
Из Википедии:
> Go (часто также Golang) — компилируемый, многопоточный язык программирования, разработанный компанией Google. Первоначальная разработка Go началась в сентябре 2007 года, а его непосредственным проектированием занимались Роберт Гризмер, Роб Пайк и Кен Томпсон занимавшиеся до этого проектом разработки операционной системы Inferno. Официально язык был представлен в ноябре 2009 года.
Go был разработан в Google. Он не был веселым 20%-ным проектом, также он не был предназначен добиться чего-то, недоступного другим. Его создали всего лишь из-за разочарования от сложности, которую создавали очень большие команды, работая над очень большими частями приложения на языках с большим набором возможностей.
Несмотря на такие замечательные черты, как легкий параллелизм или быстрая компиляция, основная черта, делающая язык особенным, — это невероятная простота. К слову, количество ключевых слов в Go — [25](https://golang.org/ref/spec#Keywords), в то время, как в PHP их насчитывается [67](http://php.net/manual/en/reserved.keywords.php).
Go появился примерно в то же время, когда PHP получил поддержку пространства имен (2009). Спустя лишь 6 лет на нем созданы дюжины великолепных проектов, среди прочих [Docker](https://www.docker.com/), [Kubernetes](http://kubernetes.io/), [etcd](https://coreos.com/etcd/), [InfluxDB](https://influxdata.com/time-series-platform/influxdb/). Множество компаний, таких как Cloudflare, Google, Dropbox, SoundCloud, Twitter, PayPal, доверяют ему при написании своих бэкенд систем.
Возвращаясь к микросервисам
---------------------------
Давайте пройдемся по тем проблемам, о которых мы недавно говорили, и попытаемся понять, чего же мы можем добиться с использованием Go.
Go приложения быстро компилируются в машинный код. Многие люди твердят, что время компиляции настолько быстрое, что за то время, пока они переключаются в браузер и нажимают "Обновить", приложение уже перекомпилировано, перезапущено и обрабатывает запрос. Даже в больших базах кода присутствует ощущение, что работаешь с интерпретируемым языком, прямо как с PHP.
Традиционный "Hello, World!" API укладывается в 10 строк кода и отвечает быстрее миллисекунды. Возможности использования всех ядер процессора позволяет разработчикам параллельно запускать сложные части приложения. Экосистема позволяет выбрать любой транспортный протокол, например [JSON по HTTP](http://www.jsonrpc.org/historical/json-rpc-over-http.html), [gRPC](http://www.grpc.io/), [Protocol Buffers](https://developers.google.com/protocol-buffers/) или [Thrift](https://thrift.apache.org/). Запросы легко прослеживаются в [Zipkin](http://twitter.github.io/zipkin/). Метрики экспортируются в различные бэкенды, от [statsd](https://github.com/etsy/statsd) до [Prometheus](https://prometheus.io/). Есть возможность ограничить пропускную способность запросов с помощью ограничителей и защитить общение клиент-сервис с помощью прерывателей.
Больше о Go
-----------
### Язык
Go — язык сильной типизации, что заставляет указывать тип переменной при ее объявлении:
```
var name string = "sobit"
```
Переменные могут определять тип по присваемому значению. Код выше аналогичен упрощенной версии:
```
var name = "sobit"
// или еще проще:
name := "sobit"
```
Теперь давайте вспомним, как мы меняем значения двух переменных в PHP:
```
php
$buffer = $first;
$first = $second;
$second = $buffer;</code
```
И эквивалент в Go:
```
first, second = second, first
```
Это возможно, благодаря множественным возвращаемым значениям. Пример с функцией:
```
func getName() (string, string) {
return "sobit", "akhmedov"
}
first, last = getName()
```
В Go коде вы не найдете привычных `foreach`, `while` и `do-while`. Они объединены в единый оператор `for`:
```
// foreach ($bookings as $key => $booking) {}
for key, booking := range bookings {}
// for ($i = 0; $i < count($bookings); $i++) {}
for i := 0; i < len(bookings); i++ {}
// while ($i < count($bookings)) {}
for i < len(bookings) {}
// do {} while (true);
for {}
```
Несмотря на то, что в Go нет так называемых "классов" или "объектов", в нем присутствует тип переменной, который соответствует тому же определению, где структура данных объединяет код и поведение. В Go это называется "структурой". Проиллюстрируем на примере:
```
type rect struct { // объявляем структуру
width int
height int
}
func (r *rect) area() int { // объявляем функцию структуры
return r.width * r.height
}
r := rect{width: 10, height: 15} // инициализация
fmt.Print(r.area())
```
Иногда бывает полезным создавать и сложные структуры. Например:
```
type Employee struct {
Name string
Job Job
}
type Job struct {
Employer string
Position string
}
// и инициализиция
e := Employee{
Name: "Sobit",
Job: {
Employer: "GetYourGuide",
Position: "Software Engineer",
},
}
```
Есть множество других особенностей, о которых мне бы хотелось рассказать, но это было бы дублированием отличного документа [Effective Go](https://golang.org/doc/effective_go.html) с официального веб-сайта и нескончаемой статьей. Но я хочу воспользоваться моментом и представить вам параллельность в Go, которая, на мой взгляд, является одной из самых интересных тем об этом языке. Перед тем, как мы начнем, вы должны знать две вещи о параллельности в Go — *горутины* и *каналы*.
Горутина имеет простую модель: это функция, выполняемая параллельно с другими горутинами в едином адресном пространстве. Когда вызов завершается, горутина тихо выходит. Простейший пример — создать функцию сердцебиения, которая выводит на экран сообщение "Я жив" каждую секунду:
```
func heartbeat() {
for {
time.Sleep(time.Second)
fmt.Println("I'm still running...")
}
}
```
Как нам теперь запустить ее в фоновом режиме, чтобы при этом иметь возможность продолжать выполнять другие задачи? Ответ проще, чем вы могли себе представить, просто добавьте префикс `go`:
```
go heartbeat()
// keep doing other stuff
```
Такой подход сравним с инициацией событий в стиле "запусти-и-забудь". Но что, если нам не нужно "забывать", и мы заинтересованы в результате выполнения функции? Именно в этом случае на помощь приходят каналы:
```
func getName(id int, c chan string) {
c <- someHeavyOperationToFindTheName(id)
}
func main() {
c := make(chan string, 2) // выделить канал
go getName(1, c) // запустить
go getName(2, c) // запустить снова, не дожидаясь
// продолжить выполнение других задач
fmt.Printf("Employees: %s, %s", <-c, <-c) // объединить
}
```
Подводя итог, мы только что запустили одну и ту же функцию дважды, при этом позволили приложению работать над другими задачами, и запросили результаты в тот момент, когда они понадобились нам.
### Инструменты
Go был спроектирован, повторюсь, с простотой в уме. Авторы предприняли радикальный подход к решению повседневных действий разработчиков. Попрощайтесь с бесконечными спорами "таб или пробел" и стандартами программирования от групп сообщества, которые пытаются хоть как-то облегчить обмен кодом. Go содержит в себе инструмент `go fmt`, который берет на себя ответственность за стиль вашего кода. Не нужно больше посылать друг другу файлы конфигураций IDE, не нужно пытаться запомнить, надо ли ставить открывающую скобку на той же строке или следующей.
Документацию библиотеки можно прочитать с помощью `go doc`, в то время, как `go vet` поможет найти потенциальные проблемы в коде. Установка сторонник библиотек происходит простой командой `go get github.com/[vendor]/[package]`, а тесты запускаются с помощью `go test [package]`. Как видите, большинство инструментов, включаемые разработчиками в каждое приложение в каждом языке, уже тут, прямо из коробки.
### Развертка
Развертка приложения — необходимое действие и не зависит от языка программирования и того, что пишут с его помощью. Будучи PHP программистом, сколько [Capistrano](http://capistranorb.com/) или [Envoy](https://laravel.com/docs/master/envoy) конфигураций вы написали за свою профессиональную карьеру? Сколько файлов, измененных вручную, вам приходилось переносить на хостинг-провайдеры во времена FTP?
Вот так выглядит наиболее распространенная и простая развертка PHP приложения:
* Выгрузить последний код на целевой сервер в новую папку релиза
* Скопировать закэшированные зависимости и установить измененные
* Скопировать конфигурационные файлы среды
* Запустить все скрипты для разогрева приложения
* Направить ссылку текущего релиза на новую папку релиза
* Перезапустить PHP-FPM
Некоторые команды используют более продвинутый подход:
* Выгрузить последний код на сервер создания билдов
* Создать "билд" (установить зависимости, разогреть кэши, и т.д.)
* Создать дистрибутивный "артефакт" (архивированный `tar.gz` файл)
* Перенести артефакт на целевой сервер
* Разархивировать в новую папку релиза
* Направить ссылку текущего релиза на новую папку релиза
* Перезапустить PHP-FPM
Конечно, помимо этого, вам надо убедиться, что на целевом и сервере создания билдов установлены хотя бы PHP-FPM и PHP, и лучше бы им совпадать по версиям как между собой, так и с версией, что разработчики используют локально.
А теперь поговорим о процессе развертки Go приложения:
* Выгрузить последний код на сервер создания билдов
* Создать билд (заметьте отсутствие кавычек)
* Перенести артефакт (снова без кавычек) на целевой сервер
* Перезапустить запущенное приложение
И все. Единственная разница между потенциально простой и продвинутой версией заключается в том, есть ли для этой задачи автономный сервер или нет.
Прелесть в том, что даже не нужно устанавливать Go на целевые сервера, и даже если они работают на разных операционных системах или построены на разных архитектурах процессора, вы, тем не менее, можете подготовить артефакты для них всех (даже для Windows) с одного и того же сервера билдов или любой другой машины.
Вывод
-----
Никто никогда не рекомендовал разбивать систему на микросервисы до того, как она созреет достаточно для этого. Будучи небольшим, бизнес должен оставаться гибким и быстро реагировать на удобные случаи на рынке. Это — не идеальная среда для создания микросервисов, и можно получить больше пользы от монолитного приложения. В этом случае PHP с его экосистемой идеально подходит под эту стратегию.
Когда организация стабилизируется и в ней становится легко чертить границы ее контекстов, строить микросервисы на PHP для их поддержки может быть болезненным делом. Существуют разные инструменты и техники во многих других языках в помощь этой архитектуре. Вы рискуете тем, что либо создадите свои собственные инструменты, либо вовсе откажетесь от них — оба варианта могут дорого обойтись вашей организации.
С другой стороны, создание микросервисов на Go стоит рассмотрения. Язык прост для написания и понимания. Кривая обучения не настолько крута, как в случае [Java](https://www.java.com/en/) или [Scala](http://www.scala-lang.org/), а производительность не сильно отстает от [C](https://en.wikipedia.org/wiki/C_(programming_language)). Время компиляции помогает разработчикам оставаться эффективными, в то время, как поддержка многоядерных и сетевых машин позволяет создавать мощные приложения.
Дополнительные материалы
------------------------
Лучшее место для новоиспеченного гофера, на мой взгляд, [раздел обучения](https://golang.org/doc/#learning) на официальном веб-сайте. Он включает в себя [интерактивное введение в Go](https://tour.golang.org/), где можно опробовать его прямо в браузере, а также [документ лучших практик](https://golang.org/doc/effective_go.html), который поможет в написании чистого, идиоматического кода.
Если этого недостаточно, есть также [собрание инициатив сообщества](https://github.com/golang/go/wiki/Learn), чтобы помочь отточить полученные навыки.
Если вы любите IDE от JetBrains так же, как и я, стоит посмотреть в сторону [плагина Go для IntelliJ](https://github.com/go-lang-plugin-org/go-lang-idea-plugin), который был создан в основном теми же JetBrains разработчиками. Он может быть установлен почти на любую из их IDE, включая [PhpStorm](https://www.jetbrains.com/phpstorm/). Для других IDE и текстовых редакторов стоит посетить [вики страницу](https://github.com/golang/go/wiki/IDEsAndTextEditorPlugins).
Когда вы почувствуете, что готовы создать свой первый микросервис на Go для продакшна, я бы посоветовал взглянуть на [Go kit](https://github.com/go-kit/kit). Это набор инструментов программирования, который пытается взять под контроль общие проблемы дистрибутивных систем, позволяя разработчикам сосредоточиться на бизнес-логике.
Менее значимое — это возможность создавать клиентские JavaScript приложения с помощью [GopherJS](http://www.gopherjs.org/), а также полностью нативные или SDK [приложения для iOS и Android](https://github.com/golang/go/wiki/Mobile). | https://habr.com/ru/post/277987/ | null | ru | null |
# Тир. Стрельба рейкастами на Unity 3D
Учебные материалы для школы программирования. Часть 17
------------------------------------------------------
Предыдущие уроки можно найти здесь:1. [Spaceship](https://habr.com/ru/post/535916/)
2. [Домино](https://habr.com/ru/post/536204/)
3. [Flappy Bird](https://habr.com/ru/post/536658/)
4. [Гравитационная комната](https://habr.com/ru/post/537580/)
5. [Платформер](https://habr.com/ru/post/537586/)
6. [Деревья (плагин SpeedTree)](https://habr.com/ru/post/538874/)
7. [Моделирование дома в SketchUp](https://habr.com/ru/post/538878/)
8. [Дом в лесу](https://habr.com/ru/post/538910/)
9. [Эффект дождя. Частицы](https://habr.com/ru/post/540146/)
10. [Бильярд](https://habr.com/ru/post/540186/)
11. [Жидкий персонаж](https://habr.com/ru/post/540274/)
12. [Стики и работа с Event System](https://habr.com/ru/post/541868/)
13. [Синтезатор на Unity 3D](https://habr.com/ru/post/551516/)
14. [Судно на воздушной подушке](https://habr.com/ru/post/552834/)
15. [Регдоллы на Unity 3D](https://habr.com/ru/post/552840/)
16. [Как работают векторы. Баскетбол на Unity 3D](https://habr.com/ru/post/553420/)
В этом проекте рассмотрим процесс работы:
* с рейкастами и векторами;
* с методами других пользовательских классов;
* с AudioSource и с Rigidbody через код;
* три основных составляющих выстрела, психологически действующих на игрока (звук, свет и свечение, анимация и след от выстрела);
* инстанцирование префабов.
Ключевыми темами проекта выступают именно рейкасты и векторы. Последним, необходимо уделять довольно много времени каждый день, и на простых примерах объяснять, как они устроены. Но если вам удалось быстро выполнить проект с учениками, то в этом уроке будет уместно рассмотреть mecanim-систему.
Порядок выполнения
------------------
Создаём новый проект, импортируем приложенный [ассет](https://disk.yandex.ru/d/djqB8cpF_jnAYw?w=1).
Помимо стандартных ресурсов пакет имеет сторонний плагин для рисовки декалей. Его работа в контексте данного урока не рассматривается.
Проект урока разбит на 2 части - тир и гранаты.
Тир
---
Тир - самый простой способ научить детей пользоваться рейкастами. Для упрощения, был заранее подготовлен ассет, содержащий все необходимые ресурсы, группе же перекидывается ассет, не содержащий скрипта мишени и её префаба.
Во время этой части урока необходимо объяснить, каким образом работает рейкаст и то, как можно взаимодействовать с другими скриптами из него.
Внутри проекта есть скрипт DecalShooter, который создаёт декали, и в котором расположен весь код стрельбы, включая рейкаст. В нём будет вводиться код взаимодействия с мишенью.
Для начала, необходимо подготовить саму мишень. Ею служит цилиндр, который необходимо уменьшить по Y до состоянии платины, удалить CapsuleCollider и поставить MeshCollider с галочкой Convex. Дополнительно, на цилиндр устанавливается текстура мишени, внутри цилиндра создаётся point light, подсвечивающий мишень, и объект с AudioSource для воспроизведения звука, а на сам цилиндр устанавливается Rigidbody с обработкой коллизий типа Continius Dynamic и галочкой isKinematik. У AudioSource не забудьте убрать галочку PlayOnAwake и закинуть звук попадания в мишень.
Следующим шагом становится создание скрипта Target, который сразу же накладываем на нашу мишень.
Мишень после этих действий необходимо добавить в новый префаб, чтобы при размножении мишени и внесении изменений не возникало необходимости править каждую. Теперь можно перейти к коду мишени.
```
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class Target : MonoBehaviour {
public GameObject light;
public Rigidbody rig;
public AudioSource src;
bool enabled = true;
// Use this for initialization
void Start() {
rig = GetComponent();
src = GetComponent();
}
// Update is called once per frame
void Update() {
}
public void shoot() {
if (!enabled) {
return;
}
rig.isKinematic = false;
light.SetActive(false);
src.Play();
enabled = false;
}
}
```
Код мишени содержит публичный метод shoot, который необходим для того, чтобы другие скрипты могли обращаться к нашей мишени. Следующий шаг - проверка из файла DecalShooter попали ли мы в мишень и вызов метода shoot. В рейкаст необходимо включить следующий участок кода:
```
if (Input.GetKeyDown(KeyCode.Mouse0)) {
time = 0.3f;
ShootSource.Play();
anim.Play("fire");
Muzzleflash.SetActive(true);
// Сама стрельба
RaycastHit hitInfo;
Vector3 fwd = transform.TransformDirection(Vector3.forward);
if (Physics.Raycast(transform.position, fwd, out hitInfo, 100f)) {
GameObject go = Instantiate(
DecalPrefab,
hitInfo.point,
Quaternion.LookRotation(
Vector3.Slerp(-hitInfo.normal, fwd, normalization)
)
) as GameObject;
go.GetComponent().UpdateDecalTo(
hitInfo.collider.gameObject,
true
);
Vector3 explosionPos = hitInfo.point;
Target trg = hitInfo.collider.GetComponent();
if (trg) {
trg.shoot();
}
Rigidbody rb = hitInfo.collider.GetComponent();
if (rb != null) {
rb.AddForceAtPosition(fwd \* power, hitInfo.point, ForceMode.Impulse);
Debug.Log("rb!");
}
}
// Сама стрельба
}
```
Данный код пытается получить компонент из объекта hitInfo и, если это удаётся, вызывает метод shoot. Мишень падает, свет от мишени выключается, звук попадания воспроизводится. Далее, желательно дать группе свободное задание по кастомизации своего проекта. Как альтернативу, можно предложить изменить код таким образом, чтобы мишень меняла цвет при попадании. Делается это заменой в Target строк:
```
light.SetActive(false);
```
на
```
light.GetComponent().color = Color.red;
```
Таким образом, свет меняется и не удаляется.
Гранаты
-------
Эта часть урока должна ещё больше закрепить понимание векторов и работы рейкастов.
Для начала, создадим другой скрипт - дальномер.
```
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class Lenght : MonoBehaviour {
public Text Dalnost;
float rasstoyanie = 0; // переменная для расстояния до цели
// Use this for initialization
void Start() {
}
// Update is called once per frame
void Update() {
RaycastHit hitInfo;
if (Physics.Raycast(transform.position, transform.TransformDirection(Vector3.forward), out hitInfo, 200)) {
rasstoyanie = hitInfo.distance;
Dalnost.text = rasstoyanie.ToString();
}
}
}
```
Скрипт закинем в FPScontroller/FirstPersonCharacter. В Canvas создадим текст, закинем его в скрипт.
В этом скрипте реализован простейший рейкаст, и на его примере мы разбираем, как рейкаст передаёт информацию в структуру и как нам получать из структуры эту информацию.
При срабатывании рейкаста мы выводим дальность на экран.
Следующий шаг - бросок гранаты. Мы не используем никаких анимаций, мы создаём гранату на небольшом расстоянии от игрока и придаём ей скорость по направлению взгляда. Изменим скрипт, добавив в него поля для префаба гранаты и код броска.
```
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class Length : MonoBehaviour {
public Text Dalnost;
float rasstoyanie = 0; // переменная для расстояния до цели
public GameObject sharik;
// Use this for initialization
void Start() {
}
// Update is called once per frame
void Update() {
RaycastHit hitInfo;
if(Physics.Raycast(transform.position, transform.TransformDirection(Vector3.forward), outhitInfo, 200)) {
rasstoyanie = hitInfo.distance;
Dalnost.text = rasstoyanie.ToString ();
if(Input.GetKeyDown(KeyCode.Mouse1)) {
GameObject go = Instantiate(
sharik,
transform.position + Vector3.Normalize(hitInfo.point - transform.position),
transform.rotation
);
Rigidbody rig = go.GetComponent();
rig.velocity = Vector3.Normalize(hitInfo.point - transform.position) \* 10;
}
}
}
}
```
Сразу же возникнет вопрос - зачем такое решение? К тому же, при направлении в небо бросок не произойдёт. Сделано всё это в учебных целях. Т.к. в рамках урока код пишется поэтапно, на данном участке объясняется, как найти вектор направления на объект по конечным и начальным координатам. Теперь дело за самой гранатой. Создадим скрипт Grenade.
```
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class Grenade : MonoBehaviour {
public Transform explosionPrefab;
void OnCollisionEnter(Collision collision) {
ContactPoint contact = collision.contacts[0];
// Rotate the object so that the y-axis faces along the normal of the surface
Quaternion rot = Quaternion.FromToRotation(Vector3.up, contact.normal);
Vector3 pos = contact.point;
Instantiate(explosionPrefab, pos, rot);
Destroy(gameObject);
}
}
```
Закидываем на сцену гранату, на меш Body ставим коллайдеру Convex, добавляем гранате RIgidbody и наш скрипт. Получившуюся гранату добавляем в префаб и удаляем со сцены.
Скрипт удаляет объект, на котором висит, но до этого инстантиирует объект, который мы выбираем в качестве эффекта взрыва.
Создадим эффект взрыва. В нём должен быть свет от взрыва, AudioSource с галочкой PlayOnAwake и звуком взрыва, Spital Blend на 90 процентов переведённый в 3д и увеличенный радиус распространения звука.
Для правильной отработки всех эффектов и разлёта Rigidbody нужно создать ещё один скрипт. Его мы назовём Explosion:
```
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class Explosion : MonoBehaviour {
public float radius = 5.0f;
public float power = 10.0f;
public GameObject svet;
void Start() {
Destroy(svet, 0.1f);
Vector3 explosionPos = transform.position;
Collider[] colliders = Physics.OverlapSphere(explosionPos, radius);
foreach(Collider hit in colliders) {
Rigidbodyrb = hit.GetComponent();
if (rb != null) {
rb.AddExplosionForce(power, explosionPos, radius, 3.0f);
}
}
}
}
```
Его нужно закинуть на эффект взрыва и создать префаб.
Данный префаб и используется в скрипте гранаты для создания взрыва.
Готово!
 | https://habr.com/ru/post/556176/ | null | ru | null |
# Особенности разработки API на Symfony2
Так вышло, что всю свою недолгую карьеру я занимаюсь разработкой API для мобильных приложений и сайтов на Symfony2. Каждый раз открываю для себя все новые знания, которые кому-то покажутся очевидными, а кому-то помогут сэкономить не мало времени. Об этих знаниях и пойдет речь.
### Формы
Вообще использовать дефолтные формы для API не лучшая идея, но если вы все же решились, то вам необходимо не забывать о некоторых особенностях. Изначально формы в symfony делались для обычных сайтов, где фронтенд и бекенд объединены.
Первая проблема возникает с [entity type](http://symfony.com/doc/current/reference/forms/types/entity.html). Когда вы отсылаете запрос к методу, который использует entity type в формах – сначала достаются все сущности указанного класса, и только потом запрос на получение нужной сущности по отправленному id. Многие не знают об этом и очень удивляются, почему метод работает так долго.
**Пример решения**EntityType.php
```
php
namespace App\CommonBundle\Form\Type;
use App\CommonBundle\Form\DataTransformer\EntityDataTransformer;
use Doctrine\ORM\EntityManager;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolverInterface;
class EntityType extends AbstractType
{
private $em;
public function __construct(EntityManager $em)
{
$this-em = $em;
}
public function setDefaultOptions(OptionsResolverInterface $resolver)
{
$resolver->setDefaults([
'field' => 'id',
'class' => null,
'compound' => false
]);
$resolver->setRequired([
'class',
]);
}
public function buildForm(FormBuilderInterface $builder, array $options)
{
$builder->addModelTransformer(new EntityDataTransformer($this->em, $options['class'], $options['field']));
}
public function getName()
{
return 'entity';
}
}
```
EntityDataTransformer.php
```
php
namespace App\CommonBundle\Form\DataTransformer;
use Doctrine\ORM\EntityManager;
use Symfony\Component\Form\DataTransformerInterface;
class EntityDataTransformer implements DataTransformerInterface
{
private $em;
private $entityName;
private $fieldName;
public function __construct(EntityManager $em, $entityName, $fieldName)
{
$this-em = $em;
$this->entityName = $entityName;
$this->fieldName = $fieldName;
}
public function transform($value)
{
return null;
}
public function reverseTransform($value)
{
if (!$value) {
return null;
}
return $this->em->getRepository($this->entityName)->findOneBy([$this->fieldName => $value]);
}
}
```
services.yml
```
common.form.type.entity:
class: App\CommonBundle\Form\Type\EntityType
arguments: [@doctrine.orm.entity_manager]
tags:
- { name: form.type, alias: entity }
```
Вторая проблема возникает с [checkbox type](http://symfony.com/doc/current/reference/forms/types/checkbox.html), который пытаются использовать для булевых значений, но особенность работы этого типа такова, что если ключ существует и он не пустой, то вернется true.
**Пример решения**BooleanType.php
```
php
namespace App\CommonBundle\Form\Type;
use App\CommonBundle\Form\DataTransformer\BooleanDataTransformer;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;
class BooleanType extends AbstractType
{
public function buildForm(FormBuilderInterface $builder, array $options)
{
$builder-addViewTransformer(new BooleanDataTransformer());
}
public function getParent()
{
return 'text';
}
public function getName()
{
return 'boolean';
}
}
```
BooleanDataTransformer.php
```
php
namespace App\CommonBundle\Form\DataTransformer;
use Symfony\Component\Form\DataTransformerInterface;
use Symfony\Component\Form\Exception\TransformationFailedException;
class BooleanDataTransformer implements DataTransformerInterface
{
public function transform($value)
{
return null;
}
public function reverseTransform($value)
{
if ($value === "false" || $value === "0" || $value === "" || $value === 0) {
return false;
}
return true;
}
}
</code
```
services.yml
```
common.form.type.boolean:
class: App\CommonBundle\Form\Type\BooleanType
tags:
- { name: form.type, alias: boolean }
```
### JMS Serializer
Во всех статьях про создание API советуется именно это замечательное расширение. Люди смотрят простенький пример, где у сущностей есть две serialization groups: details и list, и начинают у каждой сущности использовать именно эти названия и все замечательно работает, пока не попадется какая-нибудь связанная сущность, у которой группы названы точно так же и выводится очень много лишней, не нужной информации. Также это может уводить в бесконечный цикл при сериализации, если обе модели выводят связь друг с другом.
**Пример неправильного использования**News.php
```
php
use JMS\Serializer\Annotation as Serialization;
class News
{
/**
* @Serialization\Groups({"details", "list"})
*/
protected $id;
/**
* @Serialization\Groups({"details", "list"})
*/
protected $title;
/**
* @Serialization\Groups({"details", "list"})
*/
protected $text;
/**
* Связь с сущностью User
*
* @Serialization\Groups({"details", "list"})
*/
protected $author;
}
</code
```
User.php
```
php
use JMS\Serializer\Annotation as Serialization;
class User
{
/**
* @Serialization\Groups({"details", "list"})
*/
protected $id;
/**
* @Serialization\Groups({"details", "list"})
*/
protected $name;
/** Огромный список полей отмеченных группами list и details */
}
</code
```
NewsController.php
```
php
class NewsController extends BaseController
{
/**
* @SerializationGroups({"details"})
* @Route("/news/{id}", requirements={"id": "\d+"})
*/
public function detailsAction(Common\Entity\News $entity)
{
return $entity;
}
}
</code
```
В примере видно, что при получении новости в поле author будут все поля, которые в User с группой details, что явно не входит в наши планы. Казалось бы, очевидно, что так делать нельзя, но, к моему удивлению, так делают многие.
Я советую именовать группы как %entity\_name%\_details, %entity\_name%\_list и %entity\_name%\_embed. Последняя нужна как раз для тех случаев, когда есть связанные сущности и мы хотим вывести какую-то связанную сущность в списке.
**Пример правильного использования**News.php
```
php
use JMS\Serializer\Annotation as Serialization;
class News
{
/**
* @Serialization\Groups({"news_details", "news_list"})
*/
protected $id;
/**
* @Serialization\Groups({"news_details", "news_list"})
*/
protected $title;
/**
* @Serialization\Groups({"news_details", "news_list"})
*/
protected $text;
/**
* Связь с сущностью User
*
* @Serialization\Groups({"news_details", "news_list"})
*/
protected $author;
}
</code
```
User.php
```
php
use JMS\Serializer\Annotation as Serialization;
class User
{
/**
* @Serialization\Groups({"user_details", "user_list", "user_embed"})
*/
protected $id;
/**
* @Serialization\Groups({"user_details", "user_list", "user_embed"})
*/
protected $name;
/** Огромный список полей, которые отмечены группами user_list и user_details */
}
</code
```
NewsController.php
```
php
class NewsController extends BaseController
{
/**
* @SerializationGroups({"news_details", "user_embed"})
* @Route("/news/{id}", requirements={"id": "\d+"})
*/
public function detailsAction(Common\Entity\News $entity)
{
return $entity;
}
}
</code
```
При таком подходе будут только необходимые поля, к тому же это можно будет использовать в других местах, где тоже нужно вывести краткую информацию о пользователе.
### Конец
На самом деле, подобных советов еще очень много и если вам будет интересно, я с радостью ими поделюсь. | https://habr.com/ru/post/257991/ | null | ru | null |
# Ликбез по браузерам для Windows в 2020
Доброго времени суток, Хабр! В очередной раз читая комментарии, наткнулся на мысль о том, что далеко не все понимают, как обстоит ситуация с браузерами для Windows на данный момент. От чего хотелось бы провести небольшой обзор текущего положения. Ну, и сразу к делу!
Браузерные движки
-----------------
Браузер — программа не простая, это целый набор компонентов, взаимодействующих между собой. Для краткого обзора потребуются всего два компонента из множества — движок отрисовки содержимого и движок исполнения JavaScript.
### Существующие движки отрисовки содержимого
* **Trident** (так же известный как **MSHTML**) — движок, ранее разрабатываемый Microsoft для браузера Internet Explorer;
* **EdgeHTML** — преемник Trident, ранее разрабатываемый Microsoft для браузера Legacy Edge (ранее просто Edge);
* **WebKit** — движок, разрабатываемый Apple для браузера Safari;
* **Blink** — преемник WebKit, разрабатываемый Google для браузера Chrome;
* **Gecko** — движок, разрабатываемый Mozilla для браузера Firefox;
* **Servo** — исследовательский проект Mozilla, некоторые технологии со временем перетекают в Gecko.
### Существующие движки исполнения JavaScript
* **Chakra JScript** — движок JS, ранее разрабатываемый Microsoft для браузера Internet Explorer;
* **Chakra JavaScript** — преемник Chakra JScript, ранее разрабатываемый Microsoft для браузера Legacy Edge;
* **Nitro** — движок JS, разрабатываемый Apple для браузера Safari;
* **V8** — движок JS, разрабатываемый Google для браузера Chrome;
* **SpiderMonkey** — движок JS, разрабатываемый Mozilla для браузера Firefox.
И тут вроде бы очевидно, какие браузеры какие движки используют, но Microsoft внёс ~~не~~много путаницы в понимание данной темы, поэтому рассмотрим браузеры отдельно.
Браузеры
--------
### Chromium
Chromium — это open-source ответвление браузера Chrome. Браузеры на основе Chromium составляют большую часть из всех используемых браузеров на планете Земля.
Обычно, браузеры на базе Chromium между собой отличаются только визуально, ведь у всех под капотом движки **Blink** и **V8**, хотя, какие-то компании пытаются привнести больше функционала в браузер, чем имеется.
**ИМХО**
Это в конечном итоге встанет разработчикам браузеров боком, потому что в любой момент главный разработчик Chromium — Google может вставить палки в колёса разработчикам модификаций.
Всех браузеров на основе Chromium подсчитать одному человеку вряд ли под силу, поэтому приведу список только тех, что помню:
* **Chrome** — в представлении не нуждается, браузер от Google;
* **~~Chr~~Edge** — новый браузер от Microsoft со старым названием. Поговаривают, отличается большей производительностью от Chrome. С некоторых пор предустанавливается в систему;
* **Brave** — браузер с повышенной безопасностью настолько, что приватный режим использует Tor;
* **Яндекс.Браузер**, **Opera**, **Vivaldi**, тысячи их.
### Firefox
Firefox использует движки **Gecko** и **SpiderMonkey** для своей работы. Имеет небольшое количество базирующихся на Firefox браузеров, но самый известный — Tor Browser. Является единственным рубежом до полного перехода интернета на браузеры на основе Chromium.
### Internet Explorer
Это любимая всеми утилита для скачивания браузеров. Как и Chrome — не нуждается в представлении. До 11 версии использовал движки **Trident** и **Chakra JScript**. В 11 версии, за исключением режима совместимости, стал использовать движки **Trident** и **Chakra JavaScript**. Этот браузер ещё долго будет использоваться для всякого рода систем видеонаблюдения, поскольку имеет, почему-то, популярный в узких кругах API для расширений. В Windows 8 и Windows 8.1 имел особую модификацию движка **Trident** на базе WinRT для Metro режима.
### (Legacy) Edge
Браузер, начавший своё существование с кодовым названием Project Spartan, являлся новым браузером от Microsoft в 2015 году, использующим движки **EdgeHTML** и **Chakra JavaScript**. Конечной целью проекта была полная совместимость с сайтами, отлично работающими в Chrome. В итоге — получилось нечто своеобразное, но, очевидно, не выжившее под давлением Google.
### Safari
Safari? А нет его больше, этого вашего Safari, кончился.
Нецелевое использование браузеров
---------------------------------
Вроде бы браузеры — законченный продукт, ни добавить ни отнять. Однако, они используются в разного рода других приложениях. Причины в следующем (в порядке убывания значимости):
* П~~р~~ограммистов на JS нечем занять;
* На JS+HTML новичкам проще программировать;
* Кроссплатформенность;
* Требуется возможность отображать веб-страницы.
Приведу примеры подобного использования:
### Chromium
Нынешние браузеры настолько сложны, что одному человеку создать собственный браузер не под силу (либо это должен быть гений). Они по сложности сравнимы с операционными системами! А, постойте, вот и первый кандидат на нецелевое использование — **Chrome OS**. Да, весь пользовательский интерфейс — просто модифицированный Chromium.
Однако, помимо этого, в виде **CEF** (Chromium Embedded Framework), Chromium используется в:
* Игровые платформы: Steam, Epic Games Store, Battle.Net и другие;
* Игры: GTA V, все игры от Blizzard, DOTA 2, CS GO и множество других;
* Редакторы кода: Atom, VS Code, Visual Studio Installer(???!);
* Программы для общения: Skype, Viber, WhatsApp, Discord, Slack и множество других;
* Другие программы: balenaEtcher, draw.io и великое множество других.
### Internet Explorer
Почти любое Win32 приложение, умеющее отображать WEB-страницы и при этом в распакованном виде занимающее меньше 60 мегабайт использует внутри Internet Explorer. Кстати, это касается не только маленьких по размеру приложений, например, Visual Studio использует Internet Explorer для отображения WEB-страниц, когда это требуется в работе IDE. Ещё существуют HTA приложения — древний предшественник CEF на базе Internet Explorer. И ведь до сих пор работает.
### (Legacy) Edge
Новым приложениям — новые движки! Любое UWP приложение, использующее внутри отображение WEB-страниц работает на базе Edge. Не то, чтобы Microsoft запрещали использовать что-то другое, но никто просто и не старался. Так же, пока что, в предварительных сборках Windows новая клавиатура с GIF панелью тоже использует Edge для рендеринга. В будущих версиях, полагаю, перейдут на ~~Chr~~Edge.
**Большая картинка с клавиатурой**
Производительность
------------------
Постойте, столько приложений, а что там с производительностью? Лично я — не специалист в оценке производительности, но хочу поделится с вами некоторыми занимательными фактами.
### Prefetcher
В Windows есть такая штука — Prefetcher. Она занимается подгрузкой программ в ОЗУ при старте ОС и на протяжении её работы. Штука эта достаточно умная, и она анализирует чаще всего запускаемые программы, чтобы в дальнейшем их подгружать.
Как это связано с браузерами? Идея в том, что это может смазать первый пользовательский опыт с другим браузером, например, пользуясь постоянно Chrome, имеете установленную версию Firefox. При запуске Firefox будет вести себя крайне медленно — медленнее, чем ваш основной браузер. Всё потому что он запылился в глазах Prefetcher. В конечном итоге всё будет работать быстро, но первое впечатление после долгого неиспользования будет ужасным. Особенно это касается пользователей с HDD или малым количеством ОЗУ.
### Области распределённой памяти
Да, звучит не очень. Но суть, в данном случае, простая — если одна единица исполняемого кода требуется к исполнению больше одного раза, будь то `exe` или `dll`, то в память она загрузится лишь один раз. Поясню: если два различных приложения в ходе своей работы загрузят одну и ту же библиотеку, например, `edgehtml.dll`, то этот файл будет загружен в ОЗУ компьютера **на самом деле** только один раз, хотя, казалось бы, потребуется два или больше раз. Таким образом ОС экономит нам оперативную память.
### Движки нормального человека
К чему это я? А вот дело в том, что в отличии от других браузеров, Internet Explorer и (Legacy) Edge предустановлены в систему, а их движки хранятся в папке `System32`. Это, вкупе с API для разработки приложений, означает, что все приложения в системе, использующие данные движки будут загружать их в память только однажды. И этот принцип распространяется на все приложения.
**В дополнение про UWP**
У людей часто возникают проблемы с UWP приложениями, а точнее — с их скоростью запуска. Всё дело в WinRT — огромном наборе библиотек, при помощи которых UWP приложение взаимодействует с ОС. Если не использовать UWP приложения часто, то этот набор библиотек не будет прогружен в памяти полностью, и придётся ожидать окончания этого процесса перед использованием приложения. Но забавный факт — используя два и более UWP приложения время их старта и общая производительность резко увеличиваются и часто даже превосходят Win32 программы. Исключением из этого является приложение "Фотографии" — тут отдельная история, покрытая туманом.
### Движки курильщика
А вот с приложениями (в том числе и браузерами) на основе Chromium это так не работает. Каждое приложение комплектует с собой собственную сборку библиотеки CEF, что, кроме раздувания размера приложения, не позволяет операционной системе иметь только одну копию `dll` в ОЗУ. Итого это сильно замедляет производительность при использовании множества подобных приложений. Помимо того, сам размер CEF довольно удручающий.
Microsoft Store
---------------
У многих возникает вопрос — почему в Microsoft Store нет ни одного браузера(не считая нескольких кривых поделок на EdgeHTML)? Ответ, на самом деле, прост — все браузеры, включая ~~Chr~~Edge имеют собственную систему обновления, что прямо запрещено правилами Microsoft Store. В остальном никто никого не ограничивает.
Как удалить новый Microsoft Edge
--------------------------------
Это не очень сложно. Для начала требуется найти папку с Microsoft Edge, она расположена по пути:
`C:\Program Files (x86)\Microsoft\Edge\Application`
Далее заходим в любую версию Edge и переходим в папку `Installer`. Полный путь может выглядеть следующим образом:
`C:\Program Files (x86)\Microsoft\Edge\Application\83.0.478.58\Installer`
Далее необходимо открыть командную строку от имени администратора в данной папке и выполнить следующую команду:
`setup.exe --uninstall --system-level --verbose-logging --force-uninstall`
Готово! Через несколько секунд этот браузер исчезнет из системы. Но при следующем же обновлении он появится снова, будте бдительны.
Заключение
----------
Пожалуй, эта статья получилась даже больше, чем я предполагал. В любом случае, какой браузер использовать — выбор ваш, но, зато, вы теперь знаете чуточку больше. Всем спасибо.
### P. S.
Администраторы Хабра, пожалуйста, почините HabraStorage в Legacy Edge! Совсем не дело. | https://habr.com/ru/post/518834/ | null | ru | null |
# TDD для микроконтроллеров. Часть 1: Первый полет
> [TDD для микроконтроллеров. Часть 1: Первый полет](https://habr.com/ru/company/ntc-vulkan/blog/487966/)
>
> [TDD для микроконтроллеров. Часть 2: Как шпионы избавляют от зависимостей](https://habr.com/ru/company/ntc-vulkan/blog/488370/)
>
> [TDD для микроконтроллеров. Часть 3: Запуск на железе](https://habr.com/ru/company/ntc-vulkan/blog/489186/)
Встраиваемые системы широко применяются в бытовой электронике, промышленной автоматике, транспортной инфраструктуре, телекоммуникациях, медицинском оборудовании, а также в военной, аэрокосмической технике и т. д. Хотя последствия любой ошибки проектирования обходятся дорого, ошибку в ПО для ПК или в большом корпоративном приложении обычно относительно легко исправить. А если дефект будет во встраиваемом ПО (далее – ВПО) электронного блока управления тормозной системой автомобиля, то это может вызвать массовый и дорогостоящий отзыв продукции.
Сфера применения встраиваемых систем постоянно расширяется, сложность выполняемых ими задач растет. Это в свою очередь повышает риск внесения ошибок в процессе разработки, что увеличивает вероятность весьма дорогостоящих дефектов в ПО.
Одной из наиболее популярных методологий улучшения качества разрабатываемых приложений является Test-driven development (TDD). Но эффективна ли методология TDD для разработки встраиваемых систем? Ответ на этот вопрос будем искать под катом.
Эффективность TDD
=================
Все большее число разработчиков придерживаются мнения, что методология [TDD имеет ряд преимуществ](https://habr.com/ru/post/313584/) над Test-last development (TLD). При этом TDD понимается как процесс итеративного, непрерывного написания тестов и рабочего кода с обязательными фазами рефакторинга.
*Схема итеративного процесса разработки TDD*
В результате применения TDD можно выделить [следующие улучшения](https://medium.com/@MasterOfCodeGlobal/benefits-of-test-driven-development-64a24bbe743e) при проектировании приложений:
* TDD позволяет сконцентрироваться на дизайне и понять, как сделать его лучше;
* TDD избавляет разработчиков от страха внесения изменений в код: при внесении некорректных изменений будет легко «отловить» ошибку с помощью запуска тестов;
* хорошо спроектированные тесты выступают в роли показательного примера использования программного модуля, что заменяет документирование кода;
* TDD улучшает покрытие кода тестами;
* завершенные тесты демонстрируют прогресс разработки: каждый реализованный тест-кейс указывает на то, что очередной функционал завершен и работает;
* уменьшается количество багов.
В настоящее время довольно просто писать тесты. Многие среды разработки позволяют добавлять тест в проект за пару кликов мыши или с помощью сочетания клавиш, что экономит немало времени, разработчику остается только самостоятельно заполнить тело теста. При этом не нужно тратить время на настройку среды разработки или скачивание дополнительных фреймворков и их подключение. Например, в Android Studio это довольно [простой и быстрый процесс](https://developer.android.com/training/testing/unit-testing/local-unit-tests.html).
Однако среды разработки для создания ВПО микроконтроллеров (далее – МК) не так стремительно развиваются, в некоторых из них отсутствует возможность создавать и запускать тесты, а также быстро получать результат их выполнения. К тому же один и тот же разработчик может иметь дело с разными аппаратными платформами, т. е. вести разработку с помощью разных интегрированных сред разработки (Integrated Development Environment – IDE). Поэтому возникают следующие вопросы:
> Как запускать тесты для embedded, будь то TLD или TDD?
>
>
>
> Будем ли мы наблюдать указанные выше улучшения в результате применения TDD при разработке встраиваемых систем?
На эти вопросы мы попытаемся ответить в данной статье.
Особенности разработки в embedded
=================================
При проектировании встраиваемых систем необходимо учитывать специфику разработки ВПО:
* ВПО запускается на МК, у которых могут быть ограниченный объем памяти, своя архитектура и т. д.;
* ВПО выполняется в среде со специфичной аппаратной поддержкой, т. е. имеет множество библиотек для взаимодействия с различными аппаратными модулями.
Как правило, для проектирования ВПО используется специализированная IDE. Обычно разработчик может загрузить с сайта производителя библиотеки для работы с аппаратными модулями конкретного МК – Hardware Abstraction Level (HAL). Но далеко не каждая IDE предоставляет инструменты для написания тестов ВПО. Кроме того, использование библиотек или написание собственных драйверов для взаимодействия с периферией МК вносит аппаратные зависимости в разрабатываемый код прошивки. Такой код будет работать только на конкретном МК (или на определенной серии МК).
Так, для применения TDD при проектировании встраиваемых систем нужно ответить на ряд вопросов:
1. Каким образом писать и запускать тесты?
2. Что делать с аппаратными зависимостями?
3. Как организовать непрерывную и итеративную разработку?
Мы попробуем ответить на эти вопросы, реализовав конкретный пример ВПО для МК с помощью методологии TDD. В завершение мы приведем плюсы и минусы применения этой методологии для разработки встраиваемых систем. Конечно, ответы на все эти вопросы не будут рассматриваться в рамках одной статьи, поэтому мы запланировали к публикации небольшой цикл статей.
**Планируемый цикл статей**
1. В первой части (вы сейчас ее читаете) мы определим цель и инструменты разработки, затем напишем простейший тест, запустим его и представим результат.
2. [Во второй части](https://habr.com/ru/company/ntc-vulkan/blog/488370/) рассмотрим процесс разработки ВПО по методологии TDD, реализуем основную платформонезависимую логику нашего проекта и применим методы для разрешения аппаратных зависимостей с целью тестирования нашего кода.
3. [В третьей части](https://habr.com/ru/company/ntc-vulkan/blog/489186/) допишем платформозависимый код (драйвер) и запустим ВПО на МК STM32F103C8, подведем итоги, учитывая материалы всего цикла статей, и перечислим плюсы и минусы применения TDD при разработке ВПО для МК.
Все исходники проекта выложены на [GitLab](https://gitlab.com/RaccoonSecurity/tddforembedded).
Разрабатываемый функционал
==========================
Многие embedded-устройства могут подключаться к ПК для конфигурирования каких-либо параметров, т. е. в таком устройстве содержатся настройки, которые можно считывать или записывать. Мы приведем пример реализации именно такого функционала. Для подключения к ПК будем использовать UART-интерфейс, а в качестве энергонезависимой памяти – флеш-память МК. Таким образом, нам необходимо реализовать следующий функционал:
* подключение устройства к ПК по UART-интерфейсу;
* сохранение параметров в энергонезависимой памяти с помощью ПК по UART-интерфейсу;
* считывание параметров из энергонезависимой памяти с помощью ПК по UART-интерфейсу.
Выбор аппаратной платформы
==========================
Для реализации нашего проекта мы выбрали отладочную плату с МК STM32F103C8, потому что МК STM32 одни из самых популярных в настоящее время, а отладочная плата стоит недорого и ее легко приобрести.
В качестве энергонезависимой памяти в выбранном МК может быть использована флеш-память. Однако следует помнить о том, что код ВПО также хранится во флеш-памяти, которая разделена на страницы. Количество и размер страниц варьируется в зависимости от линейки МК (подробно описано в [Programming manual](https://www.st.com/content/ccc/resource/technical/document/programming_manual/10/98/e8/d4/2b/51/4b/f5/CD00283419.pdf/files/CD00283419.pdf/jcr:content/translations/en.CD00283419.pdf)).
Перед записью во флеш-память необходимо убедиться, что страница была предварительно стерта.
Инструменты разработки
======================
Для создания тестов и основной логики проекта мы выбирали IDE на свой вкус и цвет, потому что в первую очередь разрабатывали платформонезависимый код, который можно скомпилировать и запустить на локальном ПК. Для разработки ВПО чаще всего используется либо «чистый» C, либо С++, поэтому для написания тестов ВПО нужно использовать соответствующий фреймворк для тестирования. В результате мы выбрали следующие инструменты для написания тестов и платформонезависимой бизнес-логики:
1. В качестве IDE – [Visual Studio](https://visualstudio.microsoft.com/), потому что нам нравится ее внешний вид, удобство отладки и рефакторинга кода. Данная IDE также подходит для написания кода на «чистом» C.
2. [CppUTest](https://cpputest.github.io/) – простой в настройке и в освоении фреймворк для модульного тестирования, который может использоваться для написания любых unit-тестов на C/C++.
Создание и настройка проекта в Visual Studio
============================================
С целью написания тестов и кода нашей бизнес-логики в первую очередь мы создали новое решение в Visual Studio, добавили в него первый проект на **Visual C++** с именем проекта Tests и типом «консольное приложение Windows». В этом проекте содержатся только код тестов и дополнительные программные модули для тестирования (например, spies, mocks, stubs и т. д.).
**Настраиваем проект Tests**1. Заходим в ***Properties -> C/C++ -> General -> Additional Include Directories*** и добавляем строки:
*— $(CPP\_U\_TEST)\include*
*— $(SolutionDir)..\Firmware\Project\Include* (путь к заголовочным файлам тестируемого кода)
2. Заходим в ***Properties -> Linker -> Input*** и добавляем строки:
*— $(CPP\_U\_TEST)\lib\cpputestd.lib*
*— $(SolutionDir)Debug\ProductionCodeLib.lib*
Где *$(CPP\_U\_TEST)* – переменная среды Windows, в которой содержится путь к папке *cpputest* (см. скриншот).
Добавляем в проект файл *Tests.cpp* с содержанием:
```
#include "CppUTest/CommandLineTestRunner.h"
int main(int argc, char** argv)
{
return RUN_ALL_TESTS(argc, argv);
}
```
Далее в этом же решении создали второй проект с именем ProductionCodeLib, тип – статическая библиотека **Visual C++**. В этот проект мы будем добавлять код бизнес-логики, который планируем запустить на «железе», т. е. код, компилируемый в файл прошивки для STM32F103C8.
**Настраиваем проект ProductionCodeLib**Добавляем пути к заголовочным файлам, используемым для создания ВПО:
* заходим в ***Properties -> C/C++ -> General -> Additional Include Directories*** и добавляем строку *\$(SolutionDir)..\Firmware\Project\Include\*
После настройки впервые запустили проект, нажав на кнопку «Run», и увидели отчет о том, что ни одного теста не было выполнено:
OK (0 tests, 0 ran, 0 checks, 0 ignored, 0 filtered out, 0 ms)
На этом настройка завершилась, можно приступить к итеративной разработке.
Разработка ВПО по методологии TDD
=================================
Мы решили использовать «чистый» C, при этом старались сохранить применение базовых принципов ООП. Такой подход обычно называют псевдо-ООП, потому что «чистый» С не поддерживает классы. В соответствии с целью нашего проекта мы создали класс `Configurator`, в котором реализовали следующую логику:
* обработка команд ПК по UART-интерфейсу;
* чтение/запись во флеш-память;
* стирание страницы флеш-памяти.
Конечно, в первую очередь мы создавали список тестов для будущего класса. Для этого брали блокнот и ручку (клавиатуру и текстовый редактор) и описывали простыми словами, какая логика нам была нужна. Такой процесс для нашего модуля занял около 5 минут. Ниже приведен *тест-лист* для класса *Configurator.*
Тест-лист
=========
*1. При получении команды `read` возвращаются данные, размещенные по указанному адресу на флеш-памяти.*
*2. При получении команды `write` производится запись данных по указанному адресу во флеш-память.*
*3. При получении команды `erase` производится стирание страницы с указанным номером.*
*4. При получении команды `help` выводится список поддерживаемых команд.*
*5. При получении `неизвестной команды` возвращается сообщение об ошибке.*
Для простоты и наглядности мы решили использовать строковый формат команд в кодировке ASCII.
Основы CppUTest и первый тест
=============================
Для реализации тестов создали файл `ConfiguratorTests.cpp` в проекте `Tests`, который затем постепенно наполняли новыми тестами в соответствии с методологией TDD.
Для написания тестов с помощью `CppUTest` используется [простая структура](https://cpputest.github.io/manual.html#getting_started).
**Структура написания тестов для CppUTest:**
```
TEST_GROUP(TestGroupName)
{
void setup()
{
}
void teardown()
{
}
};
TEST(TestGroupName, TestName)
{
}
```
Где:
* TEST\_GROUP – блок кода, в котором могут содержаться методы *setup()* и *teardown()*, а также другие вспомогательные методы или переменные;
* setup() – функция, вызываемая перед запуском каждого теста;
* teardown() – функция, вызываемая в завершении каждого теста;
* TEST – блок кода, в котором реализуется один тест, таких тестов может быть много;
* TestGroupName – название группы тестов обычно совпадает с именем класса, для которого предназначены тесты;
* TestName – название теста.
Каждый тест должен работать независимо от любых других тестов. Поэтому перед каждым запуском теста следует создавать объект, а в завершение теста удалять его. Так, для нашего класса `Configurator` в простейшем случае в `setup()` создается экземпляр, а в `teardown()` удаляется. Чтобы убедиться в том, что объект успешно создается, мы добавили простейший тест для проверки значения указателя. Если объект по каким-то причинам не был создан, то указатель будет равен значению `NULL`. Назвали тест *ShouldNotBeNull*.
**Реализация теста ShouldNotBeNull:**
```
// ConfiguratorTests.cpp
TEST_GROUP(Configurator)
{
Configurator * configurator = NULL;
void setup()
{
configurator = Configurator_Create();
}
void teardown()
{
Configurator_Destroy(configurator);
}
};
TEST(Configurator, ShouldNotBeNull)
{
CHECK_TRUE(configurator);
}
```
Первый тест был готов, но еще возвращал ошибки компиляции, потому что на данном этапе не были реализованы методы `Configurator_Create` и `Configurator_Destroy`. Для успешного завершения теста оставалось написать лишь эти два метода. И только на этом шаге мы написали первые строчки с реализацией функционала ВПО в проекте `ProductionCodeLib`. Для этого создали заголовочный файл `Configurator.h` и файл `Configurator.c`, в котором содержится реализация бизнес-логики. В `Configurator.h` добавили прототипы двух перечисленных методов. А в файл `Configurator.c` сначала добавили заглушки, т. е. оставили тело каждого метода пустым. Это было нужно для того, чтобы скомпилировать проект и запустить тесты.
**Реализация заглушек для теста ShouldNotBeNull:**
```
// Configurator.h
typedef struct ConfiguratorStruct Configurator;
Configurator * Configurator_Create(void);
void Configurator_Destroy(Configurator * self);
// Configurator.c
#include "Configurator.h"
typedef struct ConfiguratorStruct
{
char command[32];
} ConfiguratorStruct;
Configurator * Configurator_Create(void)
{
return NULL;
}
void Configurator_Destroy(Configurator * self)
{
}
```
В соответствии с методологией TDD следует убедиться, что тест запускается, но завершается с ошибкой (т. к. тело метода `Configurator_Create` на данный момент было пустым). Пробуем запустить и получаем статус выполнения теста `failed`, что и следовало ожидать. Это означает, что мы успешно выполнили фазу *test-fails*.
**Вывод ошибки на экран при запуске теста:**
```
d:\\exampletdd\\tests\\tests\\configuratortests.cpp(27): error: Failure in TEST(Configurator, ShouldNotBeNull)
CHECK_TRUE(configurator) failed
.
Errors (1 failures, 1 tests, 1 ran, 1 checks, 0 ignored, 0 filtered out, 2 ms)
```
Для перехода на следующую фазу *test-passes* необходимо было заполнить тело конструктора. Мы добавили в метод *Configurator\_Create* выделение памяти и возврат указателя на объект, этого достаточно для успешного выполнения теста *ShouldNotBeNull*. Также следовало освободить выделенную память в завершение теста, поэтому заполнили тело деструктора *Configurator\_Destroy*.
В итоге *Configurator\_Create* и *Configurator\_Destroy* выглядят так:
```
Configurator * Configurator_Create(void)
{
Configurator * self = (Configurator*)calloc(1, sizeof(ConfiguratorStruct));
return self;
}
void Configurator_Destroy(Configurator * self)
{
if (self == NULL)
{
return;
}
free(self);
self = NULL;
}
```
В результате запустили тест и получили положительный результат:
```
.
OK (1 tests, 1 ran, 1 checks, 0 ignored, 0 filtered out, 0 ms)
```
Это означает, что фаза test-passes завершилась. Далее следует фаза рефакторинга, в которой, как правило, производится улучшение дизайна, читаемости кода и т. д. В нашем случае кода еще совсем мало, поэтому мы только заменили «магическое» число `32` на константу с помощью *#define* (можно использовать `enum` или `const` вместо `define`).
Убираем антипаттерн («магическое» число) с помощью *#define*:
```
// Configurator.h
#define SERIAL_RECEIVE_BUFFER_SIZE 32
// Configurator.c
typedef struct ConfiguratorStruct
{
char command[SERIAL_RECEIVE_BUFFER_SIZE];
} ConfiguratorStruct;
```
Итог
====
Подведем промежуточные итоги опыта, описанного в этой статье:
1. Мы определили цели проекта, выбрали аппаратную платформу и инструменты для проектирования.
2. Подготовили ПК для локальной разработки тестов и кода ВПО без применения специализированных IDE для конкретного МК.
3. Создали простейший тест, для запуска которого достаточно нажать на кнопку «Run» (или соответствующую горячую клавишу), чтобы мгновенно получить результат выполнения на экране.
В следующей статье мы напишем всю платформонезависимую логику нашего проекта по методологии TDD в соответствии с разработанным выше тест-листом. Если тебе интересны вопросы «железной» разработки и безопасного кода, [присоединяйся к нашей команде](https://raccoonsecurity.ru/vacancies/). Так что [продолжение следует…](https://habr.com/ru/company/ntc-vulkan/blog/488370/)
**Дополнительная информация****Ссылки**
* [TDD для микроконтроллеров. Часть 2: Как шпионы избавляют от зависимостей](https://habr.com/ru/company/ntc-vulkan/blog/488370/)
* [TDD для микроконтроллеров. Часть 3: Запуск на железе](https://habr.com/ru/company/ntc-vulkan/blog/489186/)
* Проект на [GitLab](https://gitlab.com/RaccoonSecurity/tddforembedded)
* [CppUTest](https://cpputest.github.io/)
* [Visual Studio](https://visualstudio.microsoft.com/)
* [STM32CubeMX](https://www.st.com/en/ecosystems/stm32cube.html)
* [Atollic TrueStudio](https://atollic.com/truestudio/)
**Литература**
* Test Driven Development for Embedded C, James Grenning
* [STM32F103C8 Programming manual](https://www.st.com/content/ccc/resource/technical/document/programming_manual/10/98/e8/d4/2b/51/4b/f5/CD00283419.pdf/files/CD00283419.pdf/jcr:content/translations/en.CD00283419.pdf)
* [STM32F103C8 Reference manual](https://www.st.com/content/ccc/resource/technical/document/reference_manual/59/b9/ba/7f/11/af/43/d5/CD00171190.pdf/files/CD00171190.pdf/jcr:content/translations/en.CD00171190.pdf)
[](https://raccoonsecurity.ru/)
*Raccoon Security – специальная команда экспертов НТЦ «Вулкан» в области практической информационной безопасности, криптографии, схемотехники, обратной разработки и создания низкоуровневого программного обеспечения.* | https://habr.com/ru/post/487966/ | null | ru | null |
# Облачный сервис Parse и Intel Edison
[](http://geektimes.ru/company/intel/blog/268620/)
Хотите удалённо использовать своё устройство для интернета вещей? Тогда попробуйте [Parse](http://parse.com/) — облачный сервис, позволяющий соединять большое количество устройств и легко использовать их через веб-интерфейс. В нём есть всё, что вы ожидаете от облачного провайдера, включая аналитику, статистику, базы данных, push-уведомления, программирование на стороне сервера и многое другое. Система разработки [Parse Embedded SDK](https://www.parse.com/products) доступна для множества платформ и мобильных IoT-устройств.
В этом руководстве мы рассмотрим, как установить Parse Embedded SDK на плату Intel Edison и покажем, как запустить приложение и получить push-уведомление.
Первое и самое главное. Вы обязательно должны установить последнюю версию прошивки на Intel Edison и подключить плату к интернету. Есть [хорошее руководство](https://software.intel.com/en-us/iot/library/edison-getting-started), как это сделать на Intel Developer Zone – IoT.
В отличие от платы Intel Galileo, плата Intel Edison не имеет Ethernet порта, поэтому придётся подключаться по Wi-Fi. Если вы всё ещё этого не сделали, тогда подключите плату по последовательному порту или по Ethernet через USB (RNDIS). Затем, используя программу configure\_edison, настройте беспроводной доступ. Далее я предполагаю, что у вас есть работающее подключение к интернету.
Итак, ваша плата Intel Edison настроена, поэтому самое время установить Parse SDK. Зайдите на сайт [parse.com](http://parse.com/) и зарегистрируйтесь. Перейдите к секции ваших приложений и создайте новое приложение. После того, как вы выбрали имя, вас спросят, хотите ли вы посмотреть руководство по быстрому старту «Quickstart». Я рекомендую вам это сделать. Вы также можете перейти к руководству с вашей панели управления:
Перейдя по ссылке быстрого старта «Quickstart» выберите опцию «embedded», а затем «Linux». Это руководство было написано для Raspberry Pi, но начальные шаги очень похожи на то, что вам надо сделать с платой Intel Edison. Фактически, на плате Intel Edison запустить SDK проще. Большинство необходимых библиотек уже установлено и нам нужен только uuid-dev. Вместо шага 1 в секции «Install the SDK» откройте ssh-сессию на плате Intel Edison при помощи какого-нибудь клиента (например, Putty) и напечатайте следующе команды:
```
root@edison:~# echo "src/gz i586 http://iotdk.intel.com/repos/1.5/iotdk/i586/" >> /etc/opkg/base-feeds.conf
root@edison:~# opkg update
root@edison:~# opkg install util-linux-dev
```
Первая строка добавит репозиторий «Intel IoT developer kit» к конфигурационному файлу opkg. Этот инструмент используется для установки пакетов в дистрибутив Linux. Вторая и третья строка кода обновит и установит необходимую библиотеку со всеми зависимостями.
Теперь выполните шаги 2 и 3 из руководства и установите Parse SKD в директорию по вашему выбору, например, в домашнюю папку. Вот пример:
```
root@edison:~# cd ~
root@edison:~/parse-sdk# wget https://parse.com/downloads/embedded_linux/parse-embedded-sdks-1.0.0.zip --no-check-certificate
root@edison:~/parse-sdk# unzip parse-embedded-sdks-1.0.0.zip
root@edison:~# cd parse-embedded-sdks-1.0.0/
root@edison:~/parse-embedded-sdks-1.0.0# autoreconf -fi
root@edison:~/parse-embedded-sdks-1.0.0# ./configure --prefix=/usr
root@edison:~/parse-embedded-sdks-1.0.0# make
root@edison:~/parse-embedded-sdks-1.0.0# make install
```
Если всё прошло хорошо, у вас есть установленный Parse SDK и можно использовать его на плате Intel Edison. Для включения push-уведомлений надо настроить новое приложение через сайт parse.com. Перейдите на страницу приложения, на вкладку Settings. Здесь выберите «Push» и «Enable Push Notification».
Теперь вернитесь к руководству и следуйте оставшимся шагам для загрузки и компиляции проекта из примера:
```
root@edison:~/parse-embedded-sdks-1.0.0# cd ..
root@edison:~# wget https://parse.com/downloads/embedded_linux/RaspberryPiStarterProject-1.0.0.zip --no-check-certificate
root@edison:~# unzip RaspberryPiStarterProject-1.0.0.zip
```
Этот код распакует main.c и makefile, который сконфигурирован для компиляции и линковки с новой установленной библиотекой Parse. Чтобы сделать изменения в файле с программой, вы можете использовать редактор vi, установленный на Intel Edison или другой любой редактор на компьютере, который может работать по сети. Лично я предпочитаю Notepad++ с плагином NppFTP, который позволяет изменять файлы по FTP. Но есть и много других подходящих инструментов, например, WinSCP.
Остаток руководства демонстрирует пример для настройки приложения, регистрирования его в Parse и посылки push-уведомлений. Вставьте этот код в ваш файл main.c и добавьте предоставленные ключи. Обычно они вставляются автоматически, но если это не так, вот где их можно взять:
После добавления кода в файл main.c всё будет выглядеть примерно так:
Скомпилируйте исходный код, используя готовый makefile, и запустите готовое приложение:
```
root@edison:~# cd raspberry-pi-starter-project
root@edison:~/raspberry-pi-starter-project# make
root@edison:~/raspberry-pi-starter-project# ./quickstart
```
Оставьте приложение работающим на плате Intel Edison. Теперь, если вы нажмете кнопку «Test» на сайте Parse в руководстве внизу страницы, то будет послано push-уведомление. В консоли должно появиться следующее:
```
received push: '{"data":{"alert":"A test push from Parse!"},"time":"2015-05-18T04:21:13.946Z"}'
```
Ну, вот и всё! Мы надеемся, что это руководство было полезным для установки Parse SDK и запуска примера на плате Intel Edison.
Шаги необходимые для установки Parse SDK объединены [в нашем репозитории на github](https://github.com/intel-iot-devkit/parse-embedded-sdks-intel). | https://habr.com/ru/post/388673/ | null | ru | null |
# One Tool to Analyze Them All
Мы рады сообщить о реализации на [explain.tensor.ru](https://explain.tensor.ru/) базовой поддержки анализа и визуализации планов, специфичных **для PostgreSQL-совместимых решений**: [Timescale](https://www.timescale.com/), [Citus](https://www.citusdata.com/), [Greenplum](https://greenplum.org/) и [Redshift](https://aws.amazon.com/ru/redshift/).
Так что если в будущем вам встретится план, похожий на результат обычного `EXPLAIN`, но с некоторыми странными узлами — вы знаете, куда идти.
EXPLAIN <-> SQL
---------------
В развитие темы [сопоставления узлов плана и запроса](https://habr.com/ru/post/517652/) добавлена возможность быстрого просмотра и переключения между ними:
Поддерживается определение узлов `[Parallel] Custom Scan (ChunkAppend)`:
Собственное время `Task`-узлов, выполняющихся на отдельных нодах кластера, определяется на основании фактического `Execution Time`:
Время «родителя» `Custom Scan (Citus Adaptive)` вычисляется корректно, даже в случае одновременного выполнения `Task` сразу на нескольких узлах кластера:
> Подробнее об анализе `EXPLAIN` в [Citus](https://www.citusdata.com/blog/2020/09/05/citus-9-4-whats-new/).
Поддерживаются специфичные узлы вроде `Broadcast Motion, Redistribute Motion, Gather Motion, Partition Selector, Sequence`:
> Подробнее об анализе `EXPLAIN` в [Greenplum](https://gpdb.docs.pivotal.io/510/best_practices/tuning_queries.html).
Поддерживается работа со всеми `XN`-узлами, включая специфичные `XN Network, XN Merge, XN Window` и data redistribution у `Join`-узлов:
> Подробнее об анализе `EXPLAIN` в [Redshift](https://docs.aws.amazon.com/redshift/latest/dg/c-the-query-plan.html).
---
Если вдруг вы нашли что-то, что мы пока не учли — напишите в комментариях. | https://habr.com/ru/post/531620/ | null | ru | null |
# Golang-дайджест № 24 (1 – 31 декабря 2022)
Свежая подборка новостей и материалов.
### Новости, события
* [Gorilla Web Toolkit](https://github.com/gorilla) - репозитории проекта Gorilla переведены в архив в будущем эти библиотеки не будут развиваться.
* [Предложение: добавить поддержку переноса нескольких ошибок в go 1.20](https://github.com/golang/go/issues/53435)
```
func main() {
if err := validate("ruster", "4321"); err != nil {
log.Fatal(err)
// incorrect username
// incorrect password
}
// everything is fine
}
func validate(username, password string) (err error) {
// errors.Join the errors into a single error
if username != "gopher" {
err = errors.Join(err, errors.New("incorrect username"))
}
if password != "1234" {
err = errors.Join(err, errors.New("incorrect password"))
}
return
}
```
* [Предложение: обработка ошибок try handler](https://github.com/golang/go/issues/56165)
* [Предложение: runtime проблема с отслеживанием улучшений диагностики](https://github.com/golang/go/issues/57175)
* [Ментальная карта стандартных библиотек Go](https://nicetomap.com/golang-1.19-standard-library)
* [Go ботнет, синтаксические ошибки](https://arstechnica.com/information-technology/2022/12/advanced-botnet-taken-down-by-an-all-too-human-flaw-syntax-error/)
* [Официальное руководство по сборщику мусора Go](https://go.dev/doc/gc-guide)
### Awesome
* <https://awesome-go.com/>
* <https://github.com/guardrailsio/awesome-golang-security>
* <https://github.com/Binject/awesome-go-security>
* <https://gist.github.com/hbt/d6ab942b882d5b94f331c5257076d05e>
* <https://github.com/avelino/awesome-go>
### Материалы для обучения
* [Уроки для изучения Golang](https://golangify.com/)
* [Gopherlings - изучайте Go, исправляя неправильные программы](https://github.com/soypat/gopherlings)
* [Алгоритмы, реализованные в Go (для обучения)](https://the-algorithms.com/language/go)
* [LearnGo: большая коллекция примеров, упражнений](https://github.com/inancgumus/learngo)
### Статьи
* [Лучший фреймворк для Go?](https://threedots.tech/post/best-go-framework/)
* [Использование событий, отправленных сервером, для упрощения потоковой передачи в реальном времени в масштабе](https://shopify.engineering/server-sent-events-data-streaming)
* [Быстрые встраиваемые шаблоны в Go с помощью quicktemplate](https://andrewpillar.com/programming/2022/11/29/fast-embedded-templates-in-go-with-quicktemplate/)
* [Несколько полезных паттернов для os/exec в Go](https://www.dolthub.com/blog/2022-11-28-go-os-exec-patterns/)
* [Функциональные табличные тесты в Go](https://arslan.io/2022/12/04/functional-table-driven-tests-in-go/)
* [Когда использовать gRPC и GraphQL](https://stackoverflow.blog/2022/11/28/when-to-use-grpc-vs-graphql/)
* [Эффективная обработка ошибок в Go](https://earthly.dev/blog/golang-errors/)
* [Преступления с Go Generics](https://xeiaso.net/blog/gonads-2022-04-24)
* [Паттерны гонки данных в Go](https://www.uber.com/en-UA/blog/data-race-patterns-in-go/)
* [Почему мы пишем на Go](https://bitly.com/blog/why-we-write-everything-in-go/)
* [Как мы пишем действия GitHub в Go](https://full-stack.blend.com/how-we-write-github-actions-in-go.html)
* [Новое в Go 1.20: перенос нескольких ошибок](https://lukas.zapletalovi.com/posts/2022/wrapping-multiple-errors/)
* [Проектирование библиотек Go](https://abhinavg.net/2022/12/06/designing-go-libraries/)
* [3D-графика в Go](https://habr.com/ru/company/otus/blog/708170/)
* [Схема разделения секрета Шамира в Hashicorp Vault](https://habr.com/ru/post/708230/)
* [Flamingo, Go ahead! или Как реализовать DDD в Go?](https://habr.com/ru/company/aktiv-company/blog/708030/)
* [«Видишь гофера? А он есть». Чем живут русскоязычные golang-разработчики](https://habr.com/ru/article/707054/)
* [Как починить QA-отдел, или Ещё один переезд в Go](https://habr.com/ru/company/ozontech/blog/707092/)
* [Под капотом у компилятора Go: добавление нового оператора в Go — часть 1](https://habr.com/ru/company/otus/blog/706942/)
* [База по шардированию базы](https://habr.com/ru/company/ozontech/blog/705912/)
* [The Best Golang framework: no framework?](https://habr.com/ru/post/705078/)
* [Проблема grpc-gateway и как ее можно решить](https://habr.com/ru/post/704802/)
* [Hashmap по версии Golang вместе с реализацией на дженериках](https://habr.com/ru/post/704796/)
* [Библиотека алгоритмов на графах на языке Go. Часть 1](https://habr.com/ru/post/704730/)
### Инструменты
* [gnet 2.2.0](https://github.com/panjf2000/gnet) — высокопроизводительный, легкий, неблокирующий, сетевой фреймворк.
* [ecoji 2.0.0](https://github.com/keith-turner/ecoji) — инструмент для кодирования, декодирования эмодзи.
* [otto 0.2.1](https://github.com/robertkrimen/otto) — синтаксический анализатор и интерпретатор JavaScript в Go.
* [semver 3.2.0](https://github.com/Masterminds/semver) — библиотека для семантического управление версиями.
* [d2 0.1.5](https://github.com/terrastruct/d2) — система декларативного построения диаграмм.
* [marmot 0.7.5](https://github.com/maxpert/marmot) — распределенный репликатор SQLite поверх NATS.
* [task 3.20.0](https://github.com/go-task/task) — инструмент для запуска/сборки задач, которое должно быть проще и удобнее в использовании, чем, например, GNU Make.
* [mysql 1.7](https://github.com/go-sql-driver/mysql) — драйвер для базы данных MySQL.
* [permify 0.2.2](https://github.com/Permify/permify) — служба авторизации для создания и поддержки детальной авторизации в ваших приложениях.
* [gobgp 3.10.0](https://github.com/osrg/gobgp) — реализация протокола Border Gateway Protocol (BGP).
* [notify 0.36.0](https://github.com/nikoksr/notify)— библиотека Go для отправки уведомлений в различные службы обмена сообщениями.
* [katana 0.0.3](https://github.com/projectdiscovery/katana)— фреймворк для веб-сканирования.
* [fiber 2.41.0](https://github.com/gofiber/fiber) — веб-фреймворк вдохновлён Express.js.
* [imagor 1.3.6](https://github.com/cshum/imagor) — сервер обработки изображений с поддержкой Docker.
* [echo 4.10.0](https://github.com/labstack/echo) — платформа, предназначенная для создания API-интерфейсов REST, поддержкой HTTP/2, автоматическим TLS и многим другим.
* [ebitengine 2.4.15](https://github.com/hajimehoshi/ebiten) — игровой движок с открытым исходным кодом 2D-игр.
* [mirrord 3.19.0](https://github.com/metalbear-co/mirrord) — инструмент для запуска локальной службы в облачном (Kubernetes) контексте.
* [fasthttp 1.44.0](https://github.com/valyala/fasthttp) — HTTP-пакет с настроенной производительностью.
### Видео
* 📺 [Изучение сетевого программирования путем создания клона Toxiproxy](https://www.youtube.com/watch?v=8z6okCgdREo)
* 📺 [Все, что вам нужно знать о указателях в Go](https://www.youtube.com/watch?v=mqH21m0MsWk)
* 📺 [Как создать и структурировать проект JSON API в Go,](https://www.youtube.com/watch?v=CJfE9kD_i7Q)
* 📺 [Более безопасное написание приложений с помощью Go](https://www.youtube.com/watch?v=aw7lFSFGKZs)
* 📺 [Создание CLI-инструмента с помощью Go, который вызывает HTTP API Stripe](https://www.youtube.com/watch?v=jasgSuYt2Jg)
### Подкасты
* 🎧 [GenericTalks](https://soundcloud.com/generictalks)
* 🎧 [Go Time](https://podcasts.apple.com/us/podcast/go-time/id1120964487)
* 🎧 [Использовать TDD или не использовать TDD с Биллом Кеннеди и Крисом Джеймсом](https://changelog.com/gotime/258)
### Сообщества
* 💬 [Вопросы по языку на русскоязычном StackOverflow](https://ru.stackoverflow.com/questions/tagged/golang)
* 💬 [Страница Go на stackoverflow](https://stackoverflow.com/questions/tagged/go)
* 💬 [Форум в группах Google](https://groups.google.com/forum/#!forum/Golang-ru)
##### Eжедневный дайджест в телеграм.
[GolangStack](https://t.me/GolangStack) | https://habr.com/ru/post/710908/ | null | ru | null |
# Автодискаверинг и автопостановка на мониторинг или как попивать кофе вместо подготовки ответов пользователям
Современная ИТ-инфраструктура – это живая экосистема, которая пребывает в динамическом состоянии. Она расширяется, меняется, обрастает новыми элементами и связями. Это полноценный организм, за которым нужно следить и ухаживать, не забывая при этом учитывать все его изменения.
Представим ситуацию: решили вы повысить производительность информационной системы. Команда девелоперов для этой цели развернула новые ноды, добавила элементы ИС, зарелизила изменения, система работает эффективнее, и, казалось бы, все счастливы. Да только от радости забыли поставить новые элементы на мониторинг. Так и будете вы спокойно пить кофе, любуясь зелеными огоньками на экране рядом с каждым компонентом системы, пока разъяренные пользователи не cымитируют DDoS атаку на внешний интерфейс вашего хелпдеска, когда один из новых элементов откажет.
А теперь представьте, чтобы избежать подобных инцидентов и при этом не просыпаться в холодном поту среди ночи, вспоминая, поставили ли вы новую конфигурационную единицу на мониторинг, машины научились брать ответственность за эти процессы на себя. Расскажу как в данной статье.
Для этого нам понадобятся базовые системы мониторинга, Zabbix, Prometheus или что-то похожее, какая конкретно система вообще не важно, важно подобрать правильный оркестратор и агрегатор событий. Возьмем AIOps платформу Monq, которую можно бесплатно скачать с [сайта разработчика](https://monq.ru/download). С помощью нее мы автоматически построим ресурсно-сервисную модель на основе данных из Zabbix и применение политик эскалации. Нашей задачей будет один раз настроить систему мониторинга и забыть о добавлении объектов, триггеров, правил и действий. Гартнер уже больше года размышляет над термином Hyperautomation. Сегодня как раз на деле опишу один из таких кейсов.
### Причем тут AIOps
В современном мире стремительная цифровизация бизнеса непрерывно трансформирует IT. Внедрение или доработка информационных систем и приложений, сложность и гибридность инфраструктуры часто требуют наличия дополнительных ресурсов и делают традиционные методы управления IT не подходящими для быстрых изменений и не способными отвечать на вызовы новых реалий. Тут на передний план выходят технологии AIOps.
AIOps, или Artificial Intelligence for IT Operations, - это многослойная платформа для управления IT, на основе искусственного интеллекта позволяющая автоматизировать обработку и принятие решений на основе больших данных, поступающих в режиме реального времени из IT-инфраструктуры. Следовательно, AIOps освобождает IT-специалистов от рутинных задач мониторинга отдельных событий, позволяя полностью положиться на машинное обучение.
Источник: Gartner, IncО Monq уже написано не мало статей на Хабре ([тут](https://habr.com/ru/post/594805/) или [тут](https://habr.com/ru/company/galssoftware/blog/572552/), например) и повторяться не хотелось бы, это российская разработка для проактивного мониторинга и автоматизации, на ней строятся автоматизированные ситуационные центры от маленького домашнего фрилансного сисадминского уровня до уровня крупных корпораций, где прилетают тысячи событий в минуту. Мне нравится то, что это система, созданная инженерами для инженеров. В одном из последних обновлений у них появилась функция автоматического построения ресурсно-сервисных моделей, а с их помощью намного легче проводить автоматический анализ основной причины сбоя (Root Cause Analysis) и настраивать сценарии автодействий и автоправил. Также недавно вышел новый движок автоматизации. Если бы не он, статьи бы этой не было.
Сначала кейс с полной автоматизацией был построен на продуктивной системе, в которой есть и Zabbix (несколько серверов: отдельно сеть, отдельно инфра), и Prometheus (мониторинг микросервисов), и Jager (для трассировки приложений), и vCenter. Но описывать весь кейс я не могу, так что для статьи поднял упрощенную конфигурацию с одним Zabbix, взял его, так как это, пожалуй, самый распространенный источник событий. Подобным образом можно подключать любые другие источники, содержащие информацию, которую можно отрисовать на ресурсно-сервисной модели.
Статью постарался оформить как туториал, чтобы вы смогли это у себя повторить. Если будет что-то не понятно - пишите в комментарии. А теперь поехали!
### Агрегация и анализ событий из внешних систем
Прежде чем начать получать данные из первичной системы, необходимо настроить их поток. В разделе Сбор данных - Потоки данных через основное меню нажимаем кнопку Добавить поток в верхнем правом углу, заполняем поля и тем самым конфигурируем необходимый поток.
Для потоков данных в Monq доступны предустановленные шаблоны конфигурации, предназначенные для интеграции Monq с системами мониторинга. Например, шаблон Zabbix, который мы применяем в данном случае, уже содержит следующие задания и обработчики:
| | | |
| --- | --- | --- |
| | **Задания** | **Обработчики** |
| Zabbix | **- Zabbix - Version Check"** - получение актуальной версии подключенного сервера Zabbix**- "Zabbix - Api Connection Check"** - проверка состояния соединения с API Zabbix**- "Zabbix - Events Data Flow"** - получение данных из ZabbixВо всех заданиях применяется агент *SharedAgents* - системный агент по умолчанию, доступен для изменения на внешние агенты | **Routing for Zabbix stream**, который проставляет:**-** Метку type:Zabbix.**-** Метку postRouting:cl.stream-ready-event.zabbix.new для дальнейшей маршрутизации события.**labels\_add**('type', 'Zabbix')**labels\_add**('postRoutings',{'cl.stream-ready-event.zabbix.new'})**next\_step**(source)Пользователю доступно добавление новых обработчиков к имеющемуся. |
Чтобы связать Zabbix и Monq, прописываем URL подключения к Zabbix, логин и пароль от Zabbix.
Если вы решили интегрировать данные из Zabbix, то логично предположить, что у вас уже имеется аккаунт в этой системе. Если нет, то вы можете создать новый. На скриншоте ниже представлен процесс создания нового пользователя в Zabbix.
Как было отмечено выше, в предустановленном шаблоне конфигурации уже содержатся задания для привязки Zabbix к Monq. Однако в нашем случае необходимо добавить ещё одно кастомное задание, благодаря которому будут тянуться данные из Zabbix для дальнейшего построения топологии.
Задание пишется на yaml и будет выполнять запрос на API Zabbix:
```
jobs:
- steps:
- run: 'curl -H \"Content-Type: application/json\" -s --request POST --data-raw \"${zabbixGetHostsJson}\" ${zabbixUri}'
env:
zabbixUri: https://zabbix.ru/api_jsonrpc.php
zabbixGetHostsJson: >
{
"jsonrpc": "2.0",
"method": "host.get",
"params": {
"filter": {
"output": "extend"
},
"selectGroups": "extend"
},
"id": 1,
"auth": "token"
}
outputs:
data: $._outputs.shell
artifacts:
- data: '{{ outputs.data }}'
send-to:
api:
uri: https://monq.ru/api/public/cl/v1/stream-data
headers:
x-smon-stream-key: $.vars.stream.key
x-smon-userspace-id: $.userspaceId
media-type: application/json
```
Вы можете запросто использовать данный скрипт как шаблон, вставив его вручную и поменяв следующие строки в соответствии с вашими данными:
API токен берем (или создаем в случае его отсутствия) также в Zabbix.
Сохраняем изменения. Вжух! И необходимый поток добавлен в Monq.
Но на этом магия конфигурации не заканчивается. Стоит отметить, что задание по сбору данных топологии не может выполняться на внутреннем агенте по политикам безопасности Monq, поэтому перед его запуском необходимо подключить внешний агент.
Добавляем Новый координатор, внутри которого настраиваем агент.
Процесс настройки агента и добавления данных в поля подробно описан в документации Monq, которая хранится в открытом доступе, поэтому в этой статье мы не будет акцентировать внимание на данном процессе, чтобы поскорее перейти к самому интересному – автоматизации.
После настройки возвращаемся в наш поток и меняем агент в добавленном вручную задании на только что созданный.
Теперь запускаем поток. В “Событиях и логах” можем проверить наличие в нём событий, чтобы убедиться, что данные поступают в систему.
“Провалившись” в одно из событий, сообщающее о проблеме, увидим не только его табличное представление, откуда сможем вытянуть информацию обо всех элементах, содержащихся в Zabbix, но также стандартную для Zabbix структуру JSON, например:
Информация обо всех hosts из ZabbixПример структуры JSON для одного из событий ZabbixНа основе событий, приходящих из первичных систем мониторинга, сможем построить ресурсно-сервисную модель (РСМ).
### Строим ресурсно-сервисную модель
Ресурсно-сервисная модель (РСМ) – это перечень конфигурационных единиц (КЕ) системы, а также массив связей между ними. В Monq РСМ основана на топологии. Но не будем пока забегать вперёд и вернемся к структуре JSON первичного события, на которой мы остановились в предыдущем разделе. В ней обратим внимание на следующие параметры, по которым и будет строить ресурсно-сервисную модель:
При дальнейшем автоматическом создании конфигурационных единиц будем определять, что:
* *Название КЕ == host.name (Наименование узла Zabbix)*
* *Название родительской КЕ == host.groups[0].name*
* *Связанный объект => Узел Zabbix*
В разделе Автоматизации создаем новый сценарий для Zabbix, владельцем которого является наша Рабочая группа.
Добавленные сценарии увидим в разделе Автоматизация.
Проектирование сценария начинается с блока “OnLogEvent”, куда приходят события о топологии, и производится при помощи визуального движка программирования (low-code).
Затем производится проверка потоков: если название потока совпадает со значением в сценарии (в нашем случае – Zabbix Sync), то скрипт выполняется дальше, если нет – скрипт выполняться не будет.
Чтобы “куст” топологии разрастался из одной информационной системы, можно вручную создать корневую КЕ через опцию создания КЕ в окне графа РСМ.
Создав КЕ, берем её **ID из ссылки** и вставляем **в следующий блок** в скрипте.
Тем самым при создании сценария все группы будут привязываться к данной корневой КЕ, которая будет отображать на топологии здоровье всей системы в целом.
Но не будем пока спойлерить и вернёмся к построению единого скрипта, который условно можно разделить на две части:
1. Создание конфигурационных единиц (КЕ).
2. Привязывание узлов первичных систем мониторинга (для дальнейшей привязки триггеров).
В дальнейшем скрипт совершенствуется, производятся различные проверки, добавляется автоматическое создание КЕ и создаются связи подчинения между ними. Подробный процесс создания сценария, получения атрибутов КЕ, создания связей влияния и подчинения описан в [документации Monq](https://docs.monqlab.com/current/ru/reference/api/service-model/).
Затем выполняем компиляцию и запускаем сценарий:
В результате выполнения этого скрипта создается полноценный граф РСМ, на котором отображаются статусы всех компонентов и здоровье системы в режиме реального времени.
После получения события с топологией и его обработки сценарием видим и построенную модель, и статусы привязанных триггеров. Отображение карты настраивается автоматически в соответствии с правилами: в данном случае показываются все КЕ, связанные с Monq на расстоянии бесконечности.
Если во время автодискаверинга будет обнаружена новая КЕ, то мы сразу увидим её на карте. Чтобы быть уверенным, что система точно не подвела, можно проверить добавление новых элементов в Журнале событий.
Как видно из скриншота, все новые КЕ и связи были добавлены автоматически.
### Автоправила и автодействия
Как вы уже поняли, Monq берет на себя некоторые задачи и автоматизирует рутинные процессы, которые раньше выполнялись вручную. Для каждого элемента системы можно настроить не только автоматическое добавление, но и автоматические правила, которые будут срабатывать при определенных изменениях в КЕ.
Открываем раздел “Правила и действия” и добавляем Новое правило. Например, создадим правило для всех КЕ и событий с приоритетом 2 или выше.
Далее прописываем автоматическое действие, которое будет выполняться в случае срабатывания данного правила. В нашем случае это – два оповещения по e-mail и в Telegram с интервалом в 2 и 30 мин и выполнение скрипта автопочинки в случае, если за это время инцидент не был устранен.
Шаблоны оповещений также настраиваются внутри Monq. Вы можете добавить любой текст, прикрепить необходимые файлы, используя для разметки Markdown и HTML.
Таким образом при обнаружении события с высоким приоритетом будет срабатывать данный сценарий автодействия: отправятся необходимые оповещения и запустится скрипт починки. И все это будет совершено автоматически! Пока вы будете попивать кофеек.
### Заключение
Когда в систему приходит событие, оно изменяет либо саму РСМ, либо её состояние. Monq автоматически позволяет отследить все эти изменения и выполнить связанные с ними действия. Автоматически добавляются объекты, автоматически привязываются триггеры первичных локальных систем мониторинга, автоматически распространяются политики эскалации, автоматически рассчитывается здоровье системы и запускаются сценарии автоматизации.
Приведенный выше пример, это была искусственная упрощенная демонстрация. В продуктиве систем и объектов больше, и все это нормально уживается в одном экране и это здорово. Выполнив необходимую первичную настройку, описанную выше, вы полностью передадите пласт некогда ручных работ в Monq, освободив ресурсы для других важных задач.
К слову, у вас есть возможность лично протестировать описанный выше кейс. Пошаговый рецепт с готовым сценарием автоматизации доступен по [ссылке](https://docs.monqlab.com/current/ru/automation/new/). Вы можете перетянуть его в свою систему и попробовать все описанные выше функции, возможности и фишки Monq. Делитесь опытом в комментах – обсудим 😉
Черпать мысли и делиться опытом можно в русскоязычном комьюнити в Telegram [тут](https://t.me/monq_community_ru). | https://habr.com/ru/post/662620/ | null | ru | null |
# Locks in PostgreSQL: 1. Relation-level locks
The previous two series of articles covered [isolation and multiversion concurrency control](https://habr.com/en/company/postgrespro/blog/467437/) and [logging](https://habr.com/en/company/postgrespro/blog/491730/).
In this series, we will discuss **locks**.
This series will consist of four articles:
1. Relation-level locks (this article).
2. [Row-level locks](https://habr.com/en/company/postgrespro/blog/503008/).
3. [Locks on other objects and predicate locks](https://habr.com/en/company/postgrespro/blog/504498/).
4. [Locks in RAM](https://habr.com/en/company/postgrespro/blog/507036/).
The material of all the articles is based on training courses on administration that Pavel [pluzanov](https://habr.com/ru/users/pluzanov/) and I are creating (mostly [in Russian](https://postgrespro.ru/education/courses), although one course is available [in English](https://postgrespro.com/education/courses)), but does not repeat them verbatim and is intended for careful reading and self-experimenting.
> Many thanks to Elena Indrupskaya for the translation of these articles into English.
>
>
General information on locks
============================
PostgreSQL has a wide variety of techniques that serve to lock something (or are at least called so). Therefore, I will first explain in the most general terms why locks are needed at all, what kinds of them are available and how they differ from one another. Then we will figure out what of this variety is used in PostgreSQL and only after that we will start discussing different kinds of locks in detail.
Locking is used to order concurrent access to shared resources.
By concurrent access, simultaneous access of several processes is meant. These processes themselves can run either in parallel (if the hardware permits) or sequentially in a time-sharing mode — it makes no difference.
Without concurrency, no locking is needed (for example: the shared buffer cache requires locking, while a local one does not).
Before accessing a resource, a process must *acquire* the lock associated with this resource. So this is a matter of certain discipline: everything works fine while processes conform to established rules of access to a shared resource. If a DBMS controls locking, it maintains order on its own; but if an application sets locks, the responsibility falls on it.
At a low level, a lock is an area in the shared memory with some indication of whether the lock is released or acquired (and maybe some additional information): the process number, acquisition time and so forth).
> Note that this area in the shared memory itself is a resource that allows concurrent access. If we descend yet to a lower level, we will see that to regulate access, OS provides specialized synchronization primitives (such as semaphores or mutexes). Their purpose is to ensure that code accessing a shared resource is used only in one process. At the lowest level, these primitives are implemented through atomic processor instructions (such as `test-and-set` or `compare-and-swap`).
>
>
When a resource is no longer needed to a process, the latter *releases* the lock so that other processes can use it.
Certainly, sometimes a lock cannot be acquired: the resource can be already in use by someone else. Then the process either stands in a wait queue (if the locking technique permits this) or repeats an attempt to acquire the lock some time later. Anyway, the process has to be idle in a wait for the resource to be free.
> Sometimes, other, non-blocking, strategies can be used. For example: [multiversion concurrency control](https://habr.com/en/company/postgrespro/blog/467437/) in certain cases, allows several processes to work simultaneously with different versions of data without blocking one another.
>
>
In general, by the resource to be protected we mean anything that we can unambiguously identify and associate the lock address with it.
For example: a DBMS object such as a data page (identified by the filename and location inside the file), table (OID in the system catalog), or table row (the page and offset inside it) can be a resource. A memory structure such as a hash table, buffer and so forth (identified by a previously assigned number) can also be a resource. Sometimes it is even convenient to use abstract resources, which have no physical meaning (identified just by a unique number).
Many factors affect the efficiency of locking, of which we give prominence to two.
* The **granularity** is critical when the resources are organized in a hierarchy.
For example: a table consists of pages, which contain table rows. All these objects can be resources. If processes are interested only in a few rows, but a lock is acquired at the table level, other processes will be unable to simultaneously work with different rows. Therefore, the higher the granularity, the better for enabling parallelization.
But this causes increase of the number of locks (for which the information needs to be stored in memory). In this case, *escalation* of locks can be applied: when the number of low-level high-granularity locks exceeds a certain limit, they are replaced with one higher-level lock.
* Locks can be acquired in various **modes**.
The names of the modes can be any; what really matters is the matrix of their compatibility with each other. The mode that is incompatible with any mode (including itself) is usually called *exclusive*. If modes are compatible, several processes can acquire a lock simultaneously; modes like these are called *shared*. In general, the more modes compatible with each other can be distinguished, the more opportunities for concurrency occur.
By the duration, locks can be divided into long and short.
* **Long** locks are acquired for a potentially long time (usually up to the end of the transaction) and most often relate to such resources as tables (relations) and rows. As a rule, PostgreSQL controls these locks automatically, but a user, however, has certain control over this process.
A large number of modes is typical of long locks to enable as many simultaneous data operations as possible. Usually an extensive infrastructure (for example: support of wait queues and detection of deadlocks) and monitoring tools are available for such locks since the maintenance cost of all these convenient features is anyway incomparably less than the cost of operations over data being protected.
* **Short** locks are acquired for a short time (from a few processor instructions to fractions of seconds) and usually relate to data structures in the shared memory. PostgreSQL controls such locks in a fully automatic fashion — you only need to be aware of their existence.
The minimum of modes (exclusive and shared) and a simple infrastructure are typical of short locks. Sometimes there can even be no monitoring tools.
PostgreSQL uses different kinds of locks.
**Object-level locks** pertain to long, «heavy-weight» locking. Relations and other objects are resources here. If in this article you come across the word «lock» or «locking» without clarification, it means just this, «normal» locking.
Among long locks, **row-level locks** stand out separately. They are implemented differently from other long locks because they are potentially huge in number (imagine an update of a million of rows in one transaction). We will discuss these locks in the next article.
The third article of the series will cover the remaining object-level locks, as well as **predicate locks** (since the information on all these locks is uniformly stored in RAM).
Short locks comprise various **locks on RAM structures**. We will discuss them in the last article of the series.
Object-level locks
==================
So, we are starting with object-level locks. By an object here we primarily mean *relations*, that is, tables, indexes, sequences and materialized views, but also some other entities. These locks are normally used to protect objects against simultaneous changes or against use when the object is being changed, but also for other needs.
The wording is vague, isn't it? Exactly so, since locks in this group are used for various purposes. The only thing that unites them is how they are organized.
Organization
------------
Object locks are stored in the shared memory of the server. The number of them is limited by the product of two parameter values: *max\_locks\_per\_transaction* × *max\_connections*.
The pool of locks is one for all transactions, that is, a transaction can acquire more locks than *max\_locks\_per\_transaction*: the only important thing is that the total number of locks in the system does not exceed the number specified. The pool is created at startup, so to change any of the two above parameters a server restart is required.
You can see all the locks in the `pg_locks` view.
If a resource is already locked in an incompatible mode, the transaction that tries to acquire the lock is queued to wait until the lock is released. Waiting transactions do not consume processor resources: backend processes involved «fall asleep» and are waked up by the OS when the resource gets free.
When to continue the work, one transaction needs a resource that is in use by another transaction, while the second one needs a resource that is in use by the first, a *deadlock* occurs. In general, a deadlock of more than two transactions can arise. In such a case, the wait will last infinitely, therefore, PostgreSQL detects such situations automatically and aborts one of the transactions to enable the others continue. (We will discuss deadlocks in detail in the next article.)
Object types
------------
The following is a list of lock types (or, if you like, object types) that we will deal with in this and next articles. The names are provided according to the `locktype` column of the `pg_locks` view.
* **relation**
Locks on relations.
* **transactionid** и **virtualxid**
Locks on the transaction ID (actual or virtual). Each transaction itself holds an exclusive lock on its own ID, therefore, such locks are convenient to use when we need to wait until completion of another transaction.
* **tuple**
Locks on a tuple. Used in some instances to prioritize several transactions waiting for a lock on the same row.
We will put off a talk on other types of locks until the third article of this series. All of them are acquired either in the exclusive or in the share/exclusive mode.
* **extend**
Used when adding pages to a file of some relation.
* **object**
Locks on objects different from relations (databases, schemas, subscriptions and so forth).
* **page**
Locks on a page — used infrequently and only by certain types of indexes.
* **advisory**
Advisory locks — a user has them acquired manually.
Relation-level locks
====================
In order not to fall out of context, in a figure like this, I will mark those types of locks that will be discussed further.
Modes
-----
Unless a relation-level lock is the most important among locks, it is mostly rich in modes for sure. As many as 8 different modes are defined for it. That many are needed to enable simultaneous execution of the maximum possible number of commands related to one table.
There is no point in committing these modes to your memory or trying to get an insight into their names; what is really important is to have near at hand the [matrix](https://postgrespro.com/docs/postgresql/10/explicit-locking#LOCKING-TABLES) that shows which locks conflict each other. For convenience, it is provided here along with examples of commands that require the corresponding levels of locking:
| Locking mode | AS | RS | RE | SUE | S | SRE | E | AE | Example of SQL commands |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Access Share | | | | | | | | X | SELECT |
| Row Share | | | | | | | X | X | SELECT FOR UPDATE/SHARE |
| Row Exclusive | | | | | X | X | X | X | INSERT, UPDATE, DELETE |
| Share Update Exclusive | | | | X | X | X | X | X | VACUUM, ALTER TABLE\*, СREATE INDEX CONCURRENTLY |
| Share | | | X | X | | X | X | X | CREATE INDEX |
| Share Row Exclusive | | | X | X | X | X | X | X | CREATE TRIGGER, ALTER TABLE\* |
| Exclusive | | X | X | X | X | X | X | X | REFRESH MAT. VIEW CONCURRENTLY |
| Access Exclusive | X | X | X | X | X | X | X | X | DROP, TRUNCATE, VACUUM FULL, LOCK TABLE, ALTER TABLE\*, REFRESH MAT. VIEW |
A few comments:
* First 4 modes allow concurrent changes of the table data, while the next 4 do not.
* The first mode (Access Share) is the weakest, it is compatible with any other but the last (Access Exclusive). This last mode is exclusive, it is incompatible with any other.
* The ALTER TABLE command has many flavors, and different flavors require different-level locks. Therefore, this command occurs in different rows of the matrix and is marked with an asterisk.
To illustrate
-------------
Let's consider an example. What happens if we execute the CREATE INDEX command?
We learn from the documentation that this command acquires a Share lock. From the matrix, we learn that the command is compatible with itself (that is, several indexes can be created simultaneously) and with read commands. So, SELECT command will continue working, while UPDATE, DELETE and INSERT will be blocked.
And vice versa: non-completed transactions that change table data will block execution of the CREATE INDEX command. It's for this reason that the CREATE INDEX CONCURRENTLY flavor of the command is available. Its execution takes longer (and it can even fail with an error), but it allows concurrent data updates.
You can make sure of this in practice. For experiments we will use the table of «bank» accounts, which is familiar to us since the [first series](https://habr.com/en/company/postgrespro/blog/467437/) and in which will store the account number and amount.
```
=> CREATE TABLE accounts(
acc_no integer PRIMARY KEY,
amount numeric
);
=> INSERT INTO accounts
VALUES (1,1000.00), (2,2000.00), (3,3000.00);
```
In the second session, we'll start a transaction. We will need the process ID of the backend process.
```
| => SELECT pg_backend_pid();
```
```
| pg_backend_pid
| ----------------
| 4746
| (1 row)
```
What locks does the transaction that just started hold? Looking into `pg_locks`:
```
=> SELECT locktype, relation::REGCLASS, virtualxid AS virtxid, transactionid AS xid, mode, granted
FROM pg_locks WHERE pid = 4746;
```
```
locktype | relation | virtxid | xid | mode | granted
------------+----------+---------+-----+---------------+---------
virtualxid | | 5/15 | | ExclusiveLock | t
(1 row)
```
As I said before, a transaction always holds an Exclusive lock on its own ID, which is virtual in this case. This process has no other locks.
Now let's update a table row. How will the situation change?
```
| => UPDATE accounts SET amount = amount + 100 WHERE acc_no = 1;
```
```
=> \g
```
```
locktype | relation | virtxid | xid | mode | granted
---------------+---------------+---------+--------+------------------+---------
relation | accounts_pkey | | | RowExclusiveLock | t
relation | accounts | | | RowExclusiveLock | t
virtualxid | | 5/15 | | ExclusiveLock | t
transactionid | | | 529404 | ExclusiveLock | t
(4 rows)
```
Locks on the table being changed and on the index (created for the primary key) being used by the UPDATE command appeared. Both locks acquired are Row Exclusive. Besides, an exclusive lock on the actual transaction ID was added (the ID appeared as soon as the transaction started changing data).
Now we'll try to create an index on the table in yet another session.
```
|| => SELECT pg_backend_pid();
```
```
|| pg_backend_pid
|| ----------------
|| 4782
|| (1 row)
```
```
|| => CREATE INDEX ON accounts(acc_no);
```
The command «hangs» waiting for the resource to be free. What lock in particular does it try to acquire? Let's figure this out:
```
=> SELECT locktype, relation::REGCLASS, virtualxid AS virtxid, transactionid AS xid, mode, granted
FROM pg_locks WHERE pid = 4782;
```
```
locktype | relation | virtxid | xid | mode | granted
------------+----------+---------+-----+---------------+---------
virtualxid | | 6/15 | | ExclusiveLock | t
relation | accounts | | | ShareLock | f
(2 rows)
```
It's clear now that the transaction tries to acquire a Share lock on the table, but cannot (`granted = f`).
In order to find the process ID (pid) of the locking process, and in general, several pids, it is convenient to use the function that appeared in version 9.6 (before that, the conclusions had to be made by carefully examining all the contents of `pg_locks`):
```
=> SELECT pg_blocking_pids(4782);
```
```
pg_blocking_pids
------------------
{4746}
(1 row)
```
And then, to understand the situation, we can get information on the sessions to which the pids found pertain:
```
=> SELECT * FROM pg_stat_activity
WHERE pid = ANY(pg_blocking_pids(4782)) \gx
```
```
-[ RECORD 1 ]----+------------------------------------------------------------
datid | 16386
datname | test
pid | 4746
usesysid | 16384
usename | student
application_name | psql
client_addr |
client_hostname |
client_port | -1
backend_start | 2019-08-07 15:02:53.811842+03
xact_start | 2019-08-07 15:02:54.090672+03
query_start | 2019-08-07 15:02:54.10621+03
state_change | 2019-08-07 15:02:54.106965+03
wait_event_type | Client
wait_event | ClientRead
state | idle in transaction
backend_xid | 529404
backend_xmin |
query | UPDATE accounts SET amount = amount + 100 WHERE acc_no = 1;
backend_type | client backend
```
When the transaction is completed, the locks are released and index is created.
```
| => COMMIT;
```
```
| COMMIT
```
```
|| CREATE INDEX
```
Join the queue!..
-----------------
To better understand what occurrence of an incompatible lock entails, let's see what will happen if we execute the VACUUM FULL command during system operation.
Let SELECT be the first command executed on the above table. It acquires a weakest-level, Access Share, lock. To control the time of releasing the lock, we execute this command inside the transaction — the lock won't be released until the transaction completes. Actually several commands can read (and update) a table, and execution of some queries can take pretty long.
```
=> BEGIN;
=> SELECT * FROM accounts;
```
```
acc_no | amount
--------+---------
2 | 2000.00
3 | 3000.00
1 | 1100.00
(3 rows)
```
```
=> SELECT locktype, mode, granted, pid, pg_blocking_pids(pid) AS wait_for
FROM pg_locks WHERE relation = 'accounts'::regclass;
```
```
locktype | mode | granted | pid | wait_for
----------+-----------------+---------+------+----------
relation | AccessShareLock | t | 4710 | {}
(1 row)
```
Then the administrator executes the VACUUM FULL command, which requires a lock that has the Access Exclusive level and that is inconsistent with everything, even with Access Share. (The LOCK TABLE command requires the same lock.) And the transaction is queued.
```
| => BEGIN;
| => LOCK TABLE accounts; -- the same lock mode as for VACUUM FULL
```
```
=> SELECT locktype, mode, granted, pid, pg_blocking_pids(pid) AS wait_for
FROM pg_locks WHERE relation = 'accounts'::regclass;
```
```
locktype | mode | granted | pid | wait_for
----------+---------------------+---------+------+----------
relation | AccessShareLock | t | 4710 | {}
relation | AccessExclusiveLock | f | 4746 | {4710}
(2 rows)
```
But the application continues to issue queries, and so the SELECT command also occurs in the system. Hypothetically, it could «make it through» while VACUUM FULL is waiting, but no — it honestly stands in a queue for VACUUM FULL.
```
|| => SELECT * FROM accounts;
```
```
=> SELECT locktype, mode, granted, pid, pg_blocking_pids(pid) AS wait_for
FROM pg_locks WHERE relation = 'accounts'::regclass;
```
```
locktype | mode | granted | pid | wait_for
----------+---------------------+---------+------+----------
relation | AccessShareLock | t | 4710 | {}
relation | AccessExclusiveLock | f | 4746 | {4710}
relation | AccessShareLock | f | 4782 | {4746}
(3 rows)
```
When the first transaction with the SELECT command completes and releases the lock, the VACUUM FULL command (which we simulated by the LOCK TABLE command) starts.
```
=> COMMIT;
```
```
COMMIT
```
```
| LOCK TABLE
```
```
=> SELECT locktype, mode, granted, pid, pg_blocking_pids(pid) AS wait_for
FROM pg_locks WHERE relation = 'accounts'::regclass;
```
```
locktype | mode | granted | pid | wait_for
----------+---------------------+---------+------+----------
relation | AccessExclusiveLock | t | 4746 | {}
relation | AccessShareLock | f | 4782 | {4746}
(2 rows)
```
And it's only after VACUUM FULL completes and releases the lock, all the queued commands (SELECT in this example) will be able to acquire appropriate locks (Access Share) and execute.
```
| => COMMIT;
```
```
| COMMIT
```
```
|| acc_no | amount
|| --------+---------
|| 2 | 2000.00
|| 3 | 3000.00
|| 1 | 1100.00
|| (3 rows)
```
So, an improperly executed command can paralyze work of the system for the time interval that is way longer than it takes to execute the command itself.
Monitoring tools
================
It's beyond doubt that locks are needed for correct work, but they can cause undesirable waits. These waits can be tracked in order to figure out their root cause and eliminate it whenever possible (for example: by changing the algorithm of the application).
We are already acquainted with one way to do this: when a long lock occurs, we can query the `pg_locks` view, look at locked and locking transactions (using the `pg_blocking_pids` function) and interpret the data using `pg_stat_activity`.
Another way is to turn the *log\_lock\_waits* parameter on. In this case, information will get into the server message log if a transaction waited longer than *deadlock\_timeout* (although the parameter is used for deadlocks, normal waits are meant here).
Let's try.
```
=> ALTER SYSTEM SET log_lock_waits = on;
=> SELECT pg_reload_conf();
```
The default value of the *deadlock\_timeout* parameter is one second:
```
=> SHOW deadlock_timeout;
```
```
deadlock_timeout
------------------
1s
(1 row)
```
Let's reproduce a lock.
```
=> BEGIN;
=> UPDATE accounts SET amount = amount - 100.00 WHERE acc_no = 1;
```
```
UPDATE 1
```
```
| => BEGIN;
| => UPDATE accounts SET amount = amount + 100.00 WHERE acc_no = 1;
```
The second UPDATE command is waiting for the lock. Let's wait for a second and complete the first transaction.
```
=> SELECT pg_sleep(1);
=> COMMIT;
```
```
COMMIT
```
Now the second transaction can be completed.
```
| UPDATE 1
```
```
| => COMMIT;
```
```
| COMMIT
```
And all the important information was logged:
```
postgres$ tail -n 7 /var/log/postgresql/postgresql-11-main.log
```
```
2019-08-07 15:26:30.827 MSK [5898] student@test LOG: process 5898 still waiting for ShareLock on transaction 529427 after 1000.186 ms
2019-08-07 15:26:30.827 MSK [5898] student@test DETAIL: Process holding the lock: 5862. Wait queue: 5898.
2019-08-07 15:26:30.827 MSK [5898] student@test CONTEXT: while updating tuple (0,4) in relation "accounts"
2019-08-07 15:26:30.827 MSK [5898] student@test STATEMENT: UPDATE accounts SET amount = amount + 100.00 WHERE acc_no = 1;
```
```
2019-08-07 15:26:30.836 MSK [5898] student@test LOG: process 5898 acquired ShareLock on transaction 529427 after 1009.536 ms
2019-08-07 15:26:30.836 MSK [5898] student@test CONTEXT: while updating tuple (0,4) in relation "accounts"
2019-08-07 15:26:30.836 MSK [5898] student@test STATEMENT: UPDATE accounts SET amount = amount + 100.00 WHERE acc_no = 1;
```
[Read on](https://habr.com/en/company/postgrespro/blog/503008/). | https://habr.com/ru/post/500714/ | null | en | null |
# Комментарии к задаче в Битрикс24 при коммите для Mercurial
 С каждым полугодием команда 1С-Битрикс презентует новый функционал облачных корпоративных порталов Битрикс24. Одной из востребованных функций портала можно назвать «Задачи», позволяющие Битрикс24 занимать места в рейтинге таск-трекеров (например, [Количество и качество: как развиваются таск-трекеры в условиях конкуренции](https://habrahabr.ru/post/302914/)). Поэтому многие веб-студии, особенно связанные с разработкой на 1С-Битрикс и Битрикс24, используют функционал задач в разработке.
В каждой задаче могут быть и постановщик, и соисполнители, и наблюдатели, в том числе и заказчики. В большинстве случаев работа с задачей длится не один день и может получится так, что в задаче (в комментариях к ней) не наблюдается активность разработчика (разработчиков), а наблюдателям кажется, что их задача не взята в работу и просто «динамится». Помимо названной проблемы хочется иметь полную информацию о том, что происходило с задачей от её начала до завершения.
В связи с этим и возникла необходимость отправлять информацию о ходе разработки во время коммитов, что бы фиксировать все изменения в комментариях к задачам не отвлекаясь на написание комментариев к ней — достаточно добавить информативный комментарий при коммите.
В работе используется VCS Mercurial, для которой и описана настройка отправки информации о коммите в комментарии задачи портала.
Для отправки комментариев при коммите Mercurial в портал Битрикс24 необходимо проделать следующие шаги:
1. На сайте, где будет размещаться приложение необходимо наличие SSL-сертификата.
2. Установить используя composer следующие пакеты:
* mesilov/bitrix24-php-sdk — обёртка на php для работы с BX24 REST API
* defuse/php-encryption — необходима для формирования ключа доступа
Установка осуществляется командой
```
$ composer require "mesilov/bitrix24-php-sdk: ^0.2.0" "defuse/php-encryption: ^2.0"
```
3. Загрузить на сайт файлы приложения:
* install.php — установочный файл приложения для Битрикс24. Необходим для получения приложением токенов доступа при установке приложения.
**install.php**
```
php
/**
* Установка приложения.
*
* Выполнить из окружения портала Битрикс24 для создания конфигурационного файла
*/
error_reporting(E_ALL & ~E_NOTICE);
require __DIR__ . '/vendor/autoload.php';
require __DIR__ . '/lib.php';
if (null === $_REQUEST['DOMAIN'] || null === $_REQUEST['member_id'] || null === $_REQUEST['AUTH_ID'] || null === $_REQUEST['REFRESH_ID']) {
die('Приложение необходимо установить из портала Битрикс24');
}
$params = AddMessageToBitrix24Task::load();
if (0 === count($params)) {
$params = [
//Идентификатор приложения в портале (из настроек приложения в портале)
'B24_APPLICATION_ID' = '',
//Секретное слово приложения в портале (из настроек приложения в портале)
'B24\_APPLICATION\_SECRET' => '',
//Требуемые для работы сущности портала (из настроек приложения в портале)
'B24\_APPLICATION\_SCOPE' => ['task'],
//URL приложения после установки (из настроек приложения в портале)
'B24\_REDIRECT\_URI' => 'https:///app.php',
//Домен портала
'DOMAIN' => $\_REQUEST['DOMAIN'],
//Уникальный идентификатор приложения
'MEMBER\_ID' => $\_REQUEST['member\_id'],
//Токен авторизации
'AUTH\_ID' => $\_REQUEST['AUTH\_ID'],
//Токен обновления
'REFRESH\_ID' => $\_REQUEST['REFRESH\_ID'],
];
//Сохранить настройки в кофигурационный файл
AddMessageToBitrix24Task::save($params);
}
//Проверка, что настроки сохранены корректно
if (AddMessageToBitrix24Task::check()) {
//Загружаем настройки для вывода в интерфейсе Битрикс24 ключа доступа
$params = AddMessageToBitrix24Task::load();
$result = 'Приложение установлено.
';
$result .= 'Добавьте в скрипт hook.php ключ доступа:
';
$result .= $params['KEY'];
} else {
$result = 'Приложение установлено c ошибками.
';
}
die($result);
```
* app.php — основной файл приложения, добавляющий комментарии к задачам при срабатывании хука Mercurial…
* lib.php — набор функций, необходимых для работы приложения
**lib.php**
```
php
/**
* Основной класс приложения
*/
use Defuse\Crypto\Crypto;
use Defuse\Crypto\Key;
/**
* Добавить комментарий к задачи в портале Битрикс24
*
* Class AddMessageToBitrix24Task
*/
class AddMessageToBitrix24Task
{
/**
* @var string Путь к настройкам приложения. Файл не должен находится в корне сайта.
*/
private static $config = __DIR__ . '/../bx24.auth';
/**
* @var string Ключ шифрования
*/
private static $safeKey;
/**
* Шифровать переменную
*
* @param string $var Переменная для шифрования
*
* @return string Шифрованная переменная
*
* @throws \Defuse\Crypto\Exception\BadFormatException
* @throws \Defuse\Crypto\Exception\EnvironmentIsBrokenException
*/
public static function encrypt($var)
{
return Crypto::encrypt($var, self::getKey());
}
/**
* Дешифровать переменую
*
* @param string $var Переменная для дешифрации
*
* @return string Дешифрованная переменная
*
* @throws \Defuse\Crypto\Exception\BadFormatException
* @throws \Defuse\Crypto\Exception\EnvironmentIsBrokenException
*/
public static function decrypt($var)
{
return Crypto::decrypt($var, self::getKey());
}
/**
* Получить ключ шифрования
*
* @return Key Ключ шифрования
*
* @throws \Defuse\Crypto\Exception\BadFormatException
* @throws \Defuse\Crypto\Exception\EnvironmentIsBrokenException
*/
public static function getKey()
{
if (null === self::$safeKey) {
$params = self::load();
//Получить ключ шифрования в бинарно-безопасном виде
if (null === $params || null === $params['PRIVATE_KEY']) {
self::$safeKey = Key::createNewRandomKey()-saveToAsciiSafeString();
} else {
self::$safeKey = $params['PRIVATE_KEY'];
}
}
return Key::loadFromAsciiSafeString(self::$safeKey);
}
/**
* Получить объект для работы с Bitrix24
*
* @param array $params Параметры для работы с Битрикс24
*
* @return \Bitrix24\Bitrix24 Объект для работы с Битрикс24
*
* @throws \Bitrix24\Bitrix24Exception
* @throws \Defuse\Crypto\Exception\BadFormatException
* @throws \Defuse\Crypto\Exception\EnvironmentIsBrokenException
*/
public static function getBX24Instance(array $params)
{
$bx24 = new \Bitrix24\Bitrix24(false);
$bx24->setApplicationScope($params['B24_APPLICATION_SCOPE']);
$bx24->setApplicationId($params['B24_APPLICATION_ID']);
$bx24->setApplicationSecret($params['B24_APPLICATION_SECRET']);
$bx24->setRedirectUri($params['B24_REDIRECT_URI']);
$bx24->setDomain($params['DOMAIN']);
$bx24->setMemberId($params['MEMBER_ID']);
$bx24->setAccessToken($params['AUTH_ID']);
$bx24->setRefreshToken($params['REFRESH_ID']);
//Если время жизни токенов истекло
if ($bx24->isAccessTokenExpire()) {
//ПОлучитть новый токен доступа
$temp = $bx24->getNewAccessToken();
//Обновить токены в объекте
$params['AUTH_ID'] = $temp['access_token'];
$params['REFRESH_ID'] = $temp['refresh_token'];
$bx24->setAccessToken($params['AUTH_ID']);
$bx24->setRefreshToken($params['REFRESH_ID']);
//Сохранить обновленные токены
self::save($params);
}
return $bx24;
}
/**
* Добавить комментарий к задаче
*
* @param \Bitrix24\Bitrix24 $bx24 Объект для работы с Битрикс24
* @param int $task Идентификатор задачи
* @param string $message Комментарий
*
* @return string
*/
public static function add(\Bitrix24\Bitrix24 $bx24, $task, $message)
{
$str = '';
try {
//Проверить есть ли такая задача на портале
$bx24->call(
'task.item.getdata',
[
'TASKID' => $task
]
);
$str .= 'Задача #' . $task . ' на портале ' . $bx24->getDomain() . ' найдена' . PHP_EOL;
//Добавить комментарий к задаче
$bx24->call(
'task.commentitem.add',
[
'TASKID' => $task,
'FIELDS' => [
'POST_MESSAGE' => $message
]
]
);
$str .= 'Комментарий к задаче успешно добавлен';
} catch (Exception $e) {
$str .= 'Ошибка при добавлении комментация к задаче';
}
return $str;
}
/**
* Сохранить настройки в конфигурационный файл
*
* @param array $params Настройки
*
* @return bool
*
* @throws \Defuse\Crypto\Exception\BadFormatException
* @throws \Defuse\Crypto\Exception\EnvironmentIsBrokenException
*/
public static function save(array $params)
{
//Ключ для доступа к приложению для добавления комментария
$params['KEY'] = AddMessageToBitrix24Task::encrypt($params['B24_APPLICATION_ID'] . $params['MEMBER_ID'] . $params['B24_APPLICATION_SECRET']);
//Ключ шифрования
$params['PRIVATE_KEY'] = self::$safeKey;
//Сохраняем данные в файл конфигурации
$result = json_encode($params, JSON_UNESCAPED_UNICODE);
return file_put_contents(self::$config, $result) > 0;
}
/**
* Получить настройки из конфигурационного файла
*
* @return array Настройки
*/
public static function load()
{
if (!file_exists(self::$config)) {
return [];
}
//Получить настройки приложения
$params = file_get_contents(self::$config);
return json_decode($params, true);
}
/**
* Проверка, что приложение установлено из заданого портала Битрикс24.
*
* @return bool
*/
public static function check()
{
try {
$params = AddMessageToBitrix24Task::load();
$bx24 = self::getBX24Instance($params);
$result = $bx24->call('app.info');
return $result['result']['CODE'] === $params['B24_APPLICATION_ID'];
} catch (\Exception $e) {
return false;
}
}
}
```
4. Загрузить на web-сервер, где используется VCS Mercurial файл hghook-commit-to-bx24.php, выполняющий обращение к приложению при коммите. Размещать файл необходимо вне корня сайта. Для работы скрипта необходимо наличие следующих функций:
* shell\_exec — выполнение консольных команд для формирования информации о коммите
* curl\_exec — для отправки данных в приложение**hghook-commit-to-bx24.php**
```
php
/**
* Хук срабатывающий после выполнения команды hg commit
*/
//Адрес приложения Битрикс24
define('BX24_APP_URL', 'https://<APP_DOMAIN/app.php');
//Ключ для обращения к приложению. Получить можно после установки из конфигурационного файла
define('KEY', '');
echo 'Запущен хук Mercurial, добавляющий информацию о коммите в задачу на портал' . PHP\_EOL;
if(!function\_exists('shell\_exec')){
echo 'Ошибка: функция «shell\_exec» недоступна' . PHP\_EOL;
echo 'Завершение хука' . PHP\_EOL;
exit(0);
}
if(!function\_exists('curl\_exec')){
echo 'Ошибка: функция «curl\_exec» недоступна' . PHP\_EOL;
echo 'Завершение хука' . PHP\_EOL;
exit(0);
}
//Путь к исполняемому файлу Mercurial
$hg = $\_SERVER['HG'];
if (!is\_file($hg) || !is\_executable($hg)) {
echo 'Ошибка: не найден исполняемый файл Mercurial' . PHP\_EOL;
echo 'Завершение хука' . PHP\_EOL;
exit(0);
}
echo 'Получение информации о коммите' . PHP\_EOL;
//Получить полное название хоста, на котором работает Mercurial
$hostname = trim(shell\_exec('hostname -f'));
//Абсолютный путь к текущему репозиторию
$pwd = $\_SERVER['PWD'];
//Текущая активная ветка Mercurial
$branch = shell\_exec("$hg branch");
//Получаем информацию о сделанном коммите
$log = trim(shell\_exec("$hg log -l 1"));
//Автор коммита
$matches = null;
$user = preg\_match('/user:\s+(?\S.\*)/ium', $log, $matches) ? $matches['user'] : 'unknown';
//Комментарий коммита
$summary = preg\_match('/summary:\s+(?\S.\*)/ium', $log, $matches) ? $matches['summary'] : '';
//Получить список файлов текущего коммита за исключюенеи удаленных
$files = trim(shell\_exec("$hg st -amr"));
//Количество файлов текущего коммита
$filesCount = substr\_count($files, PHP\_EOL);
//Получить номер задачи из названия текущей ветки Mercurial или из комментария к коммиту
echo 'Поиск номера задачи в названии ветки или комментарии' . PHP\_EOL;
$task = 0;
if (preg\_match('/^task[#\@\$](?\d+)/iu', $branch, $matches)) {
$task = (int)$matches['id'];
} elseif (preg\_match('/^task[#\@\$](?\d+)/iu', $summary, $matches)) {
$task = (int)$matches['id'];
}
//Если номер не обнаружен, то предлагаем пользователю его ввести
if ($task <= 0) {
echo 'Номер задачи не найден' . PHP\_EOL;
echo 'Введите номер задачи на портале или нажмите Enter, чтобы пропустить: ';
$count = fscanf(STDIN, "%d\n", $task);
if ($count <= 0) {
echo 'Номер задачи не введен.' . PHP\_EOL;
echo 'Информация о коммите не будет отправлена на портал' . PHP\_EOL;
echo 'Завершение хука' . PHP\_EOL;
exit(0);
}
}
echo 'Отправка информации о коммите на портал' . PHP\_EOL;
$message = << $message,
'task' => $task,
'key' => KEY
];
//Формируем запрос к приложению
$ch = curl\_init();
curl\_setopt($ch, CURLOPT\_URL, BX24\_APP\_URL);
curl\_setopt($ch, CURLOPT\_RETURNTRANSFER, true);
curl\_setopt($ch, CURLOPT\_FOLLOWLOCATION, true);
curl\_setopt($ch, CURLOPT\_POST, 1);
curl\_setopt($ch, CURLOPT\_POSTFIELDS, $postData);
curl\_setopt($ch, CURLOPT\_SSL\_VERIFYPEER, 0);
$result = curl\_exec($ch);
echo $result . PHP\_EOL;
echo 'Завершение хука' . PHP\_EOL;
```
5. Добавить в hgrc путь к загруженному файлу hghook-commit-to-bx24.php
```
[hooks]
commit = php -f /home/bitrix/hghook-commit-to-bx24.php
```
6. Выбрать в левом меню портала пункт «Добавить приложение», если оно не видно, то развернуть пункт «Приложения»
7. На странице выбираем тип приложения «Для личного пользования», так как мы его не собираемся выкладывать в облачный Маркетплейс
**Выбор типа приложения**
8. На странице настроек нового приложения указываем
* Название приложения
* Название пункта меню на нужном языке
* Установить права доступа на «Задачи (task)»
* Указываем ссылку на исполняемый файл приложения
* Указываем ссылку на установочный файл приложения**Настройки приложения**
После ввода всех настроек сохраняем приложение. Настройки можно всегда отредактировать и дополнить при необходимости, выбрав соответствующий пункт на списке задач в разделе «Мои приложения»
9. После сохранения приложения мы попадаем на страницу со списком приложений. Для каждого приложения Битрикс24 присваивает два уникальных параметра «Код приложения (client\_id)» и «Ключ приложения (client\_secret)», которые необходимо указать в файле install.php
**Список приложений**
10. Теперь необходимо перейти к установке приложения, кликнув по ссылке на приложение в левом меню. Если все сделано верно, то будет показано сообщение вида
```
Приложение установлено.
Добавьте в скрипт hghook-commit-to-bx24.php ключ доступа:
```
**Установка приложения**
Если ничего не было выведено (белая область вместо приложения), то скорее всего у вас установлен заголовок
```
Header set X-Frame-Options SAMEORIGIN
```
Он запрещает показывать ваш сайт во фреймах. Что бы исправить это, в директории с приложением достаточно создать (или отредактировать) файл .htaccess, добавив строку
```
Header unset X-Frame-Options
```
Полученный код доступа необходимо записать в файл hghook-commit-to-bx24.php
11. Если всё корректно настроено, то для добавления информации о коммите к задаче потребуется её номер. Номер задачи в Битрикс24 отображается около ее названия.
**Задача в портале**
Для добавления информации о коммите к задаче можно указать номер в тексте коммита в самом начале после «task#», «task@» или «task$».
```
[bitrix@dhcppc5 www]$ hg st
M composer.json
[bitrix@dhcppc5 www]$ hg ci -u testuser -m 'task#62 Выполнен пункт #1 чеклиста: сделано то-то и то-то'
Запущен хук Mercurial, добавляющий информацию о коммите в задачу на портал
Получение информации о коммите
Поиск номера задачи в названии ветки или комментарии
Отправка информации о коммите на портал
Задача #62 на портале .bitrix24.ru найдена
Комментарий к задаче успешно добавлен
Завершение хука
[bitrix@dhcppc5 www]$
```
**Комментарий к задаче #1**
Также можно получить номер задачи из названия рабочей ветки Mercurial, если она имеет название начинающееся с «task#», «task@» или «task$».
Если номер задачи не найден ни в комментарии, ни в названии ветки, то его можно ввести вручную.
```
[bitrix@dhcppc5 www]$ hg ci -u testuser -m 'Выполнен пункт #2 чеклиста: сделано то-то и то-то'
Запущен хук Mercurial, добавляющий информацию о коммите в задачу на портал
Получение информации о коммите
Поиск номера задачи в названии ветки или комментарии
Номер задачи не найден
Введите номер задачи на портале или нажмите Enter, чтобы пропустить: 62
Отправка информации о коммите на портал
Задача #62 на портале .bitrix24.ru найдена
Комментарий к задаче успешно добавлен
Завершение хука
[bitrix@dhcppc5 www]$
```
**Комментарий к задаче #2**
Если ввод номера задачи пропущен, то комментарий не будет отправлен.
```
[bitrix@dhcppc5 www]$ hg ci -u testuser -m 'Выполнен пункт #3 чеклиста: сделано то-то и то-то'
Запущен хук Mercurial, добавляющий информацию о коммите в задачу на портал
Получение информации о коммите
Поиск номера задачи в названии ветки или комментарии
Номер задачи не найден
Введите номер задачи на портале или нажмите Enter, чтобы пропустить:
Номер задачи не введен
Информация о коммите не будет отправлена на портал
Завершение хука
[bitrix@dhcppc5 www]$
```
Если будет указан несуществующий номер задачи, то будет выведено соответствующее уведомление об ошибке.
```
[bitrix@dhcppc5 www]$ hg ci -u testuser -m 'task$65445642 Выполнен пункт #3 чеклиста: сделано то-то и то-то'
Запущен хук Mercurial, добавляющий информацию о коммите в задачу на портал
Получение информации о коммите
Поиск номера задачи в названии ветки или комментарии
Отправка информации о коммите на портал
Ошибка при добавлении комментария к задаче
Завершение хука
[bitrix@dhcppc5 www]$
```
[Код из статьи](https://github.com/gebvlad/bitrix24-hg-commit-hook).
Использованные материалы:
* [Mercurial — hgrc](https://www.selenic.com/mercurial/hgrc.5.html#hooks)
* [Битрикс24 REST API](http://dev.1c-bitrix.ru/rest_help/)
* [bitrix24-php-sdk](https://github.com/mesilov/bitrix24-php-sdk)
* [defuse/php-encryption](https://github.com/defuse/php-encryption) | https://habr.com/ru/post/303718/ | null | ru | null |
# ExtendScript: Работа со слоями
[<= Предыдущая статья ExtendScript + Expression](https://habr.com/ru/post/545068/)
И так, у нас готов макет для титров. Мы движемся к финишной прямой. Нам осталось только дописать скрипт, дополнив его методами копирования моделей на сцену.
Заходим в метод **createTitres** и сразу после добавления сцены запускаем цикл, проходясь по массиву с данными титров.
```
function createTitres(data) {
var scenesData = getScenesData();
for(var i = 0; i < scenesData.length; i++) {
var scene = getScene(scenesData[i]);
for (var j = 0; j < data.length; j++) {
var titreName = 'titre-' + j + '-' + scenesData[i].type;
var layer = scene.layers.byName(titreName);
}
}
}
```
В цикле мы первым делом пытаемся обнаружить титр на сцене. Для этого мы обращаемся к свойству композиции **layers** и его методу **byName**. Зачем мы это делаем, обсудим чуть позже. Пока давайте рассмотрим ситуацию, когда метод возвращает нам **null**, что значит, нет слоя с таким именем.
```
if (!layer) {
var modelName = 'ModelTitre_' + data[j].type + '_' + scenesData[i].type;
var item = getTitreComp(modelName);
}
//………………………………………………………………………………………//
function getTitreComp(modelName) {
var item = getItem(modelName, CompItem);
if (!item) {
alert('Отсутствует модель ' + modelName);
return null;
}
return item.duplicate();
}
```
В методе **getTitreComp** мы находим модельку титра и, если такой не нашли, возвращаем **null**. Если же модель нашлась, возвращаем ее дубликат. Далее, мы переименовываем дубликат и добавляем его на сцену методом **layers.add**, который возвращает нам слой с дубликатом
```
if (item) {
item.name = titreName;
layer = scene.layers.add(item);
}
```
Переходим к редактированию слоя. Для этого создадим метод **editLayer**, в который будем передавать сам слой, конечную точку предыдущего титра (она послужит стартовой для текущего) и мастер слой из композиции **ModelScene**,по которому мы будем проводить настройки**.**
Чтобы получить конечную точку, мы перед запуском цикла с данными титров создадим переменную **startTime** равную нулю, первый титр начинается в точке ноль
```
var scene = getScene(scenesData[i]);
var startTime = 0;
```
А метод **editLayer** будет нам возвращать новое его значение
Чтобы получить мастер слой, в методе **getScenesData** дополним объект сцены еще одним полем, **layers**, со слоями нашего макета.
```
data.push({
type: item.name.split('_')[1],
width: item.width,
height: item.height,
frameRate: item.frameRate,
duration: item.duration,
layers: item.layers
});
```
А в методе **createTitres** получим из этого поля интересующий нас слой. И передадим все это методу **editLayer**
```
if (item) {
item.name = titreName;
layer = scene.layers.add(item);
var modelLayer = scenesData[i].layers.byName(modelName);
startTime = editLayer(layer, startTime, modelLayer);
}
```
Теперь давайте создадим метод **editLayer**
```
function editLayer(layer, startTime, modelLayer) {
if (modelLayer) {
// Настройки по мастер-слою
} else {
// Настройки по умолчанию
}
}
```
В нем мы проверяем, есть ли мастер-слой и если его нет, делаем все настройки по умолчанию. Давайте с дефолтных и начнем, так как их меньше.
```
layer.startTime = startTime;
layer.outPoint = startTime + 5;
```
Мы перемещаем слой в место, где завершился предыдущий слой и указываем продолжительность слоя пять секунд.
Настроек по мастер слою будет на одну больше,
```
layer.label = modelLayer.label;
layer.startTime = startTime;
var layerDuration = modelLayer.outPoint - modelLayer.startTime;
layer.outPoint = startTime + layerDuration;
```
Первой строкой мы назначаем слою цвет, в который он будет покрашен на таймлайне. Это очень удобно, когда у вас несколько разных типов титров. Далее, как и в дефолтных, настройках указываем точку входа слоя. Третьей строкой мы высчитываем продолжительность слоя в мастере и прибавив это значение к **startTime**, получаем значение **layer.outPoint**, которое и возвращаем в итоге**.**
Финальный вид этот метод имеет следующий
```
function editLayer(layer, startTime, modelLayer) {
layer.startTime = startTime;
if (modelLayer) {
layer.label = modelLayer.label;
var layerDuration = modelLayer.outPoint - modelLayer.startTime;
layer.outPoint = startTime + layerDuration;
} else {
layer.outPoint = startTime + 5;
}
return layer.outPoint;
}
```
Снова возвращаемся в метод **createTitres**. Теперь нам надо отредактировать **Expressions** в наших титрах. Если помните из прошлой статьи, мы в выражениях ссылались на **ModelScene\_1x1**. Теперь же нам надо заменить эти ссылки на на нашу композицию **scene-1x1**
```
startTime = editLayer(layer, startTime, modelLayer);
changeExpression(
item,
'ModelScene_' + scenesData[i].type,
'scene-' + scenesData[i].type
);
//................................................................
function changeExpression(comp, search, replacement) {
for (var i = 1; i <= comp.numLayers; i++) {
var layer = comp.layer(i);
var propGroup = layer.property('ADBE Transform Group');
for (var j = 1; j <= propGroup.numProperties; j++) {
var prop = propGroup.property(j);
if (prop.expression) {
prop.expression = prop.expression.replace(
new RegExp(search, 'g'),
replacement
)
}
}
}
}
```
Метод **changeExpression** получает композицию с титром, строку которую следует заменить и строку на которую меняем. В самом методе мы проходимся по всем слоям композиции. Количество слоев хранит свойство композиции **numLayers**. Индексация слоев начинается с единицы. Находим группу свойств слоя **ADBE Transform Group** *(с наименованиями объектов в After Effects можете ознакомиться* [*тут*](https://ae-scripting.docsforadobe.dev/matchnames/layer/avlayer/)*)*. Проходим по всем свойствам группы, их количество хранит **numProperties**. А далее, находим свойство содержащее выражение и заменяем все вхождения **ModelScene\_1x1** на **titre-1x1**.
Анимация уже работает. Последнее, что нам осталось сделать, это поменять текст в титре.
```
changeExpression(
item,
'ModelScene_' + scenesData[i].type,
'scene-' + scenesData[i].type
);
setText(item.layers.byName('reference_text'), data[j].text)
//................................................................
function setText(layer, text) {
if (layer) {
var property = layer.text.property("Source Text");
var value = property.value;
value.text = text;
property.setValue(value);
}
}
```
Мы передаем методу **setText** слой **reference\_text**, о котором заранее договорились содержать его в каждом макете титра, а также сам текст.
Метод **setText** обращается к свойству текстового слоя **SourceText**, меняет в его значение свойство **text,** вновь передавая значение свойству, не пропустите это последнее действие, иначе свойство не поменяет значение.
Все готово. Нам осталось лишь описать поведение, если все же композиция с титром уже создана и лежит на сцене.
```
for (var j = 0; j < data.length; j++) {
var titreName = 'titre-' + j + '-' + scenesData[i].type;
var layer = scene.layers.byName(titreName);
if (!layer) {
var modelName = //....
//....
} else {
setText(
layer.source.layers.byName('reference_text'),
data[j].text
);
}
}
```
Мы лишь меняем текст в титре. Для этого мы обращаемся к свойству слоя **source**, хранящее композицию, из которой состоит сам слой.
Скрипт готов. Можем его проверить. Вставляем текст титров в текстовое окно плагина
```
#simple Текст первого титра
Тип данного титра simple
#simple Титры simple могут быть и в одну строку
#double Текст третьего титра
Тип этого титра double
```
Титры выстроились на сцене.
Можем выставить их в нужное место таймлайна, изменить длительность.
Второй титр не умещается в рамках сцены.
Можно исправление внести в окне плагина и вновь запустив скрипт, можно зайти в композицию титра и отредактировать слой **refernce\_text**.
Теперь, соблюдая простые правила составления макета, вы сможете сделать титры любой сложности, на сцене любого формата. На деле скрипт сложнее, он включает в себя копирование эффектов слоев макета на слои сцены и некоторых элементов настройки слоев. Возможно, позже я расскажу об этом. Но уже этот скрипт вполне функционален и пригоден к использованию в производстве видео. Вам надо лишь однажды сделать макет, и вы всегда сможете создавать любое количество его копий буквально за секунды.
Скрипт с комментариями вы можете найти [тут](https://gitlab.com/ae-api-sdk/ae-api-sdk-examples/-/blob/master/titres-part-2.jsx).
Документацию по работе со слоями в ExtendScript [тут](https://ae-scripting.docsforadobe.dev/layers/layer/).
Спасибо за внимание. Если эти уроки окажутся кому-то полезны, будет приятно узнать о проектах, в которых читатели применят данные навыки.
[<= Предыдущая статья ExtendScript + Expression](https://habr.com/ru/post/545068/) | https://habr.com/ru/post/545704/ | null | ru | null |
# Wake on Lan бот для Telegram
После открытия [API ботов](https://core.telegram.org/bots/api) для Telegram их популяция начала стремительно расти. Я решил не отставать и обзавестись собственным для возможности удаленно включать компьютер. Для разработки был выбран язык C#, а в качестве хостинга выбор пал на Azure.
#### **Задача**
Написать бота, который сможет отправлять «магические пакеты» для включения компьютера на указанный адрес и порт.
Примечание: в статье не рассматриваются получение токена для бота и деплой сайта на Azure. На эти вопросы без труда [находится ответ на хабре](http://habrahabr.ru/post/262247/) или Google.
#### **Немного теории и сетевые настройки**
Для включения компьютера будет использоваться технология [Wake on Lan](https://ru.wikipedia.org/wiki/Wake-on-LAN). Поскольку бот будет находиться в облаке, нам нужно отправлять пакет на внешний адрес. В связи с этим, нужно позаботиться о том, чтобы пакет в итоге попал в локальную сеть и достиг нужной сетевой платы. Для этого нужно пробросить порт на маршрутизаторе:
**Почему 7 порт и такой адрес?**Обычно, чтобы включить компьютер в локальной сети с помощью Wake on Lan, требуется отправить «волшебный пакет» на широковещательный адрес локальной сети, на порт 7/UDP (в некоторых случаях могут использоваться и другие порты). Когда сетевая карта получает “свой” пакет, она подает сигнал на включение компьютера.
Пакет состоит из набора байт в следующем порядке: первые 6 байтов — нулевые, затем идет последовательность байт из мак-адреса сетевой карты, который повторяется 16 раз. Собственно, именно по MAC адресу сетевая карта и понимает, что нужно включить именно ее компьютер.
Мы будем формировать такой пакет и отправлять его на наш внешний адрес (например, на адрес домашнего роутера), после чего пакет должен будет маршрутизироваться на broadcast адрес локальной сети.
В моем случае пробрасывается 7 порт (доступный из интернета) на шировещательный адрес сети (10.10.10.255).
#### **Пишем код**
Для работы с API бота была выбрана библиотека [Telegram.Bot](https://github.com/MrRoundRobin/telegram.bot). Для получения обновлений будем использовать [вариант с вебхуком](https://core.telegram.org/bots/api#setwebhook). В этом случае каждое сообщение или событие, которые будет получать бот, будут отправлены на указанный URL.
В качестве хостинга было решено использовать Azure, так как он подходит по всем параметрам:
* всегда доступен
* на бесплатном тарифе есть сертификат, который позволяет обращаться к сайту по HTTPS (боты могут отправлять обновления только по зашифрованным соединениям)
* быстрая и удобная публикация сайта прямо из Visual Studio
Для начала создаем класс, который будет возвращать нам объект для работы с ботом:
```
public static class Bot
{
private static Api _bot;
///
/// Получаем бота, а если он еще
/// не инициализирован - инициализируем
/// и возвращаем
///
public static Api Get()
{
if (_bot != null) return _bot;
_bot = new Api(Config.BotApiKey);
_bot.SetWebhook(Config.WebHookUrl);
return _bot;
}
}
```
Настройки достаем из класса Config
**Config.cs**
```
public static class Config
{
///
/// Настройки для бота храним в настройках приложения
///
private static readonly NameValueCollection Appsettings = ConfigurationManager.AppSettings;
///
/// Полученный токен для бота
///
public static string BotApiKey
{
get { return Appsettings["BotApiKey"]; }
}
///
/// URL, на который должны приходить все обновления от бота
///
public static string WebHookUrl
{
get { return Appsettings["WebHookUrl"]; }
}
}
```
Теперь нам нужно формировать и отправлять пакет. За это будет отвечать класс WakeOnLan
```
///
/// Может отправлять "волшебные" пакеты для включения удаленного компьютера
///
public static class WakeOnLan
{
public static void Up(string ip, string mac, int? port = null)
{
var client = new UdpClient();
var data = new byte[102];
for (var i = 0; i <= 5; i++) // первые шесть байт - нулевые
data[i] = 0xff;
var macDigits = GetMacDigits(mac);
if (macDigits.Length != 6)
throw new ArgumentException("Incorrect MAC address supplied!");
const int start = 6;
for (var i = 0; i < 16; i++) // создаем нужную последовательность байт для пакета
for (var x = 0; x < 6; x++)
data[start + i * 6 + x] = (byte)Convert.ToInt32(macDigits[x], 16);
client.Send(data, data.Length, ip, port ?? 7); // отправляем пакет
}
private static string[] GetMacDigits(string mac) // парсим MAC
{
return mac.Split(mac.Contains("-") ? '-' : ':');
}
public static bool ValidateMac(string mac) // простая проверка на валидность MAC адреса
{
return GetMacDigits(mac).Length == 6;
}
}
```
Пакеты формируем и умеем отправлять. Осталось научить бота отвечать на команду, к примеру, /wol.
Для простоты реализована команда с параметрами, т.е. пользователь должен будет ввести примерно следующее
`/wol 1.2.3.4 01:02:03:04:05:06 7`
для того, чтобы отправить пакет на адрес 1.2.3.4, на 7 порт и разбудить компьютер с MAC адресом 01:02:03:04:05:06
```
public async void Handle(Message message)
{
var text = message.Text.Split(' ');
if (text.First() != "/wol") return;
switch (text.Count())
{
case 1:
case 2:
await _bot.SendTextMessage(message.Chat.Id, "Пример использования: /wol 1.2.3.4 01:02:03:04:05:06 7");
break;
default:
if (!WakeOnLan.ValidateMac(text[2]))
await _bot.SendTextMessage(message.Chat.Id, "Неверный MAC адрес");
else
{
try
{
WakeOnLan.Up(text[1], text[2], GetPort(text));
await _bot.SendTextMessage(message.Chat.Id, "Пакет отправлен!");
}
catch (Exception)
{
await _bot.SendTextMessage(message.Chat.Id, "Произошла ошибка :(");
}
}
break;
}
}
///
/// Получаем порт из параметров
///
private static int? GetPort(IReadOnlyList text)
{
int port;
if (text.Count == 4 && int.TryParse(text[3], out port))
return port;
return null;
}
```
Отлично, осталось лишь создать контроллер, который будет принимать обновления от бота:
```
public class MessageController : ApiController
{
[Route(@"api/message/wol")]
public OkResult Post([FromBody]Update value)
{
Task.Run(() => new Handler().Handle(value.Message));
return Ok();
}
}
```
После «заливки» приложения в Azure проверяем [бота](https://telegram.me/wol_bot):
**Ссылки:**
[WoL бот в Telegram](https://telegram.me/wol_bot)
[Проект на GitHub](https://github.com/spoofi/WolBot)
[API ботов Telegram](https://core.telegram.org/bots/api)
[Библиотека Telegram.Bot (GitHub)](https://github.com/MrRoundRobin/telegram.bot) | https://habr.com/ru/post/265305/ | null | ru | null |
# Эмулируем React useState в обычном JS (via data-attributes & css selectors)
Добрый день, Хабр! Решил поделиться своим небольшим, но полезным открытием в плане использования html data-attributes & css selectors.
Html data-attributes - это кастомные атрибуты, которые вы можете сами назначать куда-угодно и с каким угодно именем (но имя должно начинаться с префикса `data-`). Затем вы можете использовать их в css селекторах, чтобы влиять на содержимое классов и уже классами управлять элементами. Движок браузера автоматически среагирует на изменение data-атрибута и применит соответствующий код css класса.
Код реакт компоненты, где по нажатию кнопки что-то скрывается, что-то показывается:
```
import React, {useState} from "react";
const ComponentWithExpandableContent = () => {
const [expanded, setExpanded] = useState(false)
return
{ !expanded && Initial content }
setExpanded(!expanded)}>
{ !expanded ? 'Expand' : 'Collapse' }
{ expanded && Additional content }
{ expanded && More additional content }
}
export default React.memo(ComponentWithExpandableContent)
```
Состояние `expanded=false`:
Состояние `expanded=true`:
Теперь просто `html css js`.
Файл `emulating-use-state.html:`
```
Эмулируем React useState в обычном JS
(via data-attributes & css selectors)
function toggleExpand(){
const element = document.getElementById('component')
if (element.dataset.expanded!=='true'){
element.dataset.expanded = 'true'
} else {
element.dataset.expanded = 'false'
}
}
Initial content
Expand
Collapse
Additional content
More additional content
```
Файл стилей `emulating-use-state.scss:`
```
.someElementContext {
display: contents;
.component {
display: flex;
flex-flow: column nowrap;
align-items: start;
padding: 32px;
gap: 32px;
// Классы, управляющие видимостью элементов на странице
// в зависимости от текущего значения data-expanded
.expandableContent {
display: none;
}
.collapsableContent {
display: contents;
}
&[data-expanded=true] .expandableContent {
display: contents;
}
&[data-expanded=true] .collapsableContent {
display: none;
}
}
}
```
Сгенерированный средой разработки `emulating-use-state.css:`
```
.someElementContext {
display: contents;
}
.someElementContext .component {
display: flex;
flex-flow: column nowrap;
align-items: start;
padding: 32px;
gap: 32px;
}
.someElementContext .component .expandableContent {
display: none;
}
.someElementContext .component .collapsableContent {
display: contents;
}
.someElementContext .component[data-expanded=true] .expandableContent {
display: contents;
}
.someElementContext .component[data-expanded=true] .collapsableContent {
display: none;
}
```
Получилось поведение аналогичное описанному в реакт компоненте.
Здесь в качестве стэйта выступает кастомный data-атрибут `data-expanded` - он и хранит состояние. А css селектор `[data-expanded=true]` изменяет свойство `display` из `none` в `contents` (`display: contents` означает показывать содержимое элемента так, как будто самого элемента не существует) и обратно в специальных классах-обёртках `.expandableContent` & `.collapsableContent`, которыми можно просто обернуть любые элементы в html разметке. | https://habr.com/ru/post/708822/ | null | ru | null |
# История одного проекта или как я 7 лет создавал АТС на базе Asterisk и Php
Наверняка у многих из вас, как и у меня, была идея сделать что-нибудь уникальное. В этой статье я опишу технические проблемы и решения, с которыми пришлось столкнуться при разработке АТС. Возможно, это кому-то поможет решиться на свою идею, а кому-то пройти по протоптанной дорожке, ведь я тоже пользовался опытом первопроходцев.
Идея и ключевые требования
--------------------------
А началось всё банально с любви к *Asterisk* (framework для построения коммуникационный приложений), автоматизации телефонии и установок *FreePBX* (веб интерфейс для *Asterisk*). Если потребности компании были без особенностей и укладывались в возможности *FreePBX* – всё супер. Вся установка проходила за сутки, компания получала настроенную АТС, удобный интерфейс и краткое обучение плюс сопровождение по желанию.
Но самые интересные задачи были нестандартными и тогда было не так сказочно. *Asterisk* может многое, но чтобы сохранить в рабочем виде веб-интерфейс, приходилось потратить в разы больше времени. Так небольшая мелочь могла занять времени гораздо больше, чем установка всей остальной АТС. И дело не в том, что писать веб интерфейс долго, а скорее дело в особенностях архитектуры *FreePBX*. Подходы и методы архитектуры *FreePBX* закладывалась во времена php4, а в тот момент уже был php5.6 на котором всё можно было сделать проще и удобнее.
Последней каплей стали графические диалпланы в виде схемы. Когда попытался подобное построить для *FreePBX*, понял, что придётся существенно его переписать и проще уже построить что-нибудь новое.
Ключевыми требованиями стали:
* простая настройка, интуитивно доступная даже начинающему администратору. Тем самым компаниям не требуется обслуживание АТС на нашей стороне,
* легкая доработка, чтобы задачи решались за адекватное время,
* удобство интеграции с АТС. У *FreePBX* не было API для изменения настроек, т.е. нельзя, например, создавать группы или голосовые меню из стороннего приложения, только API самого *Asterisk*,
* opensource – для программистов это крайне важно для доработок под клиента.
Идея более быстрой разработки была в том, чтобы весь функционал состоял из модулей в виде объектов. Все объекты должны были иметь общий родительский класс, а значит названия всех основных функций уже известны и значит уже есть реализации по умолчанию. Объекты позволят резко сократить количество аргументов в виде ассоциативных массивов со строковыми ключами, узнать которые в *FreePBX* можно было, исследовав всю функцию и вложенные функции. В случае объектов банальное автодополнение покажет все свойства, да и целом во много раз упростит жизнь. Плюс наследование и переопределение уже закрывает множество проблем с доработками.
Следующее, что замедляло время доработки и чего стоило избежать — это дублирование. Если есть модуль ответственный за дозвон до сотрудника, то все остальные модули, которым нужно отправить звонок сотруднику, должны использовать именно его, а не создавать свои собственные копии. Так, если нужно что-нибудь поменять, то менять придется только в одном месте и поиск «как это работает» проводить одного места, а не осуществлять поиск по всему проекту.
Первая версия и первые ошибки
-----------------------------
Первый прототип был готов уже через год. Вся АТС, как и планировалось, была модульная, и модули могли не только добавлять новый функционал для обработки звонков, но и менять сам веб-интерфейс.
Да, идея построения диалплана в виде такой схемы не моя, но она весьма удобная и я сделал то же самое для *Asterisk*.
С помощью написания модуля, программисты уже могли:
* создавать для обработки звонка собственный функционал, который можно было разместить на схеме, а также в меню элементов слева,
* создавать собственные страницы для веб-интерфейса и добавлять свои шаблоны на существующие страницы (если разработчик страницы это предусмотрел),
* добавлять свои настройки на вкладку основных настроек или создавать собственную вкладку с настройками,
* программист может пронаследоваться от существующего модуля, изменить часть функционала и зарегистрировать под новым именем или заменить оригинальный модуль.
Например, вот так можно создать своё голосовое меню:
```
......
class CPBX_MYIVR extends CPBX_IVR
{
function __construct()
{
parent::__construct();
$this->_module = "myivr";
}
}
.....
$myIvrModule = new CPBX_MYIVR();
CPBXEngine::getInstance()->registerModule($myIvrModule,__DIR__); //Зарегистрировать новый модуль
CPBXEngine::getInstance()->registerModuleExtension($myIvrModule,'ivr',__DIR__); //Подменить существующий модуль
```
Первые сложные внедрения принесли первую гордость и первые разочарования. Радовало то, что оно работало, что я уже смог воспроизвести основные возможности *FreePBX*. Радовало, что людям идея схемы пришлась по душе. Было ещё много вариантов упростить разработку, но и на тот момент часть задач уже делалась проще.
Разочарованием стало API для изменения конфигурации АТС — получилось совсем не то, что хотелось. Я взял тот же принцип, что и во *FreePBX*, по нажатию кнопки Apply пересоздается вся конфигурация и перезапускаются модули.
Выглядит это так:
\**Диалплан — правило(алгоритм), по которому обрабатывается звонок.*
Но при таком варианте невозможно написать нормальное API для изменения настроек АТС. Во-первых, операция применения изменений к *Asterisk* слишком долгая и ресурсоемкая.
Во-вторых, нельзя вызвать две функции одновременно, т.к. обе будут создавать конфигурацию.
В-третьих, применяет все настройки в том числе сделанные администратором.
В этой версии, как и в *Askozia*, можно было генерить конфигурацию только измененных модулей и перезапускать только необходимые модули, но это всё полумеры. Необходимо было менять подход.
Вторая версия. Нос вытащил хвост увяз
-------------------------------------
Идеей для решения проблемы стало не пересоздавать конфигурацию и диалплан для *Asterisk*, а сохранять информацию в базу и читать из базы прямо во время обработки звонка. *Asterisk* уже умел читать конфигурации из базы, достаточно поменять значение в базе и следующий звонок уже будет обрабатываться с учетом изменений, а для чтения параметров диалплана отлично подошла функция *REALTIME\_HASH*.
В итоге не понадобилось даже перезапускать *Asterisk* при изменении настроек и все настройки стали применяться сразу к *Asterisk*.
Единственные изменения диалплана – это добавления внутренних номеров и *hints*. Но это были маленькие точечные изменения
```
exten=>101,1,GoSub(‘sub-callusers’,s,1(1)); - точечное изменение, добавляется/изменяется через ami
; sub-callusers – универсальная функция генерится при установке модуля.
[sub-callusers]
exten =>s,1,Noop()
exten =>s,n,Set(LOCAL(TOUSERID)=${ARG1})
exten =>s,n,ClearHash(TOUSERPARAM)
exten =>s,n,Set(HASH(TOUSERPARAM)=${REALTIME_HASH(rl_users,id,${LOCAL(TOUSERID)})})
exten =>s,n,GotoIf($["${HASH(TOUSERPARAM,id)}"=""]?return)
...
```
Добавить или поменять строку в диалплане легко можно через *Ami* (интерфейс управления *Asterisk*) и перезагрузки всего диалплана не требуется.
Так была решена проблема с API для конфигурации. Можно было даже напрямую зайти в базу и добавить новую группу или поменять, например, время дозвона в поле “dialtime” у группы и следующий звонок уже будет длиться указанное время (Это не рекомендация к действию, т.к. для некоторых API операций требуются *Ami* вызовы).
Первые сложные внедрения опять принесли первую гордость и разочарование. Радовало то, что это работает. База данных стала критически важным звеном, выросла зависимость от диска, рисков больше, но всё работало стабильно и без проблем. А главное теперь всё, что можно было сделать через веб-интерфейс, можно было сделать и через API и при этом использовались одни и те же методы. Дополнительно, веб-интерфейс избавился от кнопки «применить настройки к АТС», о которой администраторы часто забывали.
Разочарованием стало усложнение разработки. Ещё с первой версии язык php генерит диалплан на языке *Asterisk* и выглядит это совершенно нечитаемо, плюс сам язык *Asterisk* для написания диалплана крайне примитивен.
Как это выглядело:
```
$usersInitSection = $dialplan->createExtSection('usersinit-sub','s');
$usersInitSection
->add('',new \Dialplan\ext_gotoif('$["${G_USERINIT}"="1"]','exit'))
->add('',new \Dialplan\ext_set('G_USERINIT','1'))
->add('',new \Dialplan\ext_gosub('1','s','sub-AddOnAnswerSub','usersconnected-sub'))
->add('',new \Dialplan\ext_gosub('1','s','sub-AddOnPredoDialSub','usersinitondial-sub'))
->add('',new \Dialplan\ext_set('LOCAL(TECH)','${CUT(CHANNEL(name),/,1)}'))
->add('',new \Dialplan\ext_gotoif('$["${LOCAL(TECH)}"="SIP"]','sipdev'))
->add('',new \Dialplan\ext_gotoif('$["${LOCAL(TECH)}"="PJSIP"]','pjsipdev'))
```
Во второй версии диалплан стал универсальным, в него были заложены все возможные варианты обработки в зависимости от параметров и его размер значительно вырос. Всё это сильно замедляло время разработки, и сама мысль что в очередной раз нужно вмешиваться в диалплан наводила грусть.
Третья версия
-------------
Идеей для решения проблемы стало не генерить *Asterisk* диалплан из php, а использовать *FastAGI* и все правила обработки писать уже на самом php. *FastAGI* позволяет *Asterisk*, для обработки звонка, подключиться к сокету. Получать оттуда команды и отправлять результаты. Таким образом логика диалплана находится уже за границами *Asterisk* и может быть написана на любом языке, в моём случае на php.
Тут было много проб и ошибок. Главной проблемой являлось, что у меня уже было много классов/файлов. На создание объектов, инициализацию и взаимную регистрацию между ними уходило около 1,5 секунд, и эта задержка на каждый звонок не то, что можно игнорировать.
Инициализация должна была быть только 1 раз и поэтому поиски решения начались с написания сервиса на php с использованием *Pthreads*. Спустя неделю экспериментов этот вариант был отложен из-за тонкостей работы этого расширения. От асинхронного программирования на php после месяца тестов тоже пришлось отказаться, нужно было что-то простое, знакомое любому новичку php, да и многие расширения для php синхронные.
Решением стал свой многопоточный сервис на ‘си’, который компилировался с *PHPLIB*. Он подгружает все php файлы АТС, ждёт, когда все модули инициализируются, добавят коллбэк друг к другу и когда всё готово – кэширует. При запросе по *FastAGI* создаётся поток, в нём воспроизводится копия из кэша всех классов и данных и запрос передается в php функцию.
При таком решении время от отправки звонка в наш сервис до первой команды *Asterisk* сократилось с 1,5с до 0,05с и это время слабо зависит от размера проекта.
В итоге, время на разработку диалплана сократилось существенно, и я могу это оценить поскольку мне пришлось переписать веcь диалплан всех модулей на php. Во-первых, в php уже должны быть написаны методы для получения объекта из базы, они были нужны для отображения в веб-интерфейсе, а во-вторых, и это главное – наконец-то появилась возможность удобной работы со строками с числами с массивами с базой данных плюс множество расширений php.
Для обработки диалплана в классе модуля нужно реализовать функцию *dialplanDynamicCall* и аргумент *pbxCallRequest* будет содержать объект для взаимодействия с *Asterisk*.
В дополнении появилась возможность отлаживать диалплан (в php есть xdebug и для нашего сервиса оно работает), можно двигаться по шагам просматривая значения переменных.
Данные по звонкам
-----------------
Для любой аналитики и отчётов нужны правильно собранные данные и этот блок АТС тоже проходил много проб и ошибок с первой по третью версию. Зачастую данные по звонкам – это табличка. Один звонок = одна запись: кто звонил, кто ответил, сколько проговорили. В более интересных вариантах есть ещё дополнительная табличка, кого из сотрудников АТС вызывала во время звонка. Но всё это закрывает лишь часть потребностей.
Первоначальными требованиями стали:
* сохранять не только кому звонила АТС, но и кто ответил, т.к. существуют перехваты и при анализе звонков это нужно будет учитывать,
* время до соединения с сотрудником. Во *FreePBX* и некоторых других АТС, звонок считается отвеченным, как только АТС поднимет трубку. Но для голосового меню уже нужно поднять трубку, таким образом все звонки становятся отвеченными и время ожидания ответа становится 0-1 секунду. Поэтому решено было сохранять не только время до ответа, но время до соединения с ключевыми модулями (модуль сам устанавливает у себя это флаг. Сейчас это «Сотрудник», «Внешняя линия»),
* для более сложного диалплана, когда звонок гуляет между разными группами, нужна была возможность каждый элемент исследовать по отдельности.
Лучшим вариантом оказался вариант, когда модули АТС сами о себе отправляют информацию по звонкам и в итоге сохранять информацию в виде дерева.
Выглядит это следующим образом:
Для начала общая информация о звонке(как у всех — ничего особенного).
1. Поступил звонок по внешней линии «*Для теста*» в 05:55:52 с номера 89295671458 на номер 89999999999, в итоге на него ответил сотрудник «*Секретарь2*» с номером 104. Клиент прождал 60 секунд и разговаривал 36 секунд.
2. Сотрудник «*Секретарь2*» делает звонок на номер 112 и на него отвечает сотрудник «*Менеджер1*» спустя 8 секунд. Разговаривают 14 секунд.
3. Клиента переводят на Сотрудника «*менеджер1*» где они продолжают разговаривать ещё 13 секунд
Но это вершина айсберга, по каждой записи можно получить подробное прохождение звонка по АТС.
Вся информация представляется в виде вложенности вызовов:
1. Поступил звонок по внешней линии «*Для теста*» в 05:55:52 с номера 89295671458 на номер 89999999999.
2. В 05:55:53 внешняя линия отправляет звонок на Входящую схему «*test*»
3. Во время обработки звонка по схеме вызывается модуль «*вызов менеджера*», в котором звонок находится 16 секунд. Это разработанный под клиента модуль.
4. Модуль «*вызов менеджера*» отправляет звонок на ответственного за номер (клиента) сотрудника «*Менеджер1*» и ожидает ответа 5 секунд. Менеджер не ответил.
5. Модуль «*вызов менеджера*» отправляет звонок на группу «*Менеджеры КОРП*». Это другие менеджеры такого же направления (сидят в одной комнате) и ожидает ответа 11 секунд.
6. Группа «*Менеджеры КОРП*» вызывает сотрудников «*Менеджер1*, *Менеджер2*, *Менеджер3*» одновременно по 11 секунд. Ответа нет.
7. Вызов менеджера завершается. И схема звонок отправляет на модуль «*Выбор маршрута из 1с*». Тоже написанный под клиента модуль. Тут звонок обрабатывался 0 секунд.
8. Схема отправляет звонок на голосовое меню «*Осн с донабором*». Клиент в нём прождал 31 секунду, донабора не было.
9. Схема отправляет звонок на Группу «*Секретари*», где клиент прождал 12 секунд.
10. В группе вызывается одновременно 2 сотрудника «*Секретарь1*» и «*Секретарь2*» и спустя 12 секунд отвечает сотрудник «*Секретарь2*». Ответ на вызов дублируется в родительские вызовы. Получается и в группе ответил «*Секретарь2*», при вызове схемы ответил «*Секретарь2*» и на звонок по внешней линии ответил «*Секретарь2*».
Именно сохранение информации о каждой операции и их вложенности позволит просто сделать отчёты. Отчёт по голосовому меню поможет выяснить, насколько оно помогает или мешает. Построить отчёт о пропущенных сотрудниками звонках с учётом, что звонок перехватили и значит не считается пропущенным, и с учётом, что это был групповой звонок, и кто-нибудь другой взял раньше, а значит тоже звонок не пропущенный.
Такое хранение информации позволит взять каждую группу в отдельности и определить насколько она эффективно работает, построить график отвеченных и пропущенных группы по часам. Также можно проверить, насколько угадывает соединение с ответственным менеджером, анализируя переводы после соединения с менеджером.
В том числе можно проводить достаточно нетипичные исследования, например, как часто номера, которых нет в базе, набирают правильный добавочный или какой процент исходящих звонков является переадресацией на мобильный.
Что в итоге?
------------
Для обслуживания АТС не требуется специалист, с этим справляется самый обычный администратор – проверено на практике.
Для доработок не нужны специалисты с серьёзной квалификацией достаточно знаний php, т.к. уже написаны модули и для sip протокола, и для очереди, и для вызова сотрудника и другие. Есть класс обёртка для *Asterisk*. Программист для разработки модуля может (и по-хорошему должен) вызывать уже готовые модули. И знания *Asterisk* совершенно не нужны, если клиент просит добавить страницу с каким-нибудь новым отчётом. Но практика показывает, что сторонние программисты хоть и справляются, но без документации и нормального покрытия комментариями чувствуют себя неуверенно, поэтому ещё есть куда двигаться.
Модули могут:
* создавать новые возможности по обработке звонка,
* добавлять новые блоки в веб-интерфейс,
* пронаследоваться от любого из существующих модулей, переопределить функции и подменить его или просто быть слегка изменённой копией,
* добавлять свои настройки в шаблон настроек других модулей и многое другое.
Настройки АТС через API. Как описано выше, все настройки хранятся в базе и читаются в момент вызова, поэтому через API можно менять все настройки АТС. При вызове API не пересоздаётся конфигурация и не перезапускаются модули, следовательно, не важно насколько много у вас настроек и сотрудников. API запросы выполняются быстро и не блокируют друг друга.
АТС сохраняет все ключевые операции со звонками с длительностями (ожидания/разговора), вложенностями и в терминах АТС (сотрудник, группа, внешняя линия, а не канал, номер). Это позволяет строить различные отчёты под конкретных клиентов и большая часть работы – сделать удобный интерфейс.
Что будет дальше покажет время. Есть ещё много нюансов, которые стоит переделать, есть ещё много планов, но от создания 3-ей версии прошёл уже год и уже можно сказать, что идея работает. Основной минус 3-й версии – это аппаратные ресурсы, но за удобство разработки обычно всегда именно так и приходится платить. | https://habr.com/ru/post/501980/ | null | ru | null |
# Одновременная работа php 5.2 и php 5.3 на Ubuntu 12.04
Искал решение данной проблемы, так как держать устаревшую версию ubuntu 10.04 на отдельном сервере казалось излишним. Время на установку ~1 час. Установка производилась на работающем dev сервере.
Актуально для разработчиков под Drupal 6 и 7 и всех кто всё еще использует PHP 5.2.
Не смотря на то, что Drupal 7 нормально работает на PHP 5.3, Drupal 6 по-прежнему чувствует себя гораздо лучше с PHP 5.2. Хотя ядро D6 давно совместимо с PHP 5.3, у большинства разработчиков возникает невыносимая икота, когда они получают запрос о обновлении модуля до новой версии. Поэтому разработка для D7 и D6, становится более удобной при одновременной работе обоих версий PHP. (прим. таже это невероятно упрощает администрирование и сопровождение dev серверов путем исключения сервера с 5.2)
Одним из способов решения данной проблемы является использование mod\_php5 для обработки скриптов PHP 5.3, и использования FastCGI модуля при необходимости обработки скриптов под PHP 5.2. Соответственно, для Ubuntu 12.04, можно установить PHP 5.3 из репозитория и затем вручную скомпилировать и установить PHP 5.2. Установка PHP 5.3 из репозиториев является довольно простой операцией, которую вы, скорее всего, уже выполняли, так что давайте просто решим, что она выглядит примерно так:
`sudo apt-get install php5 php5-common php5-cli php5-dev php5-mysql phpmyadmin php5-pgsql phppgadmin php5-gd php5-mcrypt php5-curl php-pear libapache2-mod-php5 php5-xdebug php5-codesniffer`
Примечательно, хотя этот пост сосредоточен на том как установить PHP 5.2, обе версии работают одинаково хорошо.
**Загрузка исходного кода PHP**
Начнем с загрузки исходного кода с [предыдущих неподдерживаемых выпусков](http://php.net/releases/)
Я первоначально начал с версии 5.2.10 (эта версия была установлена на наших stage серверах) но был внеезапно остановлен ошибкой OpenSSL на этапе конфигурирования.
`/usr/include/openssl/conf.h:132:7: note: expected 'struct lhash_st_CONF_VALUE *' but argument is of type 'int *'
make: *** [ext/openssl/openssl.lo] Error 1`
для которой я не смог найти работающего фикса (относительно легко применимого), но этап выполнился с самой последней версией 5.2.17, выдав вместо этой, кучу других ошибок.
Что ж, загрузим и распакуем исходники в папку *~/Downloads/php-5.2.17*
`mkdir -p ~/Downloads/php-5.2.17
cd ~/Downloads/php-5.2.17
wget museum.php.net/php5/php-5.2.17.tar.gz
tar zxf php-5.2.17.tar.gz`
**Configure**
Пришло время приступить к конфигурированию пакета. Ниже приведен пример вызова скрипта ./configure:
**./configure**sudo ./configure \
--prefix=/usr/share/php52 \
--datadir=/usr/share/php52 \
--mandir=/usr/share/man \
--bindir=/usr/bin/php52 \
--with-libdir=lib64 \
--includedir=/usr/include \
--sysconfdir=/etc/php52/apache2 \
--with-config-file-path=/etc/php52/cli \
--with-config-file-scan-dir=/etc/php52/conf.d \
--localstatedir=/var \
--disable-debug \
--with-regex=php \
--disable-rpath \
--disable-static \
--disable-posix \
--with-pic \
--with-layout=GNU \
--with-pear=/usr/share/php \
--enable-calendar \
--enable-sysvsem \
--enable-sysvshm \
--enable-sysvmsg \
--enable-bcmath \
--with-bz2 \
--enable-ctype \
--with-db4 \
--without-gdbm \
--with-iconv \
--enable-exif \
--enable-ftp \
--enable-cli \
--with-gettext \
--enable-mbstring \
--with-pcre-regex=/usr \
--enable-shmop \
--enable-sockets \
--enable-wddx \
--with-libxml-dir=/usr \
--with-zlib \
--with-kerberos=/usr \
--with-openssl=/usr \
--enable-soap \
--enable-zip \
--with-mhash \
--with-exec-dir=/usr/lib/php5/libexec \
--without-mm \
--with-curl=shared,/usr \
--with-zlib-dir=/usr \
--with-gd=shared,/usr \
--enable-gd-native-ttf \
--with-gmp=shared,/usr \
--with-jpeg-dir=shared,/usr \
--with-xpm-dir=shared,/usr/X11R6 \
--with-png-dir=shared,/usr \
--with-freetype-dir=shared,/usr \
--with-ttf=shared,/usr \
--with-t1lib=shared,/usr \
--with-ldap=shared,/usr \
--with-mysql=shared,/usr \
--with-mysqli=shared,/usr/bin/mysql\_config \
--with-pgsql=shared,/usr \
--with-pspell=shared,/usr \
--with-unixODBC=shared,/usr \
--with-xsl=shared,/usr \
--with-snmp=shared,/usr \
--with-sqlite=shared,/usr \
--with-tidy=shared,/usr \
--with-xmlrpc=shared \
--enable-pdo=shared \
--without-pdo-dblib \
--with-pdo-mysql=shared,/usr \
--with-pdo-pgsql=shared,/usr \
--with-pdo-odbc=shared,unixODBC,/usr \
--with-pdo-dblib=shared,/usr \
--enable-force-cgi-redirect --enable-fastcgi \
--with-libdir=/lib/x86\_64-linux-gnu \
--with-pdo-sqlite=shared \
--with-sqlite=shared \
--enable-ipv6 \
--with-mcrypt \
--with-imap-ssl
Очевидно, что вы можете приспособить его к конкретным потребностям путем добавления и/или удаления соответствующих опций. Вы можете узнать больше о опциях которые вам нужны (или не нужны) в документации для PHP.
**Ошибки ./configure**
Итак, это, вероятно, не работает из коробки, не так ли? В большинстве случаев причина в отсутствующих зависимостях. Вы можете попробовать решить эту проблему одним выстрелом, если вы не слишком беспокоитесь об установке лишних библиотек и пакетов:
`sudo apt-get install libxml2-dev libpcre3-dev libbz2-dev libcurl4-openssl-dev libdb4.8-dev libjpeg-dev libpng12-dev libxpm-dev libfreetype6-dev libmysqlclient-dev postgresql-server-dev-9.1 libt1-dev libgd2-xpm-dev libgmp-dev libsasl2-dev libmhash-dev unixodbc-dev freetds-dev libpspell-dev libsnmp-dev libtidy-dev libxslt1-dev libmcrypt-dev`
Вы также можете исправлять ошибки отсутствующих зависимостей одну за другой, и устанавливать только те пакеты, которые действительно необходимы.
Давайте рассмотрим некоторые из возможных ошибок, (вы можете перейти к следующему разделу, если скрипт ./configure выполнен без ошибок и получено сообщение
> Thank you for using PHP at the end of its execution
*configure: error: xml2-config not found. Please check your libxml2 installation.*
Эта ошибка предлагает нам проверить наличие пакета libxml2. В действительности же, это значит, что отсутствует его dev версия.
Давайте найдем доступные пакеты, которые могут помочь решить данную проблему:
`$ apt-cache search libxml2 | grep dev
libcroco3-dev - Cascading Style Sheet (CSS) parsing and manipulation toolkit
libxml++2.6-dev - C++ interface to the GNOME XML library (libxml2)
libxml2-dev - Development files for the GNOME XML library
libgdome2-cpp-smart-dev - C++ bindings for GDome2 DOM implementation
libgdome2-dev - Development files for libgdome2
libgdome2-ocaml-dev - OCaml bindings for GDome2 DOM implementation
libgtkmathview-dev - rendering engine for MathML documents
libsp-gxmlcpp-dev - S+P C++ wrapper for Gnome libxml2/libxslt`
Нас интересует *libxml2-dev*, устанавливаем его:
`sudo apt-get install libxml2-dev`
Такая же процедура применяется для всех отсутствующих библиотек, поэтому я приведу только окончательные команды установки:
**fixes**
> configure: error: Could not find pcre.h in /usr
>
> `sudo apt-get install libpcre3-dev`
>
>
>
> configure: error: Please reinstall the BZip2 distribution
>
> `sudo apt-get install libbz2-dev`
>
>
>
> configure: error: Please reinstall the libcurl distribution — easy.h should be in /include/curl/
>
> `sudo apt-get install libcurl4-openssl-dev`
>
>
>
> configure: error: DBA: Could not find necessary header file(s).
>
> checking for db4 major version… configure: error: Header contains different version
>
> `sudo apt-get install libdb4.8-dev`
>
>
>
> configure: error: libjpeg.(a|so) not found.
>
> `sudo apt-get install libjpeg-dev`
>
>
>
> configure: error: libpng.(a|so) not found.
>
> `sudo apt-get install libpng12-dev`
>
>
>
> configure: error: libXpm.(a|so) not found.
>
> `sudo apt-get install libxpm-dev`
>
>
>
> configure: error: freetype.h not found.
>
> `sudo apt-get install libfreetype6-dev`
>
>
>
> You need to install postgresql-server-dev-X.Y for building a server-side extension or libpq-dev for building a client-side application.
>
> configure: error: Cannot find libpq-fe.h. Please specify correct PostgreSQL installation path
>
> `sudo apt-get install postgresql-server-dev-9.1`
>
>
>
> checking for FreeType 1 support… no — FreeType 2.x is to be used instead
>
> configure: error: Your t1lib distribution is not installed correctly. Please reinstall it.
>
> `sudo apt-get install libt1-dev`
>
>
>
> configure: error: Unable to find gd.h anywhere under /usr
>
> `sudo apt-get install libgd2-xpm-dev`
>
>
>
> configure: error: Unable to locate gmp.h
>
> `sudo apt-get install libgmp-dev`
>
>
>
> configure: error: Cannot find MySQL header files under /usr.
>
> Note that the MySQL client library is not bundled anymore!
>
> `sudo apt-get install libmysqlclient-dev`
>
>
>
> configure: error: sasl.h not found!
>
> `sudo apt-get install libsasl2-dev`
>
>
>
> configure: error: Please reinstall libmhash — I cannot find mhash.h
>
> `sudo apt-get install libmhash-dev`
>
>
>
> checking for unixODBC support… configure: error: ODBC header file '/usr/include/sqlext.h' not found!
>
> `sudo apt-get install unixodbc-dev`
>
>
>
> configure: error: Directory /usr is not a FreeTDS installation directory
>
> `sudo apt-get install freetds-dev`
>
>
>
> configure: error: Cannot find pspell
>
> `sudo apt-get install libpspell-dev`
>
>
>
> configure: error: SNMP sanity check failed. Please check config.log for more information.
>
> `sudo apt-get install libsnmp-dev`
>
>
>
> configure: error: Cannot find libtidy
>
> `sudo apt-get install libtidy-dev`
>
>
>
> configure: error: xslt-config not found. Please reinstall the libxslt >= 1.1.0 distribution
>
> `sudo apt-get install libxslt1-dev`
>
>
>
> configure: error: mcrypt.h not found. Please reinstall libmcrypt.
>
> `sudo apt-get install libmcrypt-dev`
>
>
>
> configure: error: Cannot find OpenSSL's libraries
>
> Добавьте следующее в опции ./configure:
>
> --with-libdir=/lib/x86\_64-linux-gnu
>
>
>
> configure: error: You've configured extension pdo\_sqlite to build statically, but it depends on extension pdo, which you've configured to build shared. You either need to build pdo\_sqlite shared or build pdo statically for the build to be successful.
>
> Добавьте следующее в опции ./configure
>
> `--with-pdo-sqlite=shared
>
> --with-sqlite=shared`
>
>
**Make**
Все настроено правильно и без ошибок? Тогда пришло время для компиляции (и чашечки кофе во время его выполнения):
`sudo make`
Теперь можно, попивая кофе, ждать приближение ошибок.
**Ошибки make**
Да, весьма вероятно, что здесь все может пойти наперекосяк.
Вот две ошибки и один ворнинг, которые вы всего скорее всего получите:
**fixes**
> ext/openssl/.libs/xp\_ssl.o: In function `php\_openssl\_setup\_crypto':
>
> ext/openssl/xp\_ssl.c:357: undefined reference to `SSLv2\_server\_method'
>
> ext/openssl/xp\_ssl.c:337: undefined reference to `SSLv2\_client\_method'
>
>
>
> Это связано с [багом #54736](http://search.twitter.com/search?q=%2354736) которые лекго решаются применением патча прикрепленного к этому [багрепорту](http://-bugs.php.net/patch-display.php?bug_id=54736&patch=debian_patches_disable_SSLv2_for_openssl_1_0_0.patch&revision=latest)
>
>
>
> Скачайте этот патч в папку *~/Downloads/php-5.2.17* и выполните следующее:
>
> `patch -p1 < debian_patches_disable_SSLv2_for_openssl_1_0_0.patch.patch`
>
>
>
> Вы должны увидеть сообщение об успешном применении патча, наподобии этого:
>
> `patching file ext/openssl/xp_ssl.c
>
> Hunk #1 succeeded at 332 (offset 4 lines).
>
> Hunk #2 succeeded at 354 (offset 4 lines).
>
> Hunk #3 succeeded at 583 (offset -50 lines).
>
> Hunk #4 succeeded at 819 (offset -98 lines).`
>
>
>
> ext/gmp/gmp.c: In function ‘zif\_gmp\_random’:
>
> ext/gmp/gmp.c:1399:69: error: ‘\_\_GMP\_BITS\_PER\_MP\_LIMB’ undeclared (first use in this function)
>
> ext/gmp/gmp.c:1399:69: note: each undeclared identifier is reported only once for each function it appears in
>
>
>
> Пришло время исправить [баг #50990](http://search.twitter.com/search?q=%2350990)
>
> В одном из комментариев susan dot smith dot dev at gmail dot com предлагается следующее работающее решение, которое делает магию:
>
>
>
>
> > Я решила проблему заменой устаревшей постоянной определения *\_\_GMP\_BITS\_PER\_MP\_LIMB* на *GMP\_LIMB\_BITS*, которая присутствует во всех предыдущих версиях и MPIR определяет тоже.
>
>
>
>
>
> Вам нужно отредактировать файл *ext/gmp/gmp.c* и заменить \_\_GMP\_BITS\_PER\_MP\_LIMB на GMP\_LIMB\_BITS. В моем случае это было строке 1399.
>
>
>
> ext/zip/lib/.libs/zip\_dirent.o: In function `memset':
>
> /usr/include/x86\_64-linux-gnu/bits/string3.h:82: warning: memset used with constant zero length parameter; this could be due to transposed parameters
>
>
>
> Последний [баг #53568](http://-bugs.php.net/bug.php?id=53568) который довольно легко исправляется: откройте файл *ext/zip/lib/zip\_dirent.c* и замените строкй 478:
>
> `memset(&tm, sizeof(tm), 0);`
>
> на
>
> `memset(&tm, 0, sizeof(tm));`
>
> Больше ошибок нет!
>
>
**Install**
Простейший вариант установки вашей блеcтящей новой версии PHP 5.2 является следующая команда:
`sudo make install`
Кроме того, если вы планируете повторить ту же установку еще раз на других машинах, или просто хотите сохранить файл пакета установки на будущее, вы можете запустить:
`sudo checkinstall`
которая вместе с установкой PHP? также создаст deb пакет в текущем каталоге.
Теперь, какой бы путь вы не выбрали, у вас установленЗРЗ 5.2 в */usr/bin/php52*
**Конфигурационные файлы Apache**
Конфигурационный каталог */etc/php52/apache2/* уже должен быть создан в процессе установки (создайте его, если он отсутствует). Теперь нужно настроить PHP 5.2 на использование тех же расширений и модулей, которые использует PHP 5.3,
`sudo ln -s /etc/php5/conf.d /etc/php52
sudo ln -s /etc/php5/cli /etc/php52`
Скопируйте файл *php.ini-recommended* в новый каталог (который будет определен в следующем шаге)
`sudo cp php.ini-recommended /etc/php52/apache2/php.ini`
и если нужно, внесите необходимые настройки.
**Apache и FastCGI**
Следующая вещь, которую мы сделаем, будет настройка apache для запуска PHP 5.2 используя FastCGI. Начнем установку *fastcgi* модуля:
`sudo apt-get install libapache2-mod-fastcgi`
Убедитесь, что все требуемые модули включены и перезапустите Apache:
`sudo a2enmod cgi fastcgi actions
sudo service apache2 restart`
Создайте исполняемый скрипт *php52-cgi* для запуска FastCGI версии PHP и поместите его в /usr/lib/cgi-bin/:
`#!/bin/sh
PHPRC="/etc/php52/apache2/"
export PHPRC
PHP_FCGI_CHILDREN=4
export PHP_FCGI_CHILDREN
PHP_FCGI_MAX_REQUESTS=5000
export PHP_FCGI_MAX_REQUESTS
exec /usr/bin/php52/php-cgi`
*PHPRC* этот параметр указывает на php.ini
*PHP\_FCGI\_CHILDREN* количество потоков
*PHP\_FCGI\_MAX\_REQUESTS* лимит запросов
Вы можете узнать больше об этом на сайте [FastCGI](http://www.fastcgi.com/drupal/node/10).
Дайте права на запуск:
`sudo chmod +x /usr/lib/cgi-bin/php52-cgi`
Наконец создайте новый файл */etc/apache2/php52.conf* который будет использоваться для виртуальных хостов, которые требую использования PHP 5.2:
`# Include file for virtual hosts that need to run PHP 5.2
SetHandler application/x-httpd-php5`
ScriptAlias /php52-cgi /usr/lib/cgi-bin/php52-cgi
Action application/x-httpd-php5 /php52-cgi
AddHandler application/x-httpd-php5 .php
*FilesMatch* переопределяет обработчик php файлов.
*ScriptAlias* задет путь к CGI скрипту
*AddHandler* регистрирует новый обработчик
*Action* активизирует CGI-скрипт для работы с файлами переданных от обработчика.
**Почти всё!**
Осталось только одно: для всех хостов, для которых вы хотите использовать PHP 5.2 нужно добавить в конфигурационный файл следующую строку:
`Include php52.conf`
и перегрузить новую конфигурацию:
`sudo service apache2 reload`
Поздравляю! Теперь у вас есть есть сервер с одновременно работающими версиями PHP 5.2 и PHP 5.3!
P.S. Все опечятки и замечания прошу отправлять в ПМ. v | https://habr.com/ru/post/176147/ | null | ru | null |
# Способ конфигурации проектов Yii от ГлавВеб
Привет всем любителям фреймворка Yii!
В цикле статей, хочу поделиться нашим подходом к разработке проектов на Yii. Возможно кому-то наши идеи будут полезны, возможно для кого-то это будет пища для размышлений, ну а возможно кому-то это нафиг не надо :). Я ни в коем случае не претендую на уникальность, не утверждаю, что делать надо именно так как это делаем мы.
Первый пост будет о конфигурации проекта, понимаю, тема избитая, ну куда ж без нее.
И так, начнем. Первым делом разберем входной скрипт (index.php). Вот как он выглядит у нас:
```
php
$rootPath = dirname(__FILE__);
/**
* Define config
*/
$env = null;
$envFile = $rootPath . '/.env';
if (is_file($envFile)) {
$env = trim(file_get_contents($envFile));
}
$configFile = $rootPath . '/application/config/production.php';
if (!empty($env)) {
$configFile = $rootPath . '/application/config/' . $env . '.php';
if (!file_exists($configFile)) {
die('Config file is not found.');
}
}
$config = require $configFile;
/**
* Create and run application
*/
$libraryPath = $rootPath . '/library';
require_once $libraryPath . '/yii/yii.php';
$autoloader = function($class)
{
global $libraryPath;
$path = $libraryPath . '/'
. implode(preg_split('/[_\\\]/', (string)$class, -1, PREG_SPLIT_NO_EMPTY), DIRECTORY_SEPARATOR)
. '.php';
if (is_file($path)) {
include_once $path;
}
};
Yii::registerAutoloader($autoloader, true);
Yii::createWebApplication($config)-run();
```
Первое, что мы здесь делаем — определяем конфигурацию приложения. Путь к конфигу получаем исходя из содержания файлика ".env" который лежит тут же в корне. Если этого файла нет, значит конфиг — «production». Т.е. файл ".env" должен быть только на вашей машине, на боевой сервер его не заливаем, ставим в игнор и т.д. Для чего все это нужно? — для разделения конфигурации продакшен сервера и сервера разработчика.
Плюс в конфиге, я так же определяю соответствующие константы. Например, для дев сервера, это:
```
define('YII_DEBUG', true);
define('YII_TRACE_LEVEL', 3);
define('YII_ENABLE_ERROR_HANDLER', true);
define('YII_ENABLE_EXCEPTION_HANDLER', true);
```
Почему в файле конфига, а не в «index.php»? — потому, что значения констант так же зависят от окружения.
Далее, для удобства, можно сделать слияние конфигураций. Т.е. выделить один базовый (main) и конкретные (production, dev, test и т. д.) которые определяют особенности окружения.
В таком случае содержание папки «config» будет примерно таким:
— main.php // основные настройки приложения
— production.php // отличия для продакшен сервера
— dev.php // отличия для сервера разработчика
Пример, содержания файла «dev.php»:
```
define('YII_DEBUG', true);
define('YII_TRACE_LEVEL', 3);
define('YII_ENABLE_ERROR_HANDLER', true);
define('YII_ENABLE_EXCEPTION_HANDLER', true);
return array_replace_recursive(
require dirname(__FILE__) . '/main.php',
array(
'components' => array(
'db' => array(
// Настройки для базы данных
),
),
)
);
```
Отмечу, что слияние мы делаем, через нативную PHP функцию «array\_replace\_recursive()», а не по средствам фреймоврка «CMap::mergeArray()» (как это советует кукбук). Помним, что на этот момент мы ещё не подключили библиотеку Yii. А не подключили, потому, что это вызовет конфликт констант определённых в нашем конфиге и констант определённых в yii.php.
Если посмотреть на содержание «index.php», то можно заметить, что мы немного отшли от стандартного нейминга корневых директорий принятых в Yii. В корне у нас всего 3 папки:
— application // тоже, что и protected
— library // здесь лежат используемые библиотеки, в том числе и Yii
— public // файлы которые доступны из веба, например css, js, изображения
— assest // папка для assets файлов
По большей части, такая структура, это дело привычки оставшейся из Zend-а.
Для того, что бы наши assets складывались в «public/assets» в конфиге в компоненте «assetManager» нужно переопределить свойства «basePath» и «baseUrl».
Смотрим далее. В «index.php» мы определяем и регистрируем дополнительный автолоадер. Зачем? Для того, что бы безболезненно подключать дополнительные библиотеки из директории «library». Т.е. наш автолоадер ищет файл в папке «library» по имени соответствующего класса и подключает его. Допустим для класса «Zend\_Paginator» путь будет «library/Zend/Paginator.php». Так же он понимает и неймспейсы: для класса «Zend\Paginator\Paginator» путь будет соответственно «library/Zend/Paginator/Paginator.php». Не беспокойтесь, это не повлияет на производительность, т.к. наш автолоадер будет срабатывать после автолоадера Yii. Это поведение определяется второй переменной в «Yii::registerAutoloader()».
Ну и в конце запускаем приложение с массивом наших конфигурационных данных.
На этом сегодня всё. Всем приятного дня!
P.S. На мой взгляд, хороший вариант разделения конфигов (через APPLICATION\_ENV), предлагает suver — [habrahabr.ru/post/146473](http://habrahabr.ru/post/146473/). Основное отличие моего способа в том, что не обязательно нужно делать настройки сайта в апаче, это удобно на тот случай когда сайт мы кладем в папку локалхоста (http://localhost/mysite) | https://habr.com/ru/post/150583/ | null | ru | null |
# Source Maps: быстро и понятно
Механизм Source Maps используется для отображения исходных текстов программы на сгенерированные на их основе скрипты. Несмотря на то, что тема не нова и по ней уже написан ряд статей (например [эта](https://medium.com/@trungutt/yet-another-explanation-on-sourcemap-669797e418ce), [эта](https://www.html5rocks.com/en/tutorials/developertools/sourcemaps/) и [эта](https://www.bugsnag.com/blog/source-maps)) некоторые аспекты все же нуждаются в прояснении. Представляемая статья представляет собой попытку упорядочить и систематизировать все, что известно по данной теме в краткой и доступной форме.
В статье Source Maps рассматриваются применительно к клиентской разработке в среде популярных браузеров (на примере, DevTools Google Chrome), хотя область их применения не привязана к какому-либо конкретному языку или среде. Главным источникам по Source Maps является, конечно, [стандарт](https://sourcemaps.info/spec.html), хотя он до сих пор не принят (статус — proposal), но, тем не менее, широко поддерживается браузерами.
Работа над Source Maps была начата в конце нулевых, первая версия была создана для плагина Firebug Closure Inspector. Вторая версия вышла в 2010 и содержала изменения в части сокращения размера map-файла. Третья версия разработана в рамках сотрудничества Google и Mozilla и предложена в 2011 (последняя редакция в 2013).
В настоящее время в среде клиентской разработки сложилась ситуация, когда исходный код почти никогда не интегрируется на веб-страницу непосредственно, но проходит перед этим различные стадии обработки: минификацию, оптимизацию, конкатенацию, более того, сам исходный код может быть написан на языках требующих транспиляции. В таком случае, для целей отладки необходим механизм позволяющий наблюдать в дебаггере именно исходный, человекочитаемый код.
Для работы Source Maps необходимы следующие файлы:
* собственно сгенерированный JavaScript-файл
* набор файлов с исходным кодом использовавшийся для его создания
* map-файл отображающий их друг на друга
#### Map-файл
Вся работа Source Maps основана на map-файле, который может выглядеть, например, так:
```
{
"version":3,
"file":"index.js",
"sourceRoot":"",
"sources":["../src/index.ts"],
"names":[],
"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,SAAS,SAAS;IACd,MAAM,OAAO,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;",
"sourcesContent": []
}
```
Обычно, имя map-файла складывается из имени скрипта, к которому он относится, с добавлением расширения ".map", bundle.js — bundle.js.map. Это обычный json-файл со следующими полями:
* «version» — версия Source Maps;
* «file» — (опционально) имя сгенерированного файла, к которому относится текущий map-файл;
* «sourceRoot» — (опционально) префикс для путей к файлам-исходникам;
* «sources» — список путей к файлам-исходникам (разрешаются аналогично адресам src тега script, можно использовать file://.);
* «names» — список имен переменных и функций, которые подверглись изменению в сгенерированном файле;
* «mappings» — координаты отображения переменных и функций исходных файлов на сгенерированный файл в формате Base64 VLQ;
* «sourcesContent» — (опционально) в случае self-contained map-файла список строк, каждая из которых содержит исходный текст файла из sources;
#### Загрузка Source Maps
Для того, чтобы браузер загрузил map-файл может быть использован один из следующих способов:
* JavaScript-файл пришел с HTTP-заголовком: SourceMap: (ранее использовался ныне устаревший X-SourceMap: )
* в сгенерированном JavaScript-файле есть особый комментарий вида:
```
//# sourceMappingURL= (для CSS /\*# sourceMappingURL= \*/)
```
Таким образом, загрузив map-файл браузер подтянет и исходники из поля «sources» и с помощью данных в поле «mappings» отобразит их на сгенерированный скрипт. Во вкладке Sources DevTools можно будет найти оба варианта.
Для указания пути может использоваться пседопротокол file://. Также, в может быть включено все содержимое map-файла в кодировке Base64. В терминологии Webpack подобные Source Maps названы inline source maps.
```
//# sourceMappingURL=data:application/json;charset=utf-8;base64,
```
**Ошибки загрузки Source Maps**
*Следует заметить, что map-файлы не являются частью веб-страницы, поэтому вы не увидите информации об их загрузке во вкладке Network DevTools. Тем не менее, если в сгенерированном файле находится ссылка на несуществующий map-файл, в Console DevTools будет предупреждение вида: «DevTools failed to load SourceMap: ...». Также при наличии ссылки на несуществующий исходник, вместо него будет сообщение вида: «Could not load content for ...».*
#### Self-contained map-файлы
Код файлов-исходников можно включить непосредственно в map-файл в поле «sourcesContent», при наличии этого поля необходимость в их отдельной загрузке отпадает. В этом случае названия файлов в «sources» не отражают их реального адреса и могут быть совершенно произвольными. Именно поэтому, вы можете видеть во вкладке Sources DevTools такие странные «протоколы»: webpack://, ng:// и т.д
#### Mappings
Сущность механизма отображения состоит в том, что координаты (строка/столбец) имен переменных и функций в сгенерированном файле отображаются на координаты в соотвествующем файле исходного кода. Для работы механизма отображения необходима следующая информация:
(#1) номер строки в сгенерированном файле;
(#2) номер столбца в сгенерированном файле;
(#3) индекс исходника в «sources»;
(#4) номер строки исходника;
(#5) номер столбца исходника;
Все эти данные находятся в поле «mappings», значение которого — длинная строка с особой структурой и значениями закодированными в Base64 VLQ.
Строка разделена точками с запятой (;) на разделы, соответствующие строкам в сгенерированном файле (#1).
Каждый раздел разделен запятыми (,) на сегменты, каждый из которых может содержать 1,4 или 5 значений:
* номер столбца в сгенерированном файле (#2);
* индекс исходника в «sources» (#3);
* номер строки исходника (#4);
* номер столбца исходника (#5);
* индекс имени переменной/функции из списка «names»;
Значения номеров строк и столбцов — относительные, указывают смещение относительно предыдущих координат и только первое от начала файла или раздела.
Каждое значение представляет собой число в формате Base64 VLQ. VLQ (Variable-length quantity) представляет собой принцип кодирования сколь угодно большого числа с помощью произвольного числа двоичных блоков фиксированной длины.
В Source Maps используются шестибитные блоки, которые следуют в порядке от младшей части числа к старшей. Старший 6-й бит каждого блока (continuation bit) зарезервирован, если он установлен, то за текущим следует следующий блок относящийся к этому же числу, если сброшен — последовательность завершена.
Поскольку в Source Maps значение должно иметь знак, для него также зарезервирован младший 1-бит (sign bit), но только в первом блоке последовательности. Как и ожидается, установленный sign бит означает отрицательное число.
Таким образом, если число можно закодировать единственным блоком, оно не может быть по модулю больше 15 (11112), так как в первом шестибитном блоке последовательности два бита зарезервированы: continuation бит всегда будет сброшен, sign бит будет установлен в зависимости от знака числа.
Шестибитные блоки VLQ отображаются на кодировку Base64, где каждой шестибитной последовательности соответствует определенный символ ASCII.
Декодируем число mE. Инверсируем порядок, младшая часть последняя — Em. Декодируем числа из Base64: E — 000100, m — 100110. В первом отбрасываем старший continuation бит и два лидирующих нуля — 100. Во втором отбрасываем старший continuation и младший sign биты (sign бит сброшен — число положительное) — 0011. В итоге получаем 100 00112, что соответствует десятичному 67.
Можно и в обратную сторону, закодируем 41. Его двоичный код 1010012, разбиваем на два блока: старшая часть — 10, младшая часть (всегда 4-битная) — 1001. К старшей части добавляем старший continuation бит (сброшен) и три лидирующих нуля — 000010. К младшей части добавляем старший continuation бит (установлен) и младший sign бит (сброшен — число положительное) — 110010. Кодируем числа в Base64: 000010 — C, 110010 — y. Инверсируем порядок и, в итоге, получаем yC.
Для работы с VLQ весьма полезна одноименная [библиотека](https://github.com/Rich-Harris/vlq). | https://habr.com/ru/post/509250/ | null | ru | null |
# Добавляем функциональность Razor Pages в стандартный .NET
Razor Pages — новая фича, появившаяся в Core.Net 2.0. Razor Page — это страница, состоящая из стандартной разметки (View) и бэкенд класса. В каком то смысле напоминает Web Forms только без поддержки сохранения состояния. Преимущество такого решения очевидно — мы избавляемся от ненужной прослойки — модели страницы (модель данных в виде например Entity это само собой). Бэкенд страницы является и контроллером и моделью — классика ООП — инкапсуляция данных и методов работы с ними в одном объекте. В конце концов модель страницы — это просто класс, нет никаких причин почему этим классом не может быть контроллер.
Иными словами, Razor Pages — более вменяемое решение для веба чем MVC, теперь мы имеем дело с традиционным и логичным понятием «страница» а не с контролерами и моделями разбросанными по всему проекту. Но поскольку .NET будет развиваться по направлению Core.Net то вряд ли Razor Page появятся в стандартном фреймворке, несмотря на то что ближайшие годы большинство проектов будет оставаться на стандартном .NET. Тем не менее можно изобразить функциональность Razor Pages и на стандартном фреймворке.
Решение на самом деле выглядит достаточно тривиально — нужно добавить в контролер следующую конструкцию:
```
protected override void OnActionExecuting(ActionExecutingContext Context)
{
UpdateModel(this);
}
```
Метод OnActionExecuting -событие жизненного цикла который вызывается перед выполнением метода контролера (имеется ввиду обработчик запроса — Action).
UpdateModel выполняет непосредственно привязку параметров запроса к свойствам (properties) модели — в данном случае свойствам класса контроллера.
Дополнительное удобство — теперь нет необходимости вообще принимать явно параметры ни типа Model ни какие другие. Хотя ничего не мешает это делать, если параметр — простой id, который будет использовать чисто как локальная переменная, но привязка параметров как свойств контролера необходима например, если нужно обеспечить персистентность страницы, о чем пойдет речь дальше.
Простой пример:
У нас есть обычная форма логина с двумя полями.
Приводить разметку нет смысла приведу только код контроллера
```
public class AccountController : Controller
{
public string username{ get; set; }
public string userpass{ get; set; }
[HttpPost]
public ActionResult OnLogin( )
{
//некая функция проверки в БД
checklogin(username,userpass);
return View("Index",this);
}
protected override void OnActionExecuting(ActionExecutingContext Context)
{
UpdateModel(this);
}
}
```
Как видим, в момент срабатывания события входные данные уже привязаны и готовы к использованию.
Разумеется, надо иметь ввиду что теперь возвращать как ActionResult тоже нужно контроллер ну и в шаблоне прописать имя класса контролера — типа @Model AccountController.
Как следствие такого решения упрощается и задача сохранения состояния страницы между запросами. Допустим у вас есть страница с некоей таблицей, фильтром сортировкой по столбцам и пагинацией.
Вы кликаете по фильтру модель возвращается в представление и все хорошо, но когда кликните сортировку фильтр естественно сбросится. Пагинатор сбросит и сортировку и фильтр. В WebForms состояние страницы сохранялось автоматически, в MVC приходится применять разные громоздкие решения, например склеивать все параметры и гонять их по каждому запросу, то есть на ссылку сортировки нужно повесить все параметры которые пришли перед этим с фильтра.
Подобные затруднения являются одной из причин SPA и прочего яваскриптового безумия с перетаскиванием логики и данных в браузер с вытекающими из этого тормозами браузера (особенно мобильных девайсах), прыгающими и дергающимися за каждым движением мышки страницами и увеличением трудоемкости и стоимости работ — ведь бэкенд то все равно писать в том или ином виде, упаковывать распаковывать данные пересылаемые через ajax, плюс callbac hell, усложнения отладки и так далее, и все это без практической пользы для посетителей сайта которым нет дела как написана страница.
Наиболее логичным решением является сохранение состояния страницы в сессии. Поскольку у нас все необходимые параметры уже под руками в виде свойств контроллера, все что нужно — это переопределить метод OnActionExecuted, который вызывается после обработки запроса, и упаковать нужные свойства в сессию (ключ сессии очевидно должен указывать на имя контролера).
```
protected override void OnActionExecuted (ActionExecutedContext Context)
{
//сохраняем данные
}
```
Восстанавливаются параметры из сессии в конструкторе контролера или перед вызовом UpdateModel(this). Когда придет запрос, например сортировки то новые параметры изменятся а остальное останется нетронутым и представление будет отображено в том же виде как было отправлено.
Такое решение имеет еще одно удобство — к примеру, пользователь отсортировал таблицу, и решил какой то элемент отредактировать, открывши для этого другую страницу. Естественно он хочет вернутся в то состояние списка которое оставил а так как состояние страницы у нас в сессии, то страница восстановится автоматически. Нет никакой необходимости, как часто делают, передавать весь «вареник» параметров в страницу редактирования и обратно. Если сохранять состояние между страницами нет необходимости то состояние страницы можно хранить не в сессии а в TempData.
Надеюсь данные «лайфхаки» хоть и выглядят тривиально, будут полезны новичкам пока они не подсмотрели в интернете более неудобных и громоздких решений и решили что других не бывает. | https://habr.com/ru/post/464831/ | null | ru | null |
# Figma — простое решение для дизайнера, сложное решение для верстальщика
Если вы работаете в области web-разработки, то рано или поздно, вам суждено будет познакомиться с Figma. Смиритесь с этим фактом и начинайте изучать. Я же попробую описать данный продукт, с точки зрения повседневного пользователя.
Для начала стоит упомянуть о парочке приятных моментов, за которые дизайнеры любят использовать Figma. Что ж приступим:
**Самый неоспоримый плюс – халява**
В отличие от повседневных продуктов дизайна, будь то Adobe пакет (Photoshop, Illustrator, Adobe XD … ), или Bohemian Coding (Sketch) эта программа условно бесплатная для пользователей. Разумеется за определенные финансовые вливания Вы получите дополнительные плюшки, но и без оных, продукт выглядит вполне достойно. Будем надеяться, что данная политика не поменяется, и правообладатели не начнут закручивать гайки. Аминь.
**Наличие Мультиплеера**
Для тех кто не в теме – это способность одновременно работать над одним проектом нескольким людям. И когда я написал одновременно, то это действительно так, я как верстальщик, вижу, как дизайнер(или даже дизайнеры) правят проект realtime прям на своем мониторе. Выглядит этот эффект как teamViewer. Дизайнер больше не хранит свои макеты локально, теперь это всё живет в облаках. Не нужно больше обмениваться скриншотами с менеджером, процесс создания проекта стал публичным, необходим только браузер с нормальной скоростью Интернета.
**Задействован принцип кроссплатформенности**
Стала не важна операционная система (Windows, MacOS, Linux) верстальщика и дизайнера. Они смогут работать над одним проектом без проблемы несовместимости ОС.
**Удобные быстрые клавиши**
Если вы уже привыкли работать с графическими редакторами посредством hot key для вас не составит труда быстро освоиться с новым функционалом.
Программа имеет довольно толковое описание клавиш быстрого вызова, и к тому же они сильно повторяют функционал клавиш Photoshop или Sketch, за что авторам отдельное спасибо. Все ведь ленивые и не хотят опять обучаться, как вызвать элемент Pen.
**Возможность работы с векторной графикой**
В Figma можно работать не только с растровыми изображениями, но и с векторной графикой, экспортируя и импортируя готовые решения в формат SVG. Эта фишка очень полезна, особенно если вы беспокоитесь о производительности своего web проекта, который можно очень сильно ухудшить, если вставлять не тот формат, или не того размера.
**Возможность создания компонентов**
Да, для верстальщиков поясню, что в дизайне тоже есть компоненты. И им тоже даровано свойство Наследования (привет [ООП](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)). К примеру можно создать типовую кнопку, а потом “продублировать ” её по всем артбордам. И потом, когда от заказчика придёт желание перекрасить все кнопки в розовый горошек, это всё решается за пару кликов (разумеется, если дизайнер умеет данным свойством пользоваться)
**Подключаемые плагины**
В Фигме есть функционал настраиваемых плагинов, и их там довольно много.
Представлены как продукты частных компаний, так и реализации open source сообщества. Пока что, из-за частых обновлений софта можно увидеть забагованость функционала, но я уверен, что это поправят.
---
А теперь о негативных моментах, с которыми сталкиваются пользователи Figma в процессе работы, ну или о том, чего так не хватает, а очень надо.
**Проблема с определением фактических размеров элементов и расстояния между ними**
К сожалению, в процессе верстки постоянно сталкиваюсь с проблемою узнать реальное расстояние между элементами. Особенно плохо обстоят дела, если дизайнер забыл очистить картинки от прозрачного фона (transparent background) или некорректно прописал межстрочный интервал для текста.
Иногда эту проблему можно решить, выбрав элемент отсчета, а затем с зажатой клавишей Alt нажать на элемент, расстояние до которого необходимо узнать, но это не всегда работает.
**Перекрытие и заблокированные слои**
Очень часто происходят случаи, что получив ссылку на макет сайта, верстальщик не может изъять нужные элементы дизайна по причине того, что они перекрыты вышестоящими слоями, или же эти слои вообще заморожены.
Скорее всего, ваш дизайнер вам не доверяет, и вы получите от него макет с правами “read-only”, чтоб ничего там не поломали. К сожалению, функционал рабочего пространства макета ссылки очень урезан и тогда приходится создавать новый проект и переносить туда весь дизайн, только чтоб уже самому отключить мешающие слои, ну или решайте свои вопросы через общение и просьбы о помощи.
**Проблемы с текстом**
* Первое, что сразу бросится в глаза, получив новый проект — вы не узнаете какие шрифты там используются до того момента пока не проклацаете все слоя с текстами. Не понимаю, почему это пока не реализовали, к примеру, как в Avocode
* Также сталкивался с забавными случаями, что во вкладке Code написано к примеру:
```
font-family: Roboto;
font-style: normal;
font-weight: normal;
```
а если открыть данный шаблон уже в режиме дизайнера, то уже можно наблюдать, что там Roboto Bold задействовано.
Семейство шрифта вроде ж одно и то, а только в процессе верстки его всё равно через свойство @font-face отдельно подключать надо, иначе эффекта как на макете не получить. И пока не затяните на свой проект, вы этого не узнаете (и можно долго играться со свойством font-width).
Если же вы работаете не только с открытыми Google шрифтами, но и используете личный подключаемый набор, а он ещё и кирилличный, то будьте готовы к приключениям.
* Отдельные танцы с бубном начинаются, если ваш дизайнер очень любит градиентные шрифты с тенями и обводками.
[](https://habrastorage.org/webt/rp/0w/ro/rp0wrod8fyvpx66jxdmh_gm_da0.jpeg)
Тут в код, предоставляемый Фигмой, можно вообще не смотреть. Как вариант решения проблемы вы можете сохранить данный текст в SVG (иногда это дешевле чем импортировать к странице новый шрифт), ну а если всё-таки будет необходимость заниматься решением данной проблемы на серьезном уровне, то опять забирайте макет на свой личный проект.
[](https://habrastorage.org/webt/gx/nf/zb/gxnfzbeubdgn_4v6_nvl-2xlyyc.jpeg)
Тут правда у меня возникли вопросы, почему возле ползунков смены значения градиента разработчики поленились вывести хотя бы процент текущего значения, не говоря уже про угол направления градиента, и мне как верстальщику приходиться самому угадывать какое значение надо будет поставить в background: linear-gradient, а потом починить это через [background-clip: text;](https://caniuse.com/#search=background-clip) Собственно свойство [text-stroke](https://caniuse.com/#search=text-stroke) в коде фигмы я пока тоже не встречал, хотя возможно это связано что оно ещё не во всех браузерах зеленое.
\*Делитесь своими мнениями в комментариях, почему это может быть так сложно реализовать?
**Figma является облачным продуктом**
Иначе говоря, если у Вас нету связи с глобальной паутиной на хороших скоростях, возвращайтесь в свою пещеру к настенной живописи, или переходите на оффлайновые продукты. Тут Фигма увы бессильна и Ваше творчество так и останется недоступно для общественности, и не важно, что сроки горят, и завтра сдавать проект.
**Работа в фигме расхолаживает дизайнера**
Возможно, конечно, это лично моё субъективное мнение, но макеты, которые отдаются дизайнерами под верстку сайтов, ниже качеством по сравнению с макетами, выполненными в Photoshop или Sketch. (\* я прям чувствую, что сейчас у кого-то подгорело)
* Там дизайнер посчитал, что называть слои уже не имеет смысла. Пхх там ведь и так всё видно. Неважно, что при экспорте файлов у верстальщика будет Group1.png Group1(1).png….и т.д. Разберётся.
* Там слои забыл объединять в группы, и что б нормально забрать картинку, как она выглядит, например, с наложенной маской, опять надо забирать на свой проект, и самостоятельно группировать.
* Ещё классика, это вместо определенно цвета, использовать изменение свойства прозрачности (opacity) когда это целесообразно, и нет.
И ладно, если с текстом это ещё может нормально прокатить, ленивый верстальщик с шестнадцатеричного представления цвета
```
color: #000; opacity:0.49;
```
скорее всего перейдет к rgba представлению
```
color: rgba(0,0,0,.49);
```
А вот если дизайнер решит делать такую штуку к блоку элементов (там где про background-color, color, background: linear-gradient ….), при этом, половина элементов будет с прозрачностью, а вторая, нет, то тут можно во вкладку Code и не смотреть.
В общем, Фигму нельзя рекомендовать как начальный инструмент для молодого дизайнера. Порог входа, тут пониже будет, но и нервы вы своими макетами коллегам испортите.
**Отсутствие нормальной Темной темы**
Это очень печально, но пока в Фигме нет возможности адекватно менять визуальное представление рабочего пространства под свои нужды. Особенно остро это стает когда пользуешься приложением, а не браузерной версией где можно извращается, ставя поверх браузера какие-то дополнения, плагины. Разуметься присутствуют [плагины умельцев](https://papertiger.com/figma-dark-ui-plugin), но поскольку Фигма очень часто апдейтиться, то плагины за ней не успевают.
Лучше б конечно, чтоб за данный функционал отвечали те, кто пишет продукт
Личные попытки поставить Темную тему. (Windows 10, Chrome 76) были печальны.
\*Возможно, у владельцев Mac-ов дела обстоят лучше. Делитесь в комментариях…
О том почему это важно и полезно можете посмотреть в презентации [Тёмная сторона веба, Никиты Дубко](https://www.youtube.com/watch?v=inJbZ1WFfQA) Надеюсь что поправят. Всё-таки дизайнеры — тоже люди, и им тоже надо дать возможность комфортно работать 8 часов в сутки 5 дней в неделю.
Вот такой вот кратенький обзорчик Figma у меня вышел с пожеланиями и ворчанием.
Надеюсь, что мой пост прочитает кто-то из разработчиков данного продукта и сможет его улучшить. В любом случае за данным продуктом я вижу будущее, и желательно, чтоб он развивался в правильном направлении.
**Сделаем web лучше.**
P.S. Отдельное спасибо, дизайнерам, которых я доставал дурацкими вопросами, но они на них стойко отвечали, и пользователю [AWG-RU](https://habr.com/ru/users/awg-ru/) за пост [Правила подготовки макетов в Figma](https://habr.com/ru/post/463061/) | https://habr.com/ru/post/463181/ | null | ru | null |
# Несколько хостов FreeIPA за HTTP-proxy: настраиваем HAProxy 2+
Путь инженера в телекоме часто начинается со службы технической поддержки. Если вы хотите вырастить из новичков высококлассных специалистов, нужно дать им возможность работать над выходящими за рамки служебных обязанностей задачами. Мы стараемся помогать активным коллегам в развитии — это один из главных принципов [HOSTKEY](https://hostkey.ru/) с момента основания компании. Публикуем заметку о реализации проксирования административной панели [FreeIPA](https://www.freeipa.org/page/Main_Page) через [HAProxy](https://www.haproxy.com/blog/haproxy-2-0-and-beyond/), написанную нашим *инженером техподдержки* *Александром Тряпкиным*.
([А здесь можно прочесть, как синхронизировать FreeIPA с Active Directory](https://habr.com/ru/company/hostkey/blog/669978/)).
### Проблема
У нас есть три хоста административной панели FreeIPA (freeipa01.inside.mydomain.ru, freeipa02.inside.mydomain.ru и freeipa03.inside.mydomain.ru). Необходимо обеспечить доступ к ним по одному доменному имени: freeipa.mydomain.ru. При кажущейся простоте задачи, для ее решения пришлось приложить некоторые усилия, поскольку в Интернете не нашлось готовых рецептов для HAProxy версии 2.0 и выше.
Каждая инсталляция FreeIPA привязана к своему доменному имени, а значит нам потребуется править заголовки входящих и исходящих HTTP-запросов. Портал самообслуживания должен быть закрыт действующим сертификатом, при этом работающие в бэкенде хосты FreeIPA не должны изменяться, чтобы не затронуть взаимодействие между клиентами и серверами через API.
> В старых версиях HAProxy (1+) для редактирования HTTP-заголовков использовался метод **reqrep/rsprep**. В сети есть инструкции по настройке HAProxy и FreeIPA с помощью [этого метода](https://medium.com/@michalmedvecky/running-freeipa-behind-haproxy-77620736698e), но в версии 2.0 он был помечен как deprecated, а в версии 2.1 полностью выведен из использования. Вместо **rsprep** мы будем использовать метод **http-response**.
>
>
### Решение
Для начала отредактируем созданный по умолчанию конфигурационный файл HAProxy. В нем можно выделить четыре секции: **global**, **defaults**, **frontend** и **backend**. Первые две мы трогать не будем (достаточно стандартных значений), а вот **frontend** и **backend** опишем подробно:
```
#Секция frontend
frontend main
bind :80
redirect scheme https code 301 if !{ ssl_fc } # редиректим на https
frontend main_ssl
bind :443 ssl crt /etc/haproxy/ssl/ # используем сертификаты из директории
use_backend freeipa if { ssl_fc_sni freeipa.mydomain.ru } # в случае если обращаются к freeipa.mydomain.ru используем backend FreeIPA
#Секция backend
backend freeipa
mode http
balance roundrobin # по очереди распределяем нагрузку по хостам
cookie SERVERID insert indirect nocache httponly secure # добавляем cookie для направления трафика на основе него
#acl для request на основе добавленного cookei
acl hdr_req_ipa01 req.hdr(Cookie) -m sub ipa01
acl hdr_req_ipa02 req.hdr(Cookie) -m sub ipa02
acl hdr_req_ipa03 req.hdr(Cookie) -m sub ipa03
#--------------------------------------------------------------------------
#В зависимости от того, каким cookie помечен наш запрос, изменяем заголовки Host и Referer
http-request set-header Host freeipa01.inside.mydomain.ru if hdr_req_ipa01
http-request replace-header Referer ^https?://freeipa\.mydomain\.ru(.*)$ https://freeipa01\.inside\.mydomain\.ru\1 if hdr_req_ipa01
http-request set-header Host freeipa02.inside.mydomain.ru if hdr_req_ipa02
http-request replace-header Referer ^https?://freeipa\.mydomain\.ru(.*)$ https://freeipa01\.inside\.mydomain\.ru\1 if hdr_req_ipa02
http-request set-header Host freeipa03.inside.mydomain.ru if hdr_req_ipa03
http-request replace-header Referer ^https?://freeipa\.mydomain\.ru(.*)$ https://freeipa01\.inside\.mydomain\.ru\1 if hdr_req_ipa03
#--------------------------------------------------------------------------
#acl для response на основе заголовка Location
acl hdr_ipa01 res.hdr(Location) -m sub freeipa01.inside.mydomain.ru
acl hdr_ipa02 res.hdr(Location) -m sub freeipa02.inside.mydomain.ru
acl hdr_ipa03 res.hdr(Location) -m sub freeipa03.inside.mydomain.ru
#--------------------------------------------------------------------------
#В зависимости от того с какого хоста пришел ответ редактируем заголовки Set-Cookie и Location Без редактирования заголовка Location мы столкнемся со следующей проблемой: пользователь при переходе по ссылке freeipa.mydomain.ru будет переброшен на один из хостов freeipa0x.inside.mydomain.ru (это важный момент пропущенный во всех найденных руководствах)
http-response replace-header Set-Cookie ^Domain=freeipa01\.inside\.mydomain\.ru(.*) Domain=freeipa\.mydomain\.ru\1 if hdr_ipa01
http-response replace-value Location ^https?://freeipa01\.inside\.mydomain\.ru(.*)$ https://freeipa\.mydomain\.ru\1 if hdr_ipa01
http-response replace-header Set-Cookie ^Domain=freeipa02\.inside\.mydomain\.ru(.*) Domain=freeipa\.mydomain\.ru\1 if hdr_ipa02
http-response replace-value Location ^https?://freeipa02\.inside\.mydomain\.ru(.*)$ https://freeipa\.mydomain\.ru\1 if hdr_ipa02
http-response replace-header Set-Cookie ^Domain=freeipa03\.inside\.mydomain\.ru(.*) Domain=freeipa\.mydomain\.ru\1 if hdr_ipa03
http-response replace-value Location ^https?://freeipa03\.inside\.mydomain\.ru(.*)$ https://freeipa\.mydomain\.ru\1 if hdr_ipa03
#--------------------------------------------------------------------------
#Здесь указываем наши хосты FreeIPA
server ipa01 freeipa01.inside.mydomain.ru:443 check port 443 inter 5s rise 2 fall 5 cookie ipa01 weight 9 ssl verify none
server ipa02 freeipa02.inside.mydomain.ru:443 check port 443 inter 5s rise 2 fall 5 cookie ipa02 weight 1 ssl verify none
server ipa03 freeipa03.inside.mydomain.ru:443 check port 443 inter 5s rise 2 fall 5 cookie ipa03 weight 3 ssl verify none
#check port 443 - проверяем жив ли хост по 443 порту.
#inter 5s - проверяем доступность с интервалом 5 секунд.
#rise 2 fall 5 - если 2 раза проверка скажет что хост недоступен он будет исключен из балансировки и возвращен после 5 успешных проверок
#cookie ipa0x - указывает какое cookie будет добавляться “cookie SERVERID insert”
#ssl verify none - терминация SSL-сертификата игнорируя ошибки
#weight 3 указываем приоритет распределения нагрузки
```
Также вы можете столкнуться с надоедливым окном базовой авторизации в браузерах Chrome, Edge, IE и некоторых других.
Появление этого окна описано в [багрепорте](https://bugzilla.redhat.com/show_bug.cgi?id=1309041) и там же есть решение проблемы, но при помощи HAProxy ее можно обойти без изменения конфигурации хостов. Для этого добавим в секцию backend конфигурационного файла следующую строку:
```
http-response del-header www-authenticate
```
Она удалит из ответа хоста заголовок, ответственный за появление навязчивого окна.
Итоги
-----
Сравнив решение задачи с помощью **rsprep** и через **http-response**, можно лучше разобраться в логике HAProxy и научиться работать с HTTP-запросами на более глубоком уровне.
\_\_\_\_\_\_\_\_\_
> Как видите, поддерживать инициативу инженеров технической поддержки полезно для бизнеса. Мы не только помогаем специалистам развиваться и делать карьеру (что опять-таки выгодно работодателю), но и получаем полезные клиентам прикладные разработки, а также интересные заметки для корпоративного блога. Надеемся, наше решение пригодится читателям.
>
>
*А специальный промокод*«***Я С ХАБРА***»*тоже может пригодиться: назовите его консультанту на сайте при размещении заказа, чтобы получить дополнительную скидку.*[*Платить можно как всегда в рублях*](https://hostkey.ru/news/51-mezhdunarodnyj-khosting-provajder-hostkey-prodolzhaet-prinimat-oplatu-v-rublyakh-za-uslugi-v-evrope-i-ssha/)*с НДС российской компании или в евро — компании в Нидерландах.* | https://habr.com/ru/post/679732/ | null | ru | null |
# Репликации в PostgreSQL
Сейчас трудно себе представить «боевую» инсталляцию любой серьезной СУБД в виде единственного инстанса. Конечно, некоторые приложения требуют для своей работы использование локальных баз данных, но если мы говорим о сетевом многопользовательском режиме работы, то здесь использование только одной инсталляции это очень плохая идея.
Основной проблемой единственной инсталляции естественно является надежность. В случае падения сервера нам потребуется некоторое, возможно значительное, время на восстановление. Так восстановление террабайтной базы может занять несколько часов.
Да и исправный бэкап есть не всегда, но об этом мы уже говорили в [предыдущей статье](https://habr.com/ru/company/otus/blog/710094/).
Кроме надежности, второй существенной проблемой единственной инсталляции является производительность. Даже при использовании виртуальной инфраструктуры мы не можем до бесконечности «одалживать» ресурсы у гипервизора. Что делать когда закончились память и ядра у сервера? Нужно горизонтальное масштабирование, то есть установка дополнительных инстансов. Также на производительность конкретного инстанса влияют ресурсоемкие операции, такие как построение отчетов, обработка данных и т. д. Да и бэкап тоже лучше делать с менее нагруженного инстанса.
Таким образом, мы приходим к тому, что для полноценного функционирования серьезной БД нам необходимо делать реплики. Наличие второго инстанса позволит использовать его в случае выхода из строя основного, то есть обеспечить отказоустойчивость. Кроме того, все ресурсоемкие операции можно перенести на реплику, чтобы максимально разгрузить мастер.
Но и при репликации не следует забывать о некоторых важных моментах. Так, если у вас произошло повреждение данных на логическом уровне (повреждены индексы, некорректные данные в таблицах) то все эти неприятные изменения сохраняться и на реплику. Поэтому репликация это хорошая защита от физических сбоев, а вот от логических сбоев нам поможет бэкап.
И завершая теоретическую часть этой статьи хотелось бы прояснить различия между понятиями резервирование и резервное копирование. Готовя материал к предыдущей статье я сталкивался с тем, что на некоторых ресурсах бэкап тоже называют термином резервирование. Это неверно, резервирование это обеспечение отказоустойчивости работы ресурсов в режиме реального времени. Резервирование не допускает простоев системы, по крайней мере таких масштабных как при восстановлении из бэкапов. Так что резервирование это репликации и кластеры, а резервное копирование это бэкап.
Ну а теперь перейдем уже непосредственно к репликациям в PostgreSQL.
### Виды репликаций
Для начала напомню о WAL — журналом предзаписи транзакций. Во избежание нарушений целостности в структуре баз данных, PostgreSQL сначала записывает эти изменения в файлы журнала WAL и только потом в базу. Журналы WAL нужны для того, чтобы в случае сбоя сервера можно было восстановить незафиксированные данные. Ну а применительно к теме сегодняшней статьи, WAL используется и для репликации данных.
Репликация на серверах СУБД PostgreSQL бывает двух видов: физическая и логическая. При физической репликации у нас на сервер реплики передается поток WAL записей. Одним из основных достоинств физической репликации является простота в конфигурировании и использовании, так как используется простое побайтовое копирование с одного сервера на другой. Также из-за своей простоты, физическая репликация потребляет меньше ресурсов.
Но у физических репликаций есть и свои недостатки. По аналогии с физическим бэкапом здесь также требуются одинаковые версии PostgreSQL и операционной системы.
При этом, также должны быть идентичны в том числе и аппаратные компоненты, такие как архитектура процессора. Также при физических бэкапах возможна репликация только всего кластера, на подчиненном инстансе нельзя создать никакую отдельную таблицу, даже временную. Полная идентичность основному серверу.
В зависимости от архитектуры самой БД возможна существенная нагрузка на инфраструктуру, так как нужно передавать все изменения в файлах данных полностью.
Логическая репликация работает по принципу подписки. Мастер сервер выступает в роли поставщика, который публикует изменения, происходящие в базе, а серверы реплики, выступающие в роли подписчиков получают и применяют эти изменения у себя.
На программном уровне логические репликации используют репликационные идентификаторы (как правило, это первичный ключ). Снимок данных с таблицы на основном инстансе публикуется и передается подписчику. После этого, все изменения, происходящие с данными на стороне основного сервера также публикуются и передаются подписчику, как любят писать во многих источниках «в режиме реального времени». Хотя если быть занудным то термин «работа в реальном времени» применим только к операционным системам реального времени RTOS, таким как QNX. А для классических ОС Linux/Windows все-таки уместен термин «режим близкий к реальному времени».
Так или иначе, как только изменения происходят на мастере, они сразу же реплицируется на слейва. Соответственно, подчиненный сервер применяет изменения в той же последовательности, что и публикующий узел, тем самым гарантируется транзакционная целостность.
Логическая репликация также имеет ряд преимуществ перед физической. Прежде всего, это независимость от используемых непосредственно на серверах форматов хранения данных. То есть, мастер и слейв могут иметь различные представления данных на диске, разные ОС и архитектуры. Оба сервера участника репликации могут выступать для разных объектов, как в роли поставщика, так и в роли подписчика. Таким образом мы можем использовать двусторонний обмен, например одна таблица может реплицироваться с первого сервера на второй, а другая со второго сервера на первый. К преимуществам логической репликации можно отнести возможность использовать разные ОС на разных инстансах, а также возможность выборочной репликации отдельных объектов кластера. В результате мы можем снизить нагрузку на сеть, так как при логической репликации объем передаваемых данных меньше.
### Сценарии использования
Для физических репликаций основное применение это создание отказоустойчивых кластеров, когда необходимо иметь точную копию БД на другом инстансе.
Логическая репликация предполагает больше различных вариантов использования. Например, мы можем объединить несколько баз в одну, для целей анализа, реплицировать данные между разными кофигурациями PostgreSQL, развернутыми как под Windows, так и под Linux. Можно настроить срабатывание триггеров для отдельных изменений, когда их получает подписчик и другие интересные манипуляции с реплицируемыми данными.
Перейдем к практике.
Для начала настроим физическую репликацию между двумя серверами Ubuntu 22.04.
Далее в примерах
*192.168.222.142 - Master*
*192.168.222.136 - Slave*
Прежде всего необходимо установить две абсолютно одинаковые инсталляции OC. В моем примере это будет Ubuntu. Далее обновляемся и устанавливаем СУБД на обоих серверах:
Далее работаем в консоли сервера Master.
Под аккаунтом postgres необходимо создать пользователя для репликации:
В моем примере таким пользователем является rep\_user. Далее, смотрим расположение conf файла:
Нам необходимо внести в этот файл некоторые правки:
В файл необходимо внести следующие правки:
```
archive_mode = on
archive_command = 'cp %p /oracle/pg_data/archive/%f'
max_wal_senders = 10
wal_keep_segments = 50
wal_level = replica
wal_log_hints = on
```
Далее необходимо внести дополнения в файл pg\_hba.conf, добавив имя пользователя для репликаций и IP адрес подчиненного сервера:
 И в завершении настройки перезапускаем Postgresql:
На этом настройка сервера Master завершена. Теперь перейдем к настройке сервера Slave. Прежде всего правим файл postgresql.conf:
`listen_addresses = 'localhost, 192.168.1.136'`
Для внесения дальнейших изменений нам необходимо остановить сервер:
Так как в режиме подчиненного сервера у нас все данные реплицируются с основного, нам необходимо удалить файлы из каталога main. Если у вас инсталляция не новая, можно предварительно сделать бэкап содержимого этого каталога.
Теперь проведем проверку работы процесса репликации. Для этого используем команду pg\_basebackup с адресом основного сервера и именем пользователя для репликаций:
Теперь можно запустить сервис PosthreSQL на подчиненном сервере:
### Логические репликации
В завершении статьи рассмотрим настройку логической репликации в PostgreSQL. В качестве примера я выполню репликацию базы Otus. Прежде всего необходимо в файле postgresql.conf сменить значение параметра wal\_level:
В уже знакомом нам файле pg\_hba.conf на мастере добавляем строку с IP адресом подчиненного сервера:
Далее делаем дамп всей БД и дамп схемы базы Otus.
Теперь необходимо создать публикацию на стороне сервера мастер:
И подписку на стороне подчиненного сервера:
Теперь все изменения в базе Otus будут реплицироваться на Slave И данный сервер уже можно будет использовать для выполнения резервного копирования, построения отчетов и других ресурсоемких задач.
### Заключение
В этой статье мы рассмотрели такую важную тему как базовая настройка физических и логических репликаций в СУБД PostgreSQL. Дальше, с помощью репликаций уже можно строить более сложные схемы взаимодействия между серверами БД.
Также напоминаю про [бесплатный вебинар](https://otus.pw/CEV2/) курса "*PostgreSQL для администраторов баз данных и разработчиков*" посвященный маленьким хитростям GROUP BY. На вебинаре вспомним, как устроен GROUP BY и рассмотрим его на наглядных примерах, оптимизируем работу группировки в связке с индексами, разберемся с особенностями группировки строк в PostgreSQL, а также изучим несколько полезных приемов для работы с GROUP BY.
* [Зарегистрироваться на бесплатный вебинар](https://otus.pw/eyYK/) | https://habr.com/ru/post/710956/ | null | ru | null |
# Kubernetes 1.17 — как обновиться и не потратить весь error budget
9 декабря вышла очередная версия Kubernetes — 1.17. Ее девиз — «Стабильность», множество фич получили статус GA, некоторое количество устаревших фич было удалено…
И, как всегда, наш любимый раздел Action Required файла [CHANGELOG-1.17.md](https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG-1.17.md) требует к себе внимания.
Поработаем руками…
### Внимание, Storage !
Обновление kubelet на лету в версии 1.17 не поддерживается, потому что изменился путь к block volumes. Перед обновлением узла необходимо эвакуировать с него все поды с помощью команды `kubectl drain`.
#### Флаги и ворота...
В changelog обычно пишут, что был удален или добавлен такой-то flag или feature gate, но почему-то никогда не пишут приложение, у которого произошло это изменение...:
* Убран флаг `--include-uninitialized` у `kubectl`;
* Функционал, который разрешали feature gates `GCERegionalPersistentDisk`, `EnableAggregatedDiscoveryTimeout` и `PersistentLocalVolumes`, теперь всегда используется и его нельзя отключить. Эти опции убраны из возможных ключей `api-server` и `controller-manager`;
* Сеть ip адресов для сервисов теперь не назначается по умолчанию. Необходимо указывать ее с помощью флага `--service-cluster-ip-range` при запуске API server и controller-manager.
#### kubeadm
* Kubeadm научился настраивать автоматическое обновление сертификатов для kubelet на всех узлах кластера, в том числе и на первом мастере, где выполнялась команда `kubeadm init`. Побочным эффектом стало требование наличия файла с начальной конфигурацией kubelet `bootstrap-kubelet.conf` вместо `kubelet.conf` во время выполнения `kubeadm init`;
* При добавлении режимов авторизации в API сервер kubeadm больше не подставляет режимы `Node, RBAC` в манифест статик пода, позволяя полностью поменять конфигурацию.
#### RBAC
Удалены встроенные кластерные роли `system:csi-external-provisioner` и `system:csi-external-attacher`.
#### Deprecated...
Некоторое количество фич было объявлено устаревшими, однако они все еще продолжают поддерживаться. Но особенно хотелось бы отметить процесс перехода на использование ContainerStorageInterface. Администраторы, развернувшие собственные (не managed) кластеры в AWS и GCE, должны запланировать переезд на использование CSI Driver для работы с постоянными томами — вместо драйверов, встроенных в Kubernetes. В этом им должна помочь процедура CSIMigration — ждем появления пошагового руководства. Администраторам, которые используют другие провайдеры для подключения постоянных дисков, пора искать и читать документацию: в версии 1.21 обещают окончательно удалить все встроенные драйверы. | https://habr.com/ru/post/479534/ | null | ru | null |
# Reactive Spring Cloud Gateway: конвейер WebSocket в Restful и обратно
В предыдущей статье [Reactive Spring ABAC Security: безопасность уровня Enterprise](https://habr.com/ru/post/645923/) впервые и крайне кратко представлен описанный в данной статье подход. Пришло время детально раскрыть нюансы и глубину потенциала нового подхода, когда основным протоколом для взаимодействия браузера и мобильных приложений с сервисами Spring Cloud выступает стабильный и быстрый WebSocket.
### Аннотация
Spring Cloud Gateway официально служит следующим целям: слоем безопасности, маршрутизатором, балансировщиком, провайдером протоколов сжатия. Gateway ничего не знает о передаваемых данных и тем более о бизнес-логике – это инфраструктурный сервис.
Связь Gateway с WebSocket обуславливает здравый смысл. Если перенести логику WebSocket в Gateway, то при высоких нагрузках потребуется ненамного увеличить количество подов с одной стороны (из-за ограничения количества открытых соединений), а с другой если через WebSocket работают не только браузеры, но и мобильные приложения – то такой подход становится естественным.
В статье описываются явные преимущества данного подхода, детально перечисляются нюансы реализации и определяются общие перспективы дальнейшего развития. Но основная идея сводится к уменьшению стоимости разработки за счёт переиспользования базовых технологий для всего необходимого функционала.
Что позволит в итоге освободившиеся ресурсы перекинуть на улучшения качества отрисовки интерфейсов, добавления современных спец. эффектов, увеличения динамичности интерфейса на действия пользователя и получаемых данных в реальном режиме времени.
### Введение
В эпоху рассвета мобильных приложений на Android, в то время, когда в 2009 году Samsung объявил об отказе от Symbian и переходе на Android (iOS ещё не было) – WebSocket в том же году был ещё в виде черновика, т.е. исторически мобильные приложения не застали эту технологию и развитие ушло своим чередом.
Кроме того, существовала проблема при переключении телефона с одной соты на другую – также менялся и IP-адрес телефона, что прерывало все установленные соединения. Данный фактор был не в пользу WebSocket, который в исходной версии не умел переподключаться при обрыве связи. Сейчас, качество связи стала крайне стабильной, а IP-адреса внутри сети мобильного оператора привязаны к телефону. Можно сказать появились тепличные условия для восхождения WebSocket и почему бы и нет.
В представленном проекте <https://github.com/SevenParadigms/spring-cloud-websocket-gateway>, интеграция WebSocket не влияет на работу и исходный код существующих сервисов, т.к. конвейер сообщений WebSocket в Restful прозрачно конвертирует запросы и ответы.
Преимущества использования конвейера WebSocket в Restful следующие:
1. Классический микросервисный подход Spring Cloud к организации обработки потока данных на стороне бэкенда как от браузера так и от мобильных приложений по WebSocket, когда сервисам не интересно откуда приходят http-запросы;
2. Единое понятие сессии: отключение всех соединений WebSocket пользователя однозначно сообщит о закрытии сессии как в браузере, так и в мобильном приложении (такое знание для многих бизнес-процессов критично);
3. Открытые соединения WebSocket точно определяют количество пользователей онлайн, в то время как в случае http-запросов, онлайн считается по количеству запросов за последние полчаса;
4. Более не требуется тратить значительные ресурсы на организацию Push-уведомлений – полученные через WebSocket уведомлений ничем не отличаются визуально, при условии когда приложение запущено (что в подавляющем большинстве случаев приемлемо);
5. При высоких нагрузках WebSocket заметно быстрее HTTP и значительно меньше потребляет трафика, при этом, поддерживает полнодуплексный асинхронный обмен сообщениями в обе стороны;
6. Из коробки *Origin-based cross-domain policy* (политика безопасности на основе происхождения);
7. Прямым преимуществом использования WebSocket перед http-запросами в возможности обратной связи в реальном времени, что позволяет строить современные высококонкурентные реактивные интерфейсы в мобильных приложениях.
Если принять во внимание факт увеличения расхода батареи из-за постоянно открытого соединения WebSocket, то согласно GSM Arena с 2010 года плотность аккумуляторов к 2020 году выросла в 3 раза и при том же форм-факторе ёмкость батареи достигла 5000 мАч – это действительно много.
А если ещё учесть время на полную зарядку современных аккумуляторов от сети в 15 минут, то при таких темпах развития данный факт можно смело отнести к незначительным.
Конечно, Gateway продолжит маршрутизацию и балансировку http-запросов, т.к. останутся: авторизация пользователя, запросы выдающие большие объёмы данных, выгрузка файлов в браузер, а также интеграция внешних систем.
Рассматриваемый в статье проект позволяет снизить стоимость разработки и владения за счёт использования классического подхода http-запросов при работе с браузером и мобильными приложениями по протоколу WebSocket.
Представленный исходный код несмотря на небольшой размер и простоту реализации – эффективно выполняет все возложенные на него функции.
### Поддержка WebSocket в Android и iOS
В 2010 году в iOS 4.2 впервые появилась встроенная поддержка протокола WebSocket.
Наиболее распространённая практика использования WebSocket в среде iOS – это [библиотека SocketRocket](https://github.com/facebookincubator/SocketRocket) от Facebook 2012 года, а в среде Android – [библиотека Java-WebSocket](https://github.com/TooTallNate/Java-WebSocket) от opensource разработчика Nathan Rajlich, создавший проект в 2010 году (скорее всего для нужд одного из клиентов фондовой биржи NASDAQ).
В 2013 году один из разработчиков популярного проекта Socket.io закомитил [клиент WebSocket под Android](https://github.com/socketio/socket.io-client-java), которая также активно дорабатывается и в настоящее время. А спустя 4 года, основные разработчики Socket.io выпустили [клиент под iOS](https://github.com/socketio/socket.io-client-swift) также с полной поддержкой WebSocket.
В 2014 году вышла в релиз спецификация JSR-356, поддержка которой привела к включению в Java Development Kit (JDK) пакета *javax.websocket*. В дальнейшем, непосредственно в Kotlin Standard Library была внедрена обвёртка вокруг DOM API с базовым классом WebSocket – который также можно использовать в Android приложениях.
Помимо нативных библиотек от команды Socket.io, существует более десятка сторонних с полной имплементацией протокола WebSocket по спецификации RFC 6455 и большинство из них активно поддерживаются довольно крупными сообществами.
WebSocket профессионально присутствует в мобильных приложениях более 10 лет, т.к. на глобальном уровне требование к доставке данных в реальном режиме времени постоянно расширяется с каждым новым типом данных из года в год.
Основные аспекты реализации
---------------------------
Браузер или мобильное приложение отправляет и принимает запросы по WebSocket в обвёртке:
```
data class MessageWrapper(
val type: HttpMethod = HttpMethod.GET,
val baseUrl: String? = null,
val uri: String = StringUtils.EMPTY,
val body: JsonNode? = null
)
```
Атрибуты образуют http-запрос к сервисам:
* type – тип *GET*, *HEAD*, *POST*, *PUT*, *PATCH*, *DELETE*, *TRACE* (по умолчанию *GET);*
* baseUrl – имя сервиса, например: [http://account-service](http://account-service/);
* uri – метод контроллера и query-запрос, например: findAllPaged?sort=id:desc;
* body – json запроса при типе запроса *POST*, *PUT* или *PATCH*.
При формировании ответа body заменяется ответом с сервиса: *message.copy(body = it)*, а baseUrl и uri служат идентификаторами запроса в обработчике WebSocket в браузере или в мобильном приложении.
Функция преобразования запросов WebSocket в Restful и обратно:
```
fun handling(message: MessageWrapper, username: String) {
kafkaPublisher.publishWebSocketKafka(
WebSocketEvent(username, message.baseUrl, message.uri, message.body.toString())
).subscribe()
if (message.baseUrl != null) {
val webClient = Beans.of(WebClient.Builder::class.java).baseUrl(message.baseUrl).build()
val response = when (message.type) {
HttpMethod.GET -> webClient.get().uri(message.uri).retrieve()
HttpMethod.POST -> webClient.post().uri(message.uri).body(BodyInserters.fromValue(message.body!!))
.retrieve()
HttpMethod.PUT -> webClient.put().uri(message.uri).body(BodyInserters.fromValue(message.body!!))
.retrieve()
HttpMethod.DELETE -> webClient.delete().uri(message.uri).retrieve()
HttpMethod.PATCH -> webClient.patch().uri(message.uri).body(BodyInserters.fromValue(message.body!!))
.retrieve()
HttpMethod.HEAD -> webClient.head().uri(message.uri).retrieve()
HttpMethod.OPTIONS -> webClient.options().uri(message.uri).retrieve()
HttpMethod.TRACE -> webClient.method(HttpMethod.TRACE).uri(message.uri).retrieve()
}
response
.onStatus({ status -> status.isError })
{ clientResponse ->
clientResponse.bodyToMono(ByteArrayResource::class.java)
.map { responseAnswer: ByteArrayResource ->
WebClientResponseException(
clientResponse.rawStatusCode(),
clientResponse.statusCode().name,
clientResponse.headers().asHttpHeaders(),
responseAnswer.byteArray,
Charsets.UTF_8
)
}
}
.bodyToMono(JsonNode::class.java).subscribe {
info { "Request[${message.baseUrl}${message.uri}] by user[$username] accepted" }
debug { it.toString() }
val sessionChain = clients.getIfPresent(username)
sessionChain?.sendMessage(message.copy(body = it))
}
}
}
```
Детальный обзор реализации
--------------------------
Рассмотрим публикацию точки входа для реактивного WebSocket для конвертации запросов из WebSocket в HTTP к сервисам и обратно:
```
@Component
@WebSocketEntryPoint("/wsf")
class WebSocketFactory(val kafkaPublisher: EventDrivenPublisher) : WebSocketHandler {
override fun handle(session: WebSocketSession) = session.handshakeInfo.principal
.cast(UsernamePasswordAuthenticationToken::class.java)
.flatMap { authToken: UsernamePasswordAuthenticationToken ->
val output = session.send(Flux.create {
authToken.credentials
clients.put(authToken.name, WebSocketSessionChain(
session = session, tokenHash = authToken.credentials as Long, chain = it))
})
val input = session.receive()
.map { obj: WebSocketMessage -> obj.payloadAsText.parseJson(MessageWrapper::class.java) }
.doOnNext { handling(it, authToken.name) }.then()
Mono.zip(input, output).then().doFinally { signal: SignalType ->
val sessionChain = clients.getIfPresent(authToken.name)!!
sessionChain.session.close()
kafkaPublisher.publishDisconnect(
UserDisconnectEvent(authToken.name, sessionChain.tokenHash, false)
.subscribe {
clients.invalidate(authToken.name)
info { "Connection close with signal[${signal.name}] and user[${authToken.name}]" }
}
}
kafkaPublisher.publishConnect(
UserConnectEvent(authToken.name, authToken.authorities.map { it.authority })
)
}
```
```
com.github.ben-manes.caffeine
caffeine
3.1.0
```
Кэш clients на базе библиотеки Caffeine, имеет ограничения по времени бездействия и по размеру количества открытых соединений WebSocket, а при завершении сессии по таймауту посылает в Kafka соответствующее событие:
```
val clients = Caffeine.newBuilder()
.maximumSize(Beans.getProperty(Constants.GATEWAY_CACHE_SIZE, Long::class.java, 10000))
.expireAfterAccess(
Beans.getProperty(Constants.GATEWAY_CACHE_ACCESS, Long::class.java, 1800000),
TimeUnit.MILLISECONDS
)
.removalListener { key: String?, value: WebSocketSessionChain?, cause: RemovalCause ->
if (cause.wasEvicted() && ObjectUtils.isNotEmpty(key)) {
kafkaPublisher.publishDisconnect(
UserDisconnectEvent(key, value!!.tokenHash, true)
).subscribe {
value.session.close()
info { "WebSocket disconnected by timeout with user[$key]" }
}
}
}.build()
```
События Kafka отправляются через сервис EventDriverPublisher, где представлены методы по каждому типу события – это связано с необходимостью типизации модели для сериализации, т.к. для сжатия используется библиотека [Apache Avro](https://avro.apache.org/). Все модели Kafka предварительно генерируются плагином avro-maven-plugin.
Использование [протокола сжатия Avro](https://github.com/confluentinc/schema-registry) позволяет строить именно типизированные SQL-запросы по историческим данным Kafka посредством процессора [Lenses SQL](https://lenses.io/):
 Описание модели WebSocketEvent в нотификации Avro:
```
{
"namespace": "io.github.sevenparadigms.gateway.kafka.model",
"type": "record",
"name": "WebSocketEvent",
"fields": [
{
"name": "username",
"type": {
"type": "string",
"default": "null"
}
},
{
"name": "baseUrl",
"type": "string"
},
{
"name": "uri",
"type": "string"
},
{
"name": "body",
"type": "string"
}
]
}
```
Реализация методов класса EventDrivenPublisher:
```
private val producerProps: Map = mapOf(
BOOTSTRAP\_SERVERS\_CONFIG to kafkaProperties.broker,
KEY\_SERIALIZER\_CLASS\_CONFIG to kafkaProperties.serializer,
VALUE\_SERIALIZER\_CLASS\_CONFIG to kafkaProperties.serializer,
SCHEMA\_REGISTRY\_URL\_CONFIG to kafkaProperties.schemaRegistryUrl,
VALUE\_SUBJECT\_NAME\_STRATEGY to RecordNameStrategy::class.java,
AUTO\_REGISTER\_SCHEMAS to true
)
fun publish(topic: String, event: T, key: String = UUID.randomUUID().toString()) =
KafkaSender.create(SenderOptions.create(producerProps)).createOutbound()
.send(Mono.just(ProducerRecord(topic, key, event)))
.then()
.doOnSuccess { info { "Successfully sent to topic[$topic]: $event with id=$key" } }
fun publishWebSocketKafka(event: WebSocketEvent) = publish(kafkaProperties.webSocketKafkaTopic, event)
fun publishConnect(event: UserConnectEvent) = publish(kafkaProperties.userConnectTopic, event)
fun publishDisconnect(event: UserDisconnectEvent): Mono {
eventPublisher.publishEvent(RevokeTokenEvent(hash = event.hash, source = event.username))
return publish(kafkaProperties.userDisconnectTopic, event)
}
```
Конфигурация Kafka в application.yml:
```
kafka:
web-socket-topic: websocket-transport
web-socket-kafka-topic: websocket-kafka
user-connect-topic: user-connect-event
user-disconnect-topic: user-disconnect-event
broker: localhost:9092
group-id: websocket-gateway
serializer: io.confluent.kafka.serializers.KafkaAvroSerializer
deserializer: io.confluent.kafka.serializers.KafkaAvroDeserializer
schema-registry-url: http://localhost:8081
```
Рассмотрим кусочки кода точки входа для WebSocket:
```
val output = session.send(Flux.create {
clients.put(authToken.name, WebSocketSessionChain(session, it))
})
```
здесь видно, что соединение WebSocket через объект *it = FluxSink* сохраняется в кэше clients для дальнейшей отправки сообщений пользователю в браузер или в мобильное приложение в структуре *MessageWrapper* по его идентификатору, который представлен как name;
```
Mono.zip(input, output).then().doFinally { signal: SignalType ->
val sessionChain = clients.getIfPresent(authToken.name)!!
sessionChain.session.close()
kafkaPublisher.publishDisconnect(
UserDisconnectEvent(authToken.name, sessionChain.tokenHash, false)
).subscribe {
clients.invalidate(authToken.name)
info { "Connection close with signal[${signal.name}] and user[${authToken.name}]" }
}
}
```
а конструкция *doFinally { }* позволяет перехватить момент закрытия соединения WebSocket, **корректно завершить сессию** и отправить событие Kafka.
```
io.github.sevenparadigms
reactive-spring-abac-security
1.5.2
```
В Gateway включена библиотека [reactive-spring-abac-security](https://github.com/SevenParadigms/reactive-spring-abac-security) и чтобы подключится к WebSocket необходимо передать в заголовке jwt-токен, который для производительности валидируется только по времени и по подписи публичным ключом из application.yml.
```
spring:
security:
jwt:
public-key:
MIIDeTCCAmGgAwIBAgIEFzIFujANBgkqhkiG9w0BAQsFADBtMQswCQYDVQQGEwJG
UjEQMA4GA1UECBMHVW5rbm93bjEOMAwGA1UEBxMFUGFyaXMxFzAVBgNVBAoTDlNl
dmVucGFyYWRpZ21zMQ8wDQYDVQQLEwZnaXRodWIxEjAQBgNVBAMTCUxhbyBUc2lu
ZzAeFw0yMjA0MDMxODQyMDRaFw0zMjAzMzExODQyMDRaMG0xCzAJBgNVBAYTAkZS
MRAwDgYDVQQIEwdVbmtub3duMQ4wDAYDVQQHEwVQYXJpczEXMBUGA1UEChMOU2V2
ZW5wYXJhZGlnbXMxDzANBgNVBAsTBmdpdGh1YjESMBAGA1UEAxMJTGFvIFRzaW5n
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAjtdx8tYDDRFUpw3oJdFx
Avcho5ytRQt1PZUymRoioO28RO9mXdrhJgKXA2MFlmjnzD/yRwR/PqZcneKz7rKx
kN14HYQNxgKrUFNZwtAtePiTAcAPy4NqtVeE8pS5djQ+bIqlpnJUhYvtK1vDlMkS
KUJr/N2/sRAQcH8fQiPG5vwI+MpHjWjqjjM+ycslPWqQp2QguaqxMd4IAjL8fZnP
2LGyCZdZCRbtu3TknW+zmgVMF9hiEdtUX677cBfamnslpCUe4ACI5aziwua5GQZV
DwfaFf6kOAtKcEa7CUy3axCs82KVa3lfPW/b8ALWDllbjYLZWVwNfvR5bKFFg2tk
GQIDAQABoyEwHzAdBgNVHQ4EFgQU29M6xK0D1NAvRRE1MApZv4Qr0l8wDQYJKoZI
hvcNAQELBQADggEBADCIzI/jC+3dXnhdca2ozwH6Oq46coT61tmLnCmlpTvE352w
g/FhpujILUOIwaShKjgIiBA1u1DYrZM1m9BoZ6/YuXa9OYpCK0jamuug4Vnz0bIm
fQIQPfCMJcouwc4pCm8jAzWSo8xfTJ/yhUnqt7/NQkGuSWsHVZN9O1leKVa2xTEU
C5APTpX7Rj2+mU8c/fDzFA1m+LXYp2T3dbi3yVOTzSwRkE84sE18fdgRuvJfpmxL
W3BuVKQ9/1bzpcTK1onKw7WNqrjCoO37G+d42IeDzXMdDjyI3POYYy8g/o//sp6O
JhhMDEwt2aEAKEVlQxYzgMBn8HeUQrHSeX+ML8Q=
```
```
io.github.sevenparadigms
kubernetes-embedded-hazelcast
1.2.8
```
В Gateway также включена библиотека [kuberbetes-embedded-hazelcast](https://github.com/SevenParadigms/kubernetes-embedded-hazelcast), которая инициализируется в Spring как CacheManager и запускает сервер Hazelcast как Embedded вместе с сервисом. Уникальной особенностью данной библиотеки является возможность задания максимального размера кэша по его наименованию в application.yml, что отсутствует в исходном Hazelcast.
Также в библиотеке присутствует интерфейс AnySerializable, который позволяет оперировать любыми типами данных со скоростью одновременно вставки и чтения более 1000 раз в миллисекунду.
Необязательные параметры jwt-кэша прописываются в application.yml:
```
spring.cache:
jwt.expireAfterWrite: 300000 # milliseconds, by default 5 minutes
jwt.maximumSize: 10000 # by default
```
В кластере Hazelcast хранится хэш jwt-токена, рассчитанный алгоритмом Murmur. Кэшируется хэш на уровне подов одного сервиса на время жизни токена и при повторном обращении результат валидации возвращается из кэша. Токен отзывается по завершении работы сессии пользователя при котором инициируется событие Spring *RevokeTokenEvent* и в запись кэша токена вносится признак деактивации.
Внешняя интеграция в WebSocket
------------------------------
Для асинхронной отправки сообщений в WebSocket через событие Kafka, как один из способов, добавлен роутер:
```
@Configuration
class RoutesConfiguration(private val kafkaHandler: KafkaHandler) {
@Bean
fun route(): RouterFunction = router {
("/kafka").nest {
accept(MediaType.APPLICATION\_JSON).nest {
POST("", kafkaHandler::publish)
}
}
}
}
```
который ожидает модель EventWrapper:
```
data class EventWrapper(
val topic: String = StringUtils.EMPTY,
val body: JsonNode = JsonUtils.objectNode()
)
```
и вызывает метод publish:
```
@Component
class KafkaHandler(private val kafkaPublisher: EventDrivenPublisher) {
fun publish(request: ServerRequest) = request.bodyToMono(EventWrapper::class.java)
.map { kafkaPublisher.publish(it.topic, it.body.jsonToObject(WebSocketEvent::class.java)) }
.map { ServerResponse.ok().build() }
.doOnError { error("Exception while trying to process event: " + it.message) }
}
```
после чего, в произвольный топик Kafka публикуется сообщение из body.
Если мы хотим отправить сообщение именно в WebSocket и определённому пользователю, тогда в topic указывается значение *websocket-transport*, а в body описывается модель *MessageWrapper*:
```
{
"topic": "websocket-transport",
"body": {
"username": userId,
"baseUrl": "http://account-service",
"uri": "cash-out",
"body": { "value": -100 }
}
}
```
При желании, сервис может напрямую в Kafka отправить сообщение пользователю в WebSocket не вызывая интеграционный метод */kafka* в Gateway, а также подписаться на события канала *websocket-kafka*, куда помещаются все принятые из WebSocket сообщения. При этом, сообщения с пустым baseUrl не исполняются конвейером, но также помещаются в топик *websocket-kafka*.
Другими словами, сервисы могут спокойно перейти во взаимодействие с WebSocket через Kafka, асинхронно принимая и отправляя сообщения – это та же микросервисная архитектура с брокером сообщений в качестве транспорта. Данный подход особенно оправдывает себя при высоких нагрузках, а также позволяет максимально эффективно использовать "железо" распределяя нагрузку в подах сервиса через очередь непосредственно в освободившийся поток процессора.
Проектируя и разрабатывая крупные государственные системы с распределением в региональные ЦОД, всегда вносил в архитектуру одновременно 3 вида транспорта для каждого запроса: http, брокер сообщений и предварительную запись на диск кластером in-memory базы данных с итоговой проверкой доставки по каждому из маршрутов – всё это на случай ядерной войны и это не шутка.
Возникла необходимость самому реализовывать механизм гарантированной доставки через реализацию алгоритмов *распределённого реплицируемого блочного устройства* (DRBD), когда в условиях частых изменений данных на всех узлах и нестабильной связи в дальних регионах – уже через месяц штатные средства репликации и синхронизации Oracle переставали работать **от слова совсем**.
В Spring Cloud есть два способа обработки ошибок транспорта: Circuit Breaker и Retry, предлагающие большой спектр атрибутов управления поведением при возникновении ошибки. Их можно использовать вместе и естественным образом это делает библиотека:
```
org.springframework.cloud
spring-cloud-starter-circuitbreaker-resilience4j
```
где через аннотации над функциями выстраивается посредством AspectJ управляющая инфраструктура, которая также позволяет обработать ошибки транспорта Kafka, получив в Exception все детали Event. Главное при этом не забывать про идемпотентность.
Поэтому рекомендую совмещать доступность сервисов по http и kafka на случай выхода из строя кластера Kafka во время промышленной, природной или военной катастрофы.
И наконец рассмотрим класс KafkaConsumerConfiguration, где создана подписка на топик *websocket-transport*, которая перенаправляет все принятые события в WebSocket:
```
private val receiverOptions = ReceiverOptions.create(
mapOf(
BOOTSTRAP\_SERVERS\_CONFIG to kafkaProperties.broker,
GROUP\_ID\_CONFIG to kafkaProperties.groupId,
KEY\_DESERIALIZER\_CLASS\_CONFIG to kafkaProperties.deserializer,
VALUE\_DESERIALIZER\_CLASS\_CONFIG to kafkaProperties.deserializer,
AUTO\_OFFSET\_RESET\_CONFIG to "earliest",
ENABLE\_AUTO\_COMMIT\_CONFIG to true,
SCHEMA\_REGISTRY\_URL\_CONFIG to kafkaProperties.schemaRegistryUrl,
VALUE\_SUBJECT\_NAME\_STRATEGY to RecordNameStrategy::class.java,
SPECIFIC\_AVRO\_READER\_CONFIG to true
)
).commitInterval(Duration.ZERO)
.commitBatchSize(0)
.subscription(setOf(kafkaProperties.webSocketTopic))
@Bean
fun listenWebSocketEvent(webSocketFactory: WebSocketFactory) =
KafkaReceiver.create(receiverOptions)
.receive()
.concatMap { record ->
Mono.fromRunnable {
val it = record.value()
debug { "Transfer kafka message to WebSocket: $it" }
webSocketFactory.get(it.username!!)?.sendMessage(it.copyTo(MessageWrapper()))
}
}.subscribe()
```
где из локальной коллекции пода открытых соединений в *webSocketFactory* по имени пользователя получаем объект *FluxSink* для отправки сообщения.
В конфигурации потребителя Kafka не указан CLIENT\_ID – что позволяет всем подам сервиса по GROUP\_ID одновременно обработать сообщение, т.к. соединение WebSocket присутствует только в одном из подов.
В качестве итога обзора небольшого, но эффективного кода можно также показать то небольшое количество подключаемых зависимостей в файле сборки pom.xml:
```
2021.0.1
1.5.2
1.3.11
1.11.0
7.1.1
5.1.1
1.2.8
```
Резюме
------
Простая идея интеграции в действующий Spring Cloud Gateway конвейера WebSocket в Restful уже существующих микросервисов и обратно – открывают множество возможностей и перспектив. В частности, отказа от часто дорогой инфраструктуры вокруг Push-уведомлений. При этом, Push-уведомления имеют ряд недостатков, такие как произвольные задержки транспорта, внеочерёдность уведомлений, переполнение пула очереди.
Кроме того, существующий фронт в браузере и в мобильных приложениях необязательно сразу переписывать под использование конвейера WebSocket, ведь Gateway продолжает свою работу по маршрутизации и балансировке.
Сначала, на фронт можно добавить асинхронную фабрику обработки входящих сообщений для реактивной адаптации интерфейса, а потом достаточно подменить используемую сетевую библиотеку на свою с тем же API, чтобы на заднем фоне упаковать запросы в обвёртку и затем отправить через WebSocket.
Представленный подход позволяет в любой момент перевести транспорт особо чувствительного микросервиса с http на kafka, что помимо управляемого трафика также приведёт к эффективному использованию ресурсов и соответственно удешевлению владения.
На примере организации процесса бизнес-логирования действий системы или аудита, нагрузка на БД при этом порой превышает 50%, то здесь решение часто видят в агрегации бизнес-логов через Kafka, чтобы затем методом Batch разом сохранить.
Есть две причины на мой взгляд почему аудит не стоит делать через Kafka: данные аудита удобно использовать в бизнес-логике и возможно в одной бизнес-операции, а также теряется согласованность при потери данных до записи в журнал WAL, но при наличии в Kafka.
Наиболее эффективно задача аудита, с точки зрения простоты реализации и гарантии консистентности, решается через создание виртуального потокового репликатора PostgreSQL – который даже встроен в реактивный драйвер [r2dbc-postgres](https://github.com/pgjdbc/r2dbc-postgresql):
```
Flux replicationStream = replicationConnection
.startReplication(replicationRequest).flatMapMany(it -> {
return it.map(byteBuf -> {…})
.doOnError(t -> it.close().subscribe());
});
```
где при сохранении данных в master-ноду лаг в PostgresSQL 14 составляет менее 100 мс в реальном времени, а если сервис виртуального репликатора запустить вместе с PostgreSQL, то лаг составит менее 5 мс – что весьма и востребовано. Конечно, аудит не все данные фиксирует в реальном времени, некритичные можно аккумулировать и сбрасывать через протокол [Copy](https://github.com/PgBulkInsert/PgBulkInsert) примерно каждые 500 мс.
Не стоит воспринимать гарантию доставки Kafka как панацею, довольно часто видел как в крупных информационных системах, кластера Kafka (+ZooKeeper) и ElasticSearch размещались целиком в одном ЦОД – при этом система используется во всех регионах. Это позволяет при диверсии или прямой атаке, техногенном или природном катаклизме лишиться системы целиком.
WebSocket на сегодняшний день самый популярный протокол реального времени, **ставшим стандартом де-факто** в мобильных приложениях, таких как финансовые инструменты, социальные сети, навигация по местоположению, заказ такси, доставка еды и конечно компьютерные игры.
Современные библиотеки WebSocket для Android и iOS реализуют широкий спектр методов и интерфейсов, позволяющий разработчикам даже с небольшим опытом создавать полноценные приложения реального времени с простым исходным кодом.
Так, в своё время, разработал ядро высоконагруженной криптовалютной биржи со схлопыванием более 100 тыс. контрактов по сделке за 1 секунду и конечно основным протоколом в мобильных приложениях биржи был WebSocket.
Архитектура WebSocket соответствует модели управляемых событий *Event-Driven* (EDA), а код оптимизирован для минимизации overhead по трафику и latency при передаче данных по сети. В наступившее время широкополосных каналов Интернет – WebSocket позволяет в полной мере реализовать реактивные интерфейсы, «оживляя» таким образом мобильное приложение в руках пользователя.
Буду рад, если данная статья помогла кому-то принять решение о выборе в качестве основного транспорта WebSocket как для браузера, так и для мобильных приложений. Ведь переход, как было рассмотрено, не влечёт никаких рисков, не отражается на работоспособности и исходном коде существующего функционала. При этом преимуществ такого подхода не перечесть. | https://habr.com/ru/post/662692/ | null | ru | null |
# Собеседование в Яндекс: театр абсурда :/
Привет, Хабр!
В [прошлой статье](https://habr.com/ru/post/534902/) меня знатно разбомбили в комментариях, где-то за дело, где-то я считаю, что нет. Так или иначе, я выжил, и у меня есть чем с вами поделиться >:)
Напомню, что в той статье я рассказывал, каким я вижу идеальное собеседование и что я нашёл компанию, которая так и делает - и я туда прошёл, хотя это был адский отбор. Я, довольный как слон, везде отметил, что я не ищу работу, отовсюду удалился и стал работать работу.
Как вы думаете, что делают рекрутеры, когда видят "Alexandr, NOT OPEN FOR WORK"? Правильно, пишут "Алексей, рассматриваете вариант работать в X?" Я обычно игнорирую это, но тут мне предложили попытать счастья с Яндекс.Лавкой, и я не смог пройти мимо - интересно было, смогу ли я устроиться куда-нибудь, когда введут великий российский файерволл. К тому же за последние 3 года я проходил только два интервью, и мне показалось, что я не в теме, что нынче требуется индустрии. Блин, я оказался и вправду не в теме. И вы, скорей всего, тоже - об этом и статья.
---
Короче, я согласился - буду продавать дошики и похмелье!
Мне назначили дату интервью, и также прислали методичку, чтобы я понимал, что меня ждёт и как готовиться. Чтобы ничего не заспойлерить, я замазал квадратиками важную информацию.
Вы тоже заметили "вопросы на C++" в методичке для питониста? Не то чтобы я знал C++, но в институте проходили, авось что-нибудь да вспомню на интервью.
Тут что-то написано про [leetcode](https://leetcode.com/problemset/all/), но я человек ответственный, поэтому к интервью не готовлюсь. Это кстати я не шуткую, реально: если вы ответственный человек, то вы, когда предстаёте перед компанией, отвечаете за то, что вы заявляете как ваши умения. Можно выучить типовые вопросы и даже казаться умнее и опытнее, чем есть, но по факту это переобучение на тестовых заданиях/вопросах. Ребята из ml поймут. Поэтому я гол как сокол и чист как стёклышко или что там ещё блин, если что-то знаю - скажу, что-то не знаю - скажу что не знаю. Таким образом работодатель знает, что он покупает и сколько ещё нужно вложить в меня средств на обучение. Все счастливы.
Интервью 1
----------
Так вот, назначили мне собеседование, и в назначенный час я был в зуме. Сразу скажу, что все - и рекрутер, и интервьюеры - вежливые и приятные в общении люди, тут я подкопаться не могу, ну разве что иногда они слишком корректные: спрашивают, ничего, если будет стажёр-наблюдатель и если они будут делать заметки в ходе интервью. На какой-то из итераций мне даже стало интересно, что будет, если я скажу "нет, нельзя", но именно тогда меня не спросили, так что предлагаю вам проверить самим.
Мне кинули ссылку на Яндекс.Блокнот (это я его так называю, вообще он Яндекс.Код и живёт [тут](https://code.yandex-team.ru)) - там можно вместе писать текст и включать подсветку синтаксиса. Запускать там, естественно, ничего нельзя, потому что это уже реализовано в [coderpad](https://coderpad.io), а он недостоин Яндекса. Ну ок, мне на самом деле проще, потому что написать код и написать *хотя бы* запускаемый код - это очень разные вещи. Минус - нельзя прогнать тесты и вообще тут как битва самураев: ваша правда против правды рекрутера, один доказывает, почему работает, другой - почему нет.
Итак, о чём вас спросит Яндекс на интервью? Выберите один правильный вариант:
1) прежний опыт
2) текущие проекты
3) как вы будете решать вот эту бизнес-задачу
4) как решить вот эту алгоритмическую задачу без стандартной библиотеки
Именно так! Так давайте решим эту алгоритмическую задачу. Помните, у нас нет `collections.Counter`, `itertools.groupby,` `set.intersection`, вообще случилась война и стандартная библиотека питона погибла, оставив после себя `int`, `bool`, `for`, `if` и `while`. Ну ок, хотят проверить знание каких-то базовых вещей.
### Задача 1
> *Даны два массива: [1, 2, 3, 2, 0] и [5, 1, 2, 7, 3, 2]
> Надо вернуть [1, 2, 2, 3] (порядок неважен)*
>
>
Фактически нам нужно вернуть пересечение множеств, но с повторением элементов. Не включая мозг, я начал сразу кидать что-то вроде
```
common = set(a).intersection(set(b)) # найдём общие элементы
for el in common:
occurs = min(a.count(el), b.count(el)) # и посчитаем, сколько они встречаются
```
Но меня осадили - у нас война, поэтому никаких `intersection`, только хардкор. После нескольких итераций и намёков интервьюера я родил вот это:
```
def common_elements(a, b):
b_dict = defaultdict(int) # defaultdict выжил :)
for el in b:
b_dict[el] += 1 # я считаю все элементы из b, т.е. типа collections.Counter
result = []
for el in a:
count = b_dict[el]
if count > 0: # если какой-то элемент из a встречается в b
result.append(a) # то это успех
b_dict[a] -= 1 # и я "вынимаю" его из b, т.е. уменьшаю его количество на 1
return result
```
*Внимательные читатели намекнули, что на строчках 11 и 12 нужно использовать* `el`*, а не* `a`*, но на интервью и так прокатило :)*
Тут же меня спросили, какова сложность алгоритма - ок, норм, это нужно знать, потому что в реальном программировании мне это потребовалось целых 0 раз. Ответил.
После этого задания (и впоследствии) я увидел, что хоть они и принимают рабочие решения, у них есть эталонные, к которым они вас подталкивают, особенно если сложность вашего решения больше сложности эталона. Не то чтобы прям только эталон принимают, но знайте, что он есть.
Кстати, как вы наверно догадываетесь, есть большая разница между решением, написанным в обычной рабочей атмосфере, и решением, написанным на собеседовании в яндекс.блокнотике с интервьюером на связи и ограничением по времени. Здесь и далее я привожу те решения, которые сообразил на интервью, какими бы ужасными они не были. Можно ли написать лучше? Да, в каждой из задач можно лучше.
### Задача 2
Ладно, лоу-левел алгоритмическая муть позади, давайте теперь нормальную задачу, распарсить там что-нибудь или накидать архитектуру высоконагруженного прило...
> *Дана строка (возможно, пустая), состоящая из букв A-Z:* `AAAABBBCCXYZDDDDEEEFFFAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBB`*Нужно написать функцию RLE, которая на выходе даст строку вида:* `A4B3C2XYZD4E3F3A6B28` *И сгенерирует ошибку, если на вход пришла невалидная строка.
> Пояснения: Если символ встречается 1 раз, он остается без изменений; Если символ повторяется более 1 раза, к нему добавляется количество повторений.*
>
>
Ну ок, хотят проверить знание каких-то базовых вещей.
Вроде просто: `for grouper, items in groupby(string)`... А, да, у нас была война. Ничего нет.
```
def convert(s: str) -> str:
result: List[str] = []
last_sym = None # последний символ, что мы видели
count = 0 # и сколько мы его видели
# мы будем идти по строке и записывать в result при смене символа
for sym in (list(s) + [None]): # последний None искусственно триггерит посленюю смену символа
if last_sym and sym != last_sym: # если случилась смена символа
if count == 1:
result.append(last_sym)
else:
result.append(last_sym + str(count))
# начнаем запоминать новый символ
count = 1
last_sym = sym
else: # символ просто повторился
count += 1 # ну ок, запомнили что символ видели на 1 раз больше
return ''.join(result)
```
Не помню точно, но с вероятностью 3 сигма я продолбал граничные условия - это я делать люблю. Помните, тут нельзя ничего запускать, вместо этого тут принято запускать интервьюера, который интерпретирует ваш код прям в голове и говорит какие случаи не работают, чтобы вы могли пропатчить код.
Так, давайте может что-то другое?
### Задача 3
> Дан список интов, повторяющихся элементов в списке нет. Нужно преобразовать это множество в строку, сворачивая соседние по числовому ряду числа в диапазоны. Примеры:
> [1,4,5,2,3,9,8,11,0] => "0-5,8-9,11"
> [1,4,3,2] => "1-4"
> [1,4] => "1,4"
>
>
Так блин, серьёзно? Я наверно очень мутный тип, если две предыдущие задачи не показали мой скилл на этом классе задач.
Ну ок, хотят проверить знание каких-то базовых вещей.
```
def repr(group_start, group_end) -> str:
# это просто правильно печатает группу
if last_group_start == last_group_end:
return str(last_group_end)
return f'{last_group_start}-{last_group_end}'
def squeeze(numbers) -> str:
if not numbers: # граничный случай
return ''
numbers_ = sorted(numbers) # сначала располагаем по порядку
groups = [] # тут будем хранить группы
last_group_start = None
last_group_end = None
for n in numbers_:
# это первая итерация, просто говорим, что группа началась и закончилась
if last_group_end is None:
last_group_start = n
last_group_end = n
# если предыдущая группа отличается от текущего числа на 1,
# то это число входит в группу, то есть становится концом группы
elif last_group_end == n-1:
last_group_end = n
# иначе мы понимаем, что группа закончилась,
# мы её запоминаем и начинаем новую
else:
groups.append(repr(last_group_start, last_group_end))
last_group_start = n
last_group_end = n
else:
# посленюю группу придётся обработать вручную
groups.append(repr(last_group_start, last_group_end))
return ','.join(groups)
```
На этом интервью закончилось, и я стал ждать вестей от рекрутера.
Через пару часов мне сказали, что всё отлично и меня ждут на следующих интервью - 2 штуки подряд - задачи на написание кода. Так, минуточку, а что было до этого - написание *говно*кода? Ладно, там видно будет. Уж точно что-то новенькое, следующий этап всё-таки.
Интервью 2
----------
В назначенный час я бахнул кофейку и встретился в зуме с новым рекрутером. Интервью #2 началось.
### Задача 4
Я, признаюсь, был готов ко всему, но не к этому:
> Дан массив из нулей и единиц. Нужно определить, какой максимальный по длине подинтервал единиц можно получить, удалив ровно один элемент массива.
>
> [1, 1, 0]
>
>
Ну ок, хотят проверить знание каких-то базовых вещей. Вот такой ужас у меня вышел:
```
# пример: [0, 0, 1, 1, 0, 1, 1, 0]
def max_ones_length(lst: List[int]) -> int:
max_ones_length = 0
# тут мы хотим получить сгруппированные 0 или 1 и их количество:
subranges = [] # [(0, 2), (1, 2), (0, 1), (1, 2), (0, 1)]
last_el = None # последний элемент, который мы просмотрели
# идём по элементам списка
for el in lst + [0]: # [0] - это ручной триггер для обработки последнего элемента
if last_el != el: # если произошла смена 0 на 1 или наоборот
if el == 0: # если это была смена 1 на 0
# пример: subranges == [(0, 2), (1, 2), (0, 1), (1, 2)]
# у нас произошла смена 1 на 0, до смены единица шла 2 раза
# (см последний элемент subranges) - проверяем, вдруг это
# максимальная длина
try:
last_ones_length = subranges[-1][1]
max_ones_length = max(last_ones_length, max_ones_length)
except IndexError:
pass
# а может если мы удалим один ноль между элементами 1 и 3,
# то получится более длинная последовательность единиц?
try:
gap_length = subranges[-2][1]
if gap_length == 1:
combined_ones_length = subranges[-1][1] + subranges[-3][1]
max_ones_length = max(combined_ones_length, max_ones_length)
except IndexError:
pass
# добавляем новый счётчик последовательности в subranges
subranges.append((el, 1))
else:
# увеличиваем счётчик последней последовательности на 1
subranges[-1] = (el, subranges[-1][1]+1])
last_el = el
# костыль, граничное условие
if len(subranges) == 2 and subranges[1][1] == 1:
return subranges[0][1] - 1
return max_ones_length
```
Ну что, Яндекс, ты доволен? Ты доволен?! Кто король алгоритмов?! Я король алгоритмов! Давай, удиви меня...
### Задача 5
> Даны даты заезда и отъезда каждого гостя. Для каждого гостя дата заезда строго раньше даты отъезда (то есть каждый гость останавливается хотя бы на одну ночь). В пределах одного дня считается, что сначала старые гости выезжают, а затем въезжают новые. Найти максимальное число постояльцев, которые одновременно проживали в гостинице (считаем, что измерение количества постояльцев происходит в конце дня).
>
> sample = [ (1, 2), (1, 3), (2, 4), (2, 3), ]
>
>
Отлично, тут уже начинает появляться мир - ну там люди, отели, вдруг даже этот код реально где-то когда-то может пригодиться. Я прям вижу, как с каждой задачей будут появляться дороги, поезда, реки, горы и моря, металл, электричество, сервера и датацентры и блин задачи, которые будут работать в дата-центрах и серверах, ну хоть где-нибудь!
Ну ок, хотят проверить знание каких-то базовых вещей.
```
from collections import defaultdict
def max_num_guests(guests: List[tuple]) -> int:
res = 0
# для каждого дня посчитаем, сколько приехало и сколько отъехало
arriving = defaultdict(int)
leaving = defaultdict(int)
for guest in guests: # O(n)
arriving[guest[0]] += 1
leaving[guest[1]] += 1
current = 0
# едем по дням в порядке увеличения, добавлем приехавших и убавляем уехавших,
# считаем сколько стало
for day in sorted(set(arriving.keys()).union(set(leaving.keys()))): # O(n*log(n)) + O(n)
current -= leaving[day]
current += arriving[day]
if current > res:
res = current
return res
```
Не без подсказки интервьюера, но я написал это, и теперь менеджер, наверно, может *эффективно* узнать важную инфу. Круто. Пора прыгать на следующее собеседование (да, они шли одно за другим).
Интервью 3
----------
Новый интервьюер; можно наблюдателя; можно писать заметки; да, я знаю, как работает ваш яндекс.блокнот лучше вас уже, давайте наконец
### Задача 6
> Sample Input ["eat", "tea", "tan", "ate", "nat", "bat"]
> Sample Output [ ["ate", "eat", "tea"], ["nat", "tan"], ["bat"] ]
>
> Т.е. сгруппировать слова по "общим буквам".
>
>
Смутное чувство дежавю посетило меня... Нет, показалось наверно. Ну ок, хотят проверить знание каких-то базовых вещей.
Эта задача простая, наверно хотят удостовериться, что пока я разруливал дела в отеле, я не забыл, как пользоваться словарём. Не лишено смысла! Давайте накидаем что-нибудь простое.
```
def group_words(words: List[str]) -> List[List[str]]:
groups = defaultdict(list)
for word in words: # O(n)
key = sorted(word)
groups[key].append(word)
return [sorted(words) for words in groups.values()] # O(n*log(n))
```
Тут меня спросили "а какая сложность у сортировки", и я воспользовался лайфхаком. Дело в том, что все собеседования проводятся разными людьми, и они вообще не знают ваш контекст - например, о чём я говорил в предыдущих сериях и, например, кхм, сколько алгоритмических задач я прорешал до этого. На прошлом собеседовании меня спросили, какая сложность у сортировки, я не знал и мне сказали - и на этом собеседовании я уже ответил.
### Задача 7
> Слияние отрезков:
>
> Вход: [1, 3] [100, 200] [2, 4]
> Выход: [1, 4] [100, 200]
>
>
Честно говоря, где-то тут мне уже стало плевать на собеседование, Яндекс и все эти алгоритмы, и в реале я бы уже просто послал всех в /dev/null, но мне хотелось знать, что в конце всего этого, ведь конец должен быть? Будет задача, где я завалюсь, и это кончится. Что-то вроде эвтаназии, но в интервью.
Ну ок, хотят проверить знание каких-то базовых вещей.
```
def merge(ranges: List[Tuple[int, int]]) -> List[Tuple[int, int]]:
if not ranges:
return []
result_ranges = []
last_range = None # последний отрезок, что мы видели
for rng in sorted(ranges): # обязательно сортируем
if not last_range:
last_range = rng
continue
# если начало текущего отрезка меньше конца предыдущего
if rng[0] <= last_range[1]:
# расширяем предыдущий отрезок на текущий
last_range = (last_range[0], max(rng[1], last_range[1])
# старый отрезок всё, начинаем новый
else:
result_ranges.append(last_range)
last_range = rng
else:
# граничный случай для последнего элемента
result_ranges.append(last_range)
return result_ranges
```
### Задача 8
Время собеседования подходит к концу, но всё-таки можно ещё поболтать про кодинг и поспрашивать практические вопросы, например по Django или SqlAlchemy:
> Дан массив точек с целочисленными координатами (x, y). Определить, существует ли вертикальная прямая, делящая точки на 2 симметричных относительно этой прямой множества. Note: Для удобства точку можно представлять не как массив [x, y], а как объект {x, y}
>
>
Ну ок, хотят проверить знание каких-то базовых вещей.
Тут я как всегда пошёл куда-то не туда и написал вот что:
```
from statistics import mean
def is_vertical_symmetry(points: List[Point]) -> bool:
# сначала найдём вертикальную прямую в середине всех точек
x_center = mean(p.x for p in points)
# тут будем хранить точки, для которых пока не нашли пары:
unmatched_points = defaultdict(int)
for point in points:
if point.x == x_center: # если точка на прямой, то она сама себе пара
continue
# создадим "брата" - точку, которая симметрична текущей относительно вертикальной прямой
brother = Point(
x = x_center * 2 - point.x,
y = point.y,
)
# если этот брат есть в unmatched_points, то достаём его оттуда и говорим, что текущая точка сматчилась
if unmatched_points[brother]:
unmatched_points[brother] -= 1
# иначе добавляем эту точку в не-сматченные
else:
unmatched_points[point] += 1
return not any(unmatched_points.values())
```
Здесь я прям видел, как интервьюер ожидал что-то другое, а получил меня. Ну бывает. Я тоже, знаете, ожидал собеседование.
Так, третье собеседование пройдено, и эти садисты сказали, что я прошёл дальше. Ну вот за что?
Интервью 4
----------
Честно говоря, вот тут я потерялся, потому что я всё жду, когда начнётся *собеседование*, ну, человеческое собеседование имеется в виду, а пока вместо этого я превращаюсь в алгоритмэна.
По собственным ощущениям я добрался до какого-то мини-босса и на предстоящем интервью у меня должна была пройти какая-то битва на более общие вопросы. А рекрутер мне пишет: знаете, Яндекс настоятельно советует потренироваться на задачках с leetcode. А там опять алгоритмы. Ох, не к добру это...
Ну тут уж я сломился и решил таки глянуть, что там за задачки, раз мне так настойчиво намекают. Вообще там есть сложные, и над ними было прикольно подумать и порешать в уме, но я так и не понял, как это поможет в интервью. Задачек слишком много и, что более важно, они, блин, разные, и решив одну, я не решаю класс задач - я решаю одну задачу. Соответственно либо я решаю их все и зачем мне тогда ваш Яндекс после такого, либо... короче, я опять не готовился. Ответственный человек, помните?
Кстати, где-то в этот момент я узнал, что я юзаю что-то вроде тора, но для собеседований: я общаюсь с рекрутером, мой рекрутер общается с рекрутером Яндекса, а рекрутер Яндекса общается с собеседователями, а может цепочка ещё больше. Меня это поразило прям: вы меня тут дерёте за O(n^2) в решениях, так может я у вас посчитаю длину цепочки от кандидата до собственно интервьюера и спрошу "*а можно оптимальнее?!*"
Итак, началась четвёртое (да, ей-Богу) интервью. Интервьюер спрашивает, на каком языке я буду решать задачки. На [йоптаскрипте](https://yopta.space), разумеется. Кстати, по косвенным признакам я понял, что интервьюер больше в C, чем в питон, и это тоже здорово. Итак: после того как компания решила нанять сеньор питон разраба за 200к и сношала его 3 часа на долбанных задачках, она отправляет на собеседование сишника и спрашивает, на каком языке кандидат будет сношаться с долбанными задачками. Л - логика!
Итак, вот задачка от мини-босса:
### Задание 9
> Даны две строки.
>
> Написать функцию, которая вернёт True, если из первой строки можно получить вторую, совершив не более 1 изменения (== удаление / замена символа).
>
>
Погодите, да это же... Ну ок, хотят проверить знание каких-то базовых вещей. Сссссуууу...пер.
Если вы хотите решить задачу не так, как хотел интервьюер, то смотрите:
```
def no_more_than_one_change(string1: str, string2: str) -> bool:
# string1: a b c d
# string2: a b c
max_length = max(len(string1), len(string2)) # наибольшая длина строк
diff = abs(len(string1) - len(string2)) # разница в длине строк
# дополняем строки до максимальной длины при помощи zip_longest,
# то есть на место "недостающих" элементов ставим None, и строки
# теперь одинаковой длины;
# ---->
# string1: a b c d
# string2: a b c None
# идём слева направо по обеим строкам и сравниваем символы,
# находим индекс, при котором строки начинают отличаться:
change_left = None
for i, (char1, char2) in enumerate(zip_longest(string1, string2)): # O(n)
if char1 != char2:
change_left = i # в нашем примере будет 3
break
else:
# если мы такой индекс не нашли, то строки просто совпадают
return True
# теперь делаем то же, но идём справа налево:
# string1: a b c d
# string2: None a b c
# <----
change_right = None
for j, (char1, char2) in enumerate(zip_longest(reversed(string1), reversed(string2))): # O(n)
if char1 != char2:
# тут строки прям сразу отличаются, т.е. в индексе j=0;
# но это у нас индекс в системе "справа налево",
# а мы его переводим в индекс в системе "слева направо":
i = max_length - j - 1 + diff
break
else:
assert False, 'Я дебил и что-то не учёл'
# ну а теперь смотрим, если строки отличаются в одном и том же месте
# при сканировании слева направо и справа налево, то это нам подходит
return change_left == change_right
```
Внимательный читатель может заметить, что, по-моему, это даже на приведённом примере не работает :) , хотя пофиксить несложно. Так или иначе, вот такие вещи как я написал лично мне тяжело гонять в голове, и интервьюеру тоже; интервьюер принял это как решение, прогнав несколько тестов в уме. Если хотите возвести это в абсолют, то пишите сразу на brainfucke и с умным видом объясняйте, почему оно будет работать. А вообще я просто тонко намекаю, что всё-таки компилятор/интерпретатор под рукой *нужен*.
### Задание 10
Осталось совсем немного времени, и вот в довершение пара реально сложных заданий на понимание многопоточности и gil в python:
> Дан список интов и число-цель. Нужно найти такой range, чтобы сумма его элементов давала число-цель.
>
> elements = [1, -3, 4, 5]
>
> target = 9
>
> result = range(2, 4) # because elements[2] + elements[3] == target
>
>
А теперь все вместе хором: НУ ОК, ХОТЯТ ПРОВЕРИТЬ ЗНАНИЕ КАКИХ-ТО БАЗОВЫХ ВЕЩЕЙ. Вы восхитительны. Спасибо.
Здесь я уже не успевал по времени и озвучил идею: мы бежим по списку и сохраняем в память значения сумм для всех range до этого элемета. Иными словами, для каждого элемента мы пробуем делать ranges, которые кончаются на этом элементе, и смотрим на их сумму элементов.
```
[1, -3, 5, 6, 2, 3, 5]
^____[range(0,1)=1]
[1, -3, 5, 6, 2, 3, 5]
^___[range(0,2)=range(0,1)-3=-2, range(1,2)=-3]
[1, -3, 5, 6, 2, 3, 5]
^___[range(0,3)=range(0,2)+5=3, range(1,3)=range(1,2)+5=2, range(2,3)=5]
```
Не угадал, конечно - "а можно чтобы быстрее?". Но тут, к счастью, время вышло, и мой мозг не успел придумать ничего лучше.
### >> Сейчас я нахожусь здесь <<
Прелесть ситуации в том, что я ещё не получил фидбек, то есть я кандидат Шрёдингера - я и прошёл (формально я все задачи решил), и не прошёл (== не всё угадал, где-то баги), и суперпозиция сколлапсирует, когда ответ пройдёт через всю цепочку рекрутеров ко мне. А пока я полностью беспристрастен, ведь 1) меня не отшили, то есть это не пост обиженного на компанию человека, и 2) мне плевать на результат, потому что мне и на текущей работе офигенно.
К чему всё это
--------------
Вообще это просто так тупо, что забавно, и я не мог с вами не поделиться. Никак не связанные люди тестируют меня на одном и том же типе задач, который максимально оторван от реальности, всё это длится много часов, сложность задач неупорядочена, проверяется всё в голове и никакого фидбека.
Сколько вопросов, блин, можно спросить про http, rest, django orm, sql, python, stdlib, docker, multithreading/multiprocessing/async, да про что угодно - что вы там в лавке делаете? - спросите про похмелье, но зачем 4 часа алгоритмов? Что это показывет - что я устойчив к тупости? Честно говоря, я уже не уверен.
Может кому-то пригодится разбор задачек, ну вдруг вы любитель такого, хотя я уже говорил о качестве решений :)
А если вам нужен вывод, то вот несколько, берите любой:
* Тестировать кандидатов нужно на реальных задачах, а не синтетических
* Нужно уважать время кандидатов
* Кто-то в яндексе пересмотрел "день сурка"
* Знаете, когда целое не равно сумме частей? Вот тут так же: люди тебя собеседуют хорошие и встречи приятные, а в целом всё гавно.
* Открыто новое достижение: ругательство "да пошёл ты в яндекс!"
* Большие компании ай-яй-яй
* Какой-то чувак написал смешную статью
И да, если вы ищете работу на питоне - залетайте к нам. У нас не Яндекс.
Мой канал в телеграме: [Блог погромиста](https://t.me/blog_pogromista). | https://habr.com/ru/post/550088/ | null | ru | null |
# Как решает типичные проблемы программист Google
***От переводчика**: публикуем для вас [перевод статьи Стива Меррита](https://medium.com/@steve_45636/how-a-googler-solves-coding-problems-ec5d59e73ec5), сотрудника Google, который рассказывает о том, как он решает типичные проблемы программирования. Пост будет полезен, в первую очередь, начинающим программистам.*
В этой статье я расскажу о своей стратегии решения проблем, возникающих в ходе работы над проектом, от старта до финиша. Я использую ее в ежедневном рабочем процессе в Google, а также при работе с кодерами любых уровней (коллегами, выпускниками bootcamps, студентами университетов). Структурированная методика минимизирует затраты времени на отладку и одновременно приводит к созданию более качественного кода.
Кстати, эта же стратегия зачастую срабатывает в ходе собеседований в крупных технологичных корпорациях. Три года назад я получил работу в Google благодаря ей.
> **Напоминаем:** *для всех читателей «Хабра» — скидка 10 000 рублей при записи на любой курс Skillbox по промокоду «Хабр».*
>
>
>
> **Skillbox рекомендует:** Образовательный онлайн-курс [«Профессия Java-разработчик»](https://skillbox.ru/java/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=JAVDEV&utm_content=articles&utm_term=googler).
### Шаг за шагом
Я покажу примеры в виде типичных проблем, чтобы раскрыть тему.
Проблема: «Даны две строки, sourceString и searchString, нужно вернуть первый индекс при появлении sourceString в searchString. Если searchString нет в sourceString, вернуть -1».
### 1. Начертите это
Сразу начать писать код — не очень хорошая идея. Сначала необходимо наметить путь решения проблемы. Начните с формирования гипотезы и доказательств своей точки зрения. И приступайте к работе только тогда, когда у вас уже есть четкий план. Если этого не сделать, то, когда работа уже началась, вы можете столкнуться с тем, что отдельные фрагменты кода будут не соответствовать друг другу.
Решение часто может быть нетривиальным, даже если задача выглядит простой. Планирование с использованием бумаги помогает найти верный подход и убедиться в том, что он сработает и в других ситуациях. Причем все это вы узнаете еще до того, как написана первая строка кода.
Поэтому не начинайте писать код, даже не думайте об этом. У вас будет много времени на работу. Вы — человек-компьютер, и вы решаете проблему.
Нанесите на бумагу алгоритм решения. Если вам что-то помогает визуализировать свой план, сделайте это. Задача — решить проблему при помощи карандаша и бумаги, без клавиатуры.
Придумайте простые входные данные. Если функция «передает строку», то «abc» — первый отличный пример. Попробуйте понять, каким должен быть верный результат. Затем подумайте о том, как вы поняли проблему, какие шаги были предприняты.
Представим, что у строк следующие значения:
`sourceString: "abcdyesefgh"
searchString: "yes"`
Итак, мы можем видеть, что searchString находится внутри sourceString. Но как мы к этому пришли? Мы стартовали с начала sourceString и считали его до конца, просматривая каждый трехсимвольный фрагмент, чтобы увидеть, соответствует ли оно слову «yes». Например, «abc», «bcd», «cde» и так далее. Когда мы добрались до индекса 4, мы нашли «yes» и поэтому решили, что есть совпадение, и оно начинается с индекса 4.
В институте у меня был преподаватель, который задал задачу придумать инструкцию по созданию бутерброда с арахисовым маслом. За детальную и понятную инструкцию нам пообещали высшую оценку.
Я написал следующее:
«Откройте арахисовое масло, распределите его по хлебу. Положите сверху еще один кусок хлеба, и все готово».
Я думал, что справился, пока преподаватель не взял масло и не стал намазывать на хлеб, который все еще находился в пластиковой упаковке.
Программы, как и мой учитель, требуют весьма подробных инструкций, чтобы выполнение задачи стало возможным. Поэтому, когда создаем алгоритм, мы убеждаемся, что предусмотрели всё — все возможные сценарии. Возвращение правильного ответа, когда совпадение НАЙДЕНО, — это отлично, но необходимо вернуть ответ и в том случае, если совпадения НЕ НАЙДЕНЫ.
Давайте попробуем снова с другой парой строк:
`sourceString: "abcdyefg"
searchString: "yes"`
Здесь мы начали с начала sourceString и считали его до конца, просматривая каждый трехсимвольный фрагмент, чтобы увидеть, соответствует ли он слову «yes». Когда мы добрались до индекса 4, мы нашли «yef», что было почти совпадением, но неполным, поскольку третий символ отличался. Таким образом мы продолжали считывать, пока не достигли конца строки, а затем решили, что не было совпадения, поэтому вернули -1.
Мы создали серию шагов (в программировании это называют алгоритмом), которые выполняем для решения проблемы, и мы попробовали выполнить несколько сценариев, каждый раз получая правильный результат. На данный момент мы можем быть уверены, что наш алгоритм работает, и теперь пришло время формализовать его, что приведет нас к следующему шагу.
### 2. Записываем алгоритм словами
Это делает шаги реальными, а значит, мы сможем обратиться к ним позже при написании кода.
* Начинаем с начала строки.
* Просматриваем все трехсимвольные комбинации (или сколько там символов указано в searchString).
* Если какие-то из них равны searchString, возвращаем текущий индекс.
* Если мы добрались до конца строки, не найдя соответствия, возвращаем -1.
### 3. Пишем псевдокод
Псевдокод — это не совсем код, но он «притворяется» кодом. Пример того, о чем я говорю, с учетом нашего алгоритма:
`for each index in sourceString,
there are N characters in searchString
let N chars from index onward be called POSSIBLE_MATCH
if POSSIBLE_MATCH is equal to searchString, return index
at the end, if we haven't found a match yet, return -1.`
Я могу сделать его еще более похожим на настоящий код следующим образом:
`for each index in sourceString,
N = searchString.length
POSSIBLE_MATCH = sourceString[index to index+N]
if POSSIBLE_MATCH === searchString:
return index
return -1`
### 4. Переводим в код все, что можем
Сейчас нам придется позаботиться о синтаксисе, параметрах функций и правилах языка. Может быть, вы не можете написать все, и это нормально. Напишите в коде то, что вы точно знаете!
```
function findFirstMatch (searchString, sourceString) {
let length = searchString.length;
for (let index = 0; index < sourceString.length; index++) {
let possibleMatch =
if (possibleMatch === searchString) {
return index;
}
}
return -1;
}
```
Обратите внимание, что я оставил часть этого куска кода пустым. Это намеренно! Я не был уверен в синтаксисе для обработки строк в JavaScript, но об этом дальше.
### 5. Не полагайтесь на удачу
Достаточно распространенная ошибка, особенно у начинающих программистов, — использование чего-либо, найденного в сети, с надеждой на то, что это просто будет работать. Найденный фрагмент просто вставляется в собственный проект без тестирования. Чем больше участков своей программы вы не будете понимать, тем нереалистичнее успешное завершение работы.
Вероятность появления ошибки удваивается при добавлении любого элемента, в котором вы не уверены. В итоге процесс просто выходит из-под контроля.
> Комментарий: вероятность появления ошибки можно рассчитать при помощи последовательности Мерсенна: a (n) = (2 ^ n) — 1
**Протестируйте ваш код.** Найти что-то в сети — это круто, но прежде чем добавить фрагмент в свою программу, опробуйте этот участок отдельно от всего.
В предыдущем шаге я говорил, что не знаю, как можно выбрать определенную часть строки при помощи JavaScript. Давайте поищем в Google.
<https://www.google.com/search?q=how+to+select+part+of+a+string+in+javascript>
Первый результат у нас из w3schools. Немного устарело, но работать будет:
<http://www.w3schools.com/jsref/jsref_substr.asp>
Я предполагаю, что должен использовать substr(index, searchString.length) для выделения части sourceString каждый раз. Но пока что это предположение и ничего более. Поэтому я сначала проверю его.
`let testStr = "abcdefghi"
let subStr = testStr.substr(3, 4); // simple, easy usage
console.log(subStr);
"defg"
subStr = testStr.substr(8, 5); // ask for more chars than exist
"i"`
Теперь я точно знаю, как эта функция работает. Поэтому когда я добавлю этот фрагмент в свою программу, то уже буду знать, что, если она не работает, проблема — не в добавленном участке.
Ну и, наконец, я добавляю последнюю часть кода.
```
function findFirstMatch(searchString, sourceString) {
let length = searchString.length;
for (let index = 0; index < sourceString.length; index++) {
let possibleMatch = (
sourceString.substr(index, searchString.length));
if (possibleMatch === searchString) {
return index;
}
}
return -1;
}
```
### Вывод
Если вы дочитали до конца, попробуйте воспользоваться советом. Найдите проблему, с которой не можете справиться. Я гарантирую, что теперь все получится.
Удачи и счастливого кодинга!
> **Skillbox рекомендует:**
>
>
>
> * Практический курс [«Мобильный разработчик PRO»](https://skillbox.ru/agima/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=AGIMA&utm_content=articles&utm_term=googler).
> * Онлайн-курс [«С#-разработчик с нуля»](https://skillbox.ru/c-sharp/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=CSHDEV&utm_content=articles&utm_term=googler).
> * Двухлетний практический курс [«Я — веб-разработчик PRO»](https://iamwebdev.skillbox.ru/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=WEBDEVPRO&utm_content=articles&utm_term=googler).
> | https://habr.com/ru/post/442048/ | null | ru | null |
# Новый сервис подсказок для поиска в hh.ru
Поисковые подсказки — это здорово. Как часто мы набираем полный адрес сайта в адресной строке? А название товара в интернет-магазине? Для таких коротких запросов обычно хватает ввести несколько символов, если подсказки поиска хороши. И если вы не обладаете двадцатью пальцами или неимоверной скоростью набора текста, то наверняка будете ими пользоваться.
В этой статье мы расскажем о нашем новом сервисе подсказок для поиска по вакансиям hh.ru, который мы сделали в предыдущем выпуске [Школы программистов](https://school.hh.ru/).
У старого сервиса был ряд проблем:
* он работал на отобранных вручную популярных запросах пользователя;
* не мог адаптироваться под изменение пользовательских предпочтений;
* не умел ранжировать запросы, которые не включены в топ;
* не исправлял опечатки.
В новом сервисе мы исправили эти недостатки (параллельно добавив новые).
#### Словарь популярных запросов
Когда совсем нет подсказок, можно вручную отобрать top-N запросов пользователей и формировать подсказки из этих запросов, используя точное вхождение слов (с учетом порядка или без него). Это неплохой вариант — он прост в реализации, дает хорошую точность подсказок и не испытывает проблем с производительностью. Долгое время наш саджест так и работал, но существенный минус такого подхода — недостаточная полнота выдачи.
Например, в такой список не попал запрос «javascript разработчик», поэтому при вводе «javascript раз» нам нечего показать. Если дополнять запрос, учитывая лишь последнее слово, мы увидим на первом месте «javascript разнорабочий». По той же причине не удастся реализовать исправление ошибок сложнее стандартного подхода с поиском ближайших слов по расстоянию Дамерау-Левенштейна.
#### Языковая модель
Другой подход — научиться оценивать вероятности запросов и для пользовательского запроса генерировать наиболее вероятные продолжения. Для этого используют языковые модели — вероятностное распределение на множестве последовательностей слов.
Поскольку запросы пользователей в основном короткие, мы даже не пробовали нейросетевые языковые модели, а ограничились n-граммной:
В качестве простейшей модели можем взять статистическое определение вероятности, тогда
Однако, такая модель не подходит для оценки запросов, которые отсутствовали в нашей выборке: если мы не наблюдали 'junior developer java', то окажется, что
Для решения данной проблемы можно использовать различные модели сглаживания и интерполяции. Мы использовали Backoff:
Где P — сглаженная вероятность  (мы использовали сглаживание Лапласа):
где V — наш словарь.
#### Генерация вариантов
Итак, мы умеем оценивать вероятность конкретного запроса, но как генерировать эти самые запросы? Разумно сделать следующее: пусть пользователь ввел запрос , тогда подходящие нам запросы можно найти из условия
Разумеется, перебирать  вариантов и отбирать из них лучшие для каждого входящего запроса не представляется возможным, поэтому используем [Beam Search](https://en.wikipedia.org/wiki/Beam_search). Для нашей n-граммной языковой модели он сводится к следующему алгоритму:
```
def beam(initial, vocabulary):
variants = [initial]
for i in range(P):
candidates = []
for variant in variants:
candidates.extends(generate_candidates(variant, vocabulary))
variants = sorted(candidates)[:N]
return candidates
def generate_candidates(variant, vocabulary):
top_terms = []
# сначала отбираем наиболее вероятные термы с контекстом из 1, 2, ... n термов
for n0 in range(n):
top_n = sorted(vocabulary, key=lambda c: P(с|variant[-n0:])
top_terms.extends(top_n)
candidates = [variant + [term] for term in top_terms]
# затем отбираем наиболее вероятные составленные предложения
candidates = sorted(candidates, key=lambda v: P(variant))[:N]
return candidates
```
Здесь узлы, подсвеченные зеленым, — итоговые выбранные варианты, число перед узлом  — вероятность , после узла — .
Стало намного лучше, но в generate\_candidates необходимо быстро получать N лучших термов для заданного контекста. В случае хранения только вероятностей n-грамм нам необходимо пройти по всему словарю, вычислить вероятности всех возможных фраз, а затем их отсортировать. Очевидно, что для онлайн-запросов такое не взлетит.
#### Бор для вероятностей
Для быстрого получения N лучших по условной вероятности вариантов продолжений фразы мы использовали бор на термах. В узле  хранится коэффициент , значение  и отсортированный по условной вероятности  список термов  вместе с . Специальный терм *eos* обозначает конец фразы.
#### Но есть нюанс
В описанном выше алгоритме мы исходим из того, что в запросе все слова были закончены. Однако, это не верно для последнего слова, которое пользователь вводит его прямо сейчас. Нам снова необходимо пройти по всему словарю, чтобы продолжить текущее вводимое слово. Для решения этой проблемы мы используем посимвольный бор, в узлах которого храним M отсортированных по униграммной вероятности термов. Например, так будет выглядеть наш бор для java, junior, jupyter, javascript при M=3:
Тогда перед началом Beam Search, находим M лучших кандидатов для продолжения текущего слова  и отбираем N лучших кандидатов по .
#### Опечатки
Отлично, мы построили сервис, который позволяет давать неплохие подсказки для пользовательского запроса. Мы даже готовы к появлению новых слов. И все бы хорошо… **Но пользовтели опечтыватся и не переключают hfcrkflre клавиатуры.**
Как это решить? Первым делом на ум приходит поиск исправлений с помощью нахождения ближайших вариантов по расстоянию Дамерау-Левенштейна, которое определяется как минимальное количество операций вставки/удаления/замены символа или транспозиции двух соседних, необходимых для получения из одной строки другой. К сожалению, данное расстояние не учитывает вероятность той или иной замены. Так, для введенного слова «сапрщик», получим, что варианты «сборщик» и «сварщик» равноценны, хотя интуитивно кажется, что имели в виду второе слово.
Вторая проблема — мы не учитываем контекст, в котором произошла ошибка. Например, в запросе «сапрщик заказов» мы должны все-таки предпочесть вариант «сборщик», а не «сварщик».
Если подойти к задаче исправления опечаток с вероятностной точки зрения, то вполне естественно прийти к [модели зашумленного канала](https://en.wikipedia.org/wiki/Noisy_channel_model):
1. задан алфавит ;
2. множество всех конечных строк  над ним;
3. множество строк, являющихся правильными словами ;
4. заданы распределения , где .
Затем задача исправления ставится как нахождение правильного слова w для входа s. В зависимости от источника ошибок, мера  может строиться по-разному, в нашем случае разумно попробовать оценить вероятность опечаток (назовем их элементарными заменами) , где t, r — символьные n-граммы, а затем оценивать  как вероятность получить s из w наиболее вероятными элементарными заменами.
Пусть  — разбиение строки x на n подстрок (возможно нулевых). Модель Брилла-Мура предполагает вычисление вероятности  следующим образом:
Но нам необходимо найти :
Научившись оценивать P(w|s), мы решим и проблему ранжирования вариантов с одинаковым расстоянием Дамерау-Левенштейна и сможем учитывать контекст при исправлении опечатки.
#### Вычисление $P_e(T_i | R_i)$
Для подсчета вероятностей элементарных замен нам вновь помогут пользовательские запросы: составим пары слов (s, w) которые
1. близки по Дамерау-Левенштейну;
2. одно из слов встречается чаще другого в N раз.
Для таких пар рассмотрим оптимальное выравнивание по Левенштейну:
Составим всевозможные разбиения s и w (мы ограничились длинами n=2, 3): п→п, пр→рп, про→рпо, ро→по, м→'', мм→м и т.д. Для каждой n-граммы найдем 
#### Вычисление $P(s|w)$
Вычисление  напрямую занимает : нам нужно перебрать все возможные разбиения w со всеми возможными разбиениями s. Однако, динамикой на префиксе можно получить ответ за , где n — максимальная длина элементарных замен:
![$d[i,j]=\begin{cases} d[0,j] = 0 & j >= k\\ d[i,0] = 0 & i >= k\\ d[0,j] = P(s[0:j]\space |\space w[0]) & j < k\\ d[i,0] = P(s[0]\space |\space w[0:i]) & i < k\\ d[i,j] = \underset{k, l \le n, k\lt i, l \lt j}{max}(P(s[j-l:j]\space | \space w[i-k:i])\cdot d[i-k-1,j-l-1]) \end{cases}$](https://habrastorage.org/getpro/habr/formulas/baa/5eb/f94/baa5ebf94f11d8755da2b4bbe2f14049.svg)
Здесь P — вероятность соответствующей строки в k-граммной модели. Если приглядеться, то это очень похоже на алгоритм Вагнера-Фишера с отсечением Укконена. На каждом шаге мы получаем ![$P(w[0:i] | s[0:j])$](https://habrastorage.org/getpro/habr/formulas/90b/5dc/dd2/90b5dcdd271fada2aff48df1db57956a.svg) путем перебора всех вариантов исправлений ![$w[i-k:i]$](https://habrastorage.org/getpro/habr/formulas/4e2/8fe/e7e/4e28fee7e1e53314b21e7f280c9c5ff4.svg) в ![$s[j-l : j]$](https://habrastorage.org/getpro/habr/formulas/c6f/5c5/4c5/c6f5c54c5b9fffa7a945658d3f05c271.svg) при условии  и выбора из них наиболее вероятного.
#### Возвращаемся к $P(w|s)$
Итак, мы умеем вычислять . Теперь нам нужно выбрать несколько вариантов w, максимизирующих . Точнее, для исходного запроса  необходимо выбрать такие , где  максимальна. К сожалению, честный выбор вариантов не укладывался в наши требования по времени отклика (а срок проекта подходил к концу), поэтому мы решили остановиться на следующем подходе:
1. из исходного запроса получаем несколько вариантов, изменяя k последних слов:
1. исправляем раскладку клавиатуры, если у получившегося терма вероятность в несколько раз выше исходного;
2. находим слова, расстояние Дамерау-Левенштейна которых не превосходит d;
3. выбираем из них top-N вариантов по ;
2. передаем на вход BeamSearch вместе с исходным запросом;
3. при ранжировании результатов дисконтируем полученные варианты на .
Для п.1.2 мы использовали алгоритм FB-Trie (forward and backward trie), основанный на нечетком поиске по прямому и обратному префиксному дереву. Это оказалось быстрее, чем оценивать P(s|w) по всему словарю.
#### Статистика запросов
С построением языковой модели все просто: собираем статистику по пользовательским запросам (сколько раз делали запрос данной фразы, какое количество пользователей, какое количество зарегистрированных пользователей), разбиваем запросы на n-граммы и строим боры. Сложнее с моделью ошибок: как минимум, для ее построения необходим словарь правильных слов. Как было сказано выше, для выбора обучающих пар мы использовали предположение, что такие пары должны быть близки по расстоянию Дамерау-Левенштейна, и одно должно встречаться чаще другого в некоторое количество раз.
Но данные все равно слишком шумные: попытки xss-инъекций, неверная раскладка, случайный текст из буфера обмена, опытные пользователи с запросами «программист c not 1c», ~~запросы от прошедшего по клавиатуре кота~~.
**Например, что пытались найти по такому запросу?**
Поэтому для очистки исходных данных мы исключали:
* низкочастотные термы;
* содержащие операторы языка запросов;
* обсценную лексику.
А также исправляли раскладку клавиатуры, сверялись со словами из текстов вакансий и открытых словарей. Разумеется, всего исправить не удалось, но такие варианты обычно либо совсем отсекаются, либо находятся внизу списка.
#### В прод
Прямо перед защитой проектов запустили сервис в продакшн для внутреннего тестирования, а спустя пару дней — на 20% пользователей. В hh.ru все значимые для пользователей изменения проходят через [систему АБ-тестов](https://habr.com/ru/company/hh/blog/321386), что позволяет не только быть уверенным в значимости и качестве изменений, но и [находить ошибки](https://youtu.be/V_KmTqIxJXU?t=1162).
Прокрасилась метрика среднего количества поисков из саджеста на соискателей (увеличилось с 0.959 до 1.1355), а доля поисков из саджеста от всех поисковых запросов увеличилась с 12.78% до 15.04%. К сожалению, основные продуктовые метрики не выросли, но пользователи определенно стали чаще пользоваться подсказками.
#### Напоследок
В статье не нашлось места для рассказа о процессах Школы, о других опробованных моделях, об инструментах, которые мы написали для сравнений моделей, и о встречах, где решали, какие фичи взять в разработку, чтобы успеть к промежуточным демо. Посмотрите [записи прошедшей школы](https://www.youtube.com/playlist?list=PLGn25JCaSSFQQOab_xMXI3vJ0tDUkFaCI), оставляйте заявку на <https://school.hh.ru>, выполняйте интересные задачи и приходите учиться. Кстати, сервис для проверки задач также сделали выпускники предыдущего набора.
#### Что почитать?
1. [Введение в Language Model](https://medium.com/syncedreview/language-model-a-survey-of-the-state-of-the-art-technology-64d1a2e5a466)
2. [Модель Брилла-Мура](https://www.cis.uni-muenchen.de/people/Schulz/Pub/aspaperCISreport.pdf)
3. [FB-Trie](https://www.aclweb.org/anthology/P00-1037)
4. [Что происходит с вашим запросом в поиске](https://habr.com/ru/company/hh/blog/413261) | https://habr.com/ru/post/464415/ | null | ru | null |
# Создание сложного списка элементов за 20 минут в Android на базе Groupie
Списки являются основным способом представления различного контента в мобильных приложениях. Будь то социальная сеть, приложение для чтения книг или интернет-магазин, в большинстве таких приложений встречаются списки с разными видами ячеек, разного уровня вложенности. Самый наглядный пример, известный любому Android-разработчику — это приложение Google Play, начальный экран которого является сложным списком с множеством вложенных элементов.
Естественно, чтобы поддержать такое разнообразие контента и при этом сохранить оптимальную производительность для такой задачи лучше всего использовать RecyclerView. Как создать список, поддерживающий разные виды ячеек, которые в свою очередь могут тоже содержать вложенные списки за 20 минут, я покажу на примере в этой статье.
В конце у вас получится вот такой список:
Итак, задача: создать список для отображения различного вида контента, при этом каждая категория, то есть ячейка списка может содержать неограниченное количество более мелких ячеек и иметь горизонтальный скрол. Звучит сложно? Если вы думаете что это сложная задача, над которой вам нужно будет работать всю неделю, то спешу вас обрадовать, мы сделаем такой список примерно на полчаса.
Подходов к решению такой задачи, множество, но суть решения одна — здесь необходимо использовать RecyclerView с различными типами ячеек, в которых также находится RecyclerView для возможности горизонтального скролла неограниченного количества ячеек. Можно использовать как стандартный подход, в котором необходимо будет создать adapter для каждого из списков, ViewHolders для разного типа ячеек и так далее. А можно использовать более быстрый подход без множества похожего кода на базе библиотеки Groupie
> Groupie is a simple, flexible library for complex RecyclerView layouts.
Это простая и в тоже время мощная библиотека для упрощения построения списков на базе RecyclerView, которая заметно ускорит разработку сложных списков как в примерах выше.
Безусловно, все что мы видели можно сделать и без этой библиотеки, тем более совсем недавно в Android появился MergeAdapter (если будет интересно, то в следующей статье напишу и про него). Но так или иначе вы столкнётесь с недостатками стандартного подхода, описанного в той же статье. Поэтому, сегодня мы попробуем новый подход, ускоряющий разработку, избавляющий от написания бойлерплейт-кода и соответсвующий принципам SOLID.
Если кратко, то алгоритм действий выглядит следующим:
* Создаём проект. Добавляем нужные зависимости.
* Определяем нужные ячейки. Создаём layouts для отображения UI
* Соединяем ячейки с адаптером RecyclerView и наслаждаемся результатом.
### Создание проекта и добавление библиотек.
Для создания списка как в примере на картинке нам понадобится 4 библиотеки: RecyclerView, CardView, Picasso (для отображения картинок) и Groupie. Добавим всё это в build.gradle(app):
```
implementation 'com.xwray:groupie:2.8.0'
implementation 'com.xwray:groupie-kotlin-android-extensions:2.8.0'
implementation "androidx.recyclerview:recyclerview:1.1.0"
implementation 'com.squareup.picasso:picasso:2.71828'
implementation 'androidx.cardview:cardview:1.0.0'
```
Кроме этого, добавьте в build.gradle в блок android
```
androidExtensions {
experimental = true
}
```
Нажмите Sync Now для скачивания необходимых зависимостей.
### Создание ячеек для отображения контента
Для отображения списка нам понадобится 3 типа ячеек:
* Общая ячейка — контейнер для отображения вложенного списка. Обозначена красным прямоугольником.
* Ячейка внутри основной ячейки для отображения информации о фильме. Такие ячейки выделены синим прямоугольником. Они находятся внутри основной ячейки в RecyclerView c горизонтальным скролом.
* Квадратная ячейка для отображения обложек игр. Выделена зелёным цветом.
### Создание главной ячейки с вложенным RecyclerView
Вначале создадим общую ячейку с вложенным RecyclerView для отображения более мелких ячеек.
Вёрстка такой ячейки будет состоять из CardView с LinearLayout для отображения названия, описания и RecyclerView для отображения внутренних ячеек.
```
xml version="1.0" encoding="utf-8"?
```
Теперь создадим логику для отображения данных ячейки.
```
class MainCardContainer(
private val title: String? = "",
private val description: String? = "",
private val onClick: (url: String) -> Unit,
private val items: List
) : Item() {
override fun getLayout() = R.layout.item\_card
override fun bind(viewHolder: GroupieViewHolder, position: Int) {
viewHolder.title\_text\_view.text = title
viewHolder.description\_text\_view.text = description
viewHolder.items\_container.adapter =
GroupAdapter().apply { addAll(items) }
}
}
```
Каждая ячейка при использовании Groupie должна быть наследником от абстрактного класса Item. Для этого необходимо переопределить всего 2 метода getLayout() и bind(). То есть для создания ячейки вам нужно указать layout который будет использоваться для отображения UI и дописать логику формирования данных для этой ячейки и всё! Теперь не нужно писать однотипные адаптеры для разных ячеек или комбинировать множество разных типов ячеек в одном адаптере, нарушая принципы SOLID. Ну или выдумывать базовые классы для ячеек, только для того, чтобы можно было переиспользовать один и тот же адаптер. C Groupie для каждой ячейки вам необходимо создать свой класс, и описать в нем UI!
В данном пример мы будем использовать одну общую ячейку, которая на вход принимает название, описание и список других Item, то есть ячеек, которые и будут наполнять вложенный в эту ячейку RecyclerView. Самое интересное тут, пожалуй вот эта строчка:
```
viewHolder.items_container.adapter =
GroupAdapter().apply { addAll(items) }
```
То есть для RecyclerView который внутри этой ячейки, необходимо добавить общий GroupAdapter и наполнить его ячейками, которые являются наследниками Item.
Общий контейнер готов, теперь осталось сверстать частные ячейки для каждого типа контента.
Их будет 2:
* Ячейка для фильма с названием фильма
* Квадратная ячейка с обложкой игры
### Ячейка для фильма
Ячейка для фильма, также должна быть наследником Item и должна реализовать 2 метода:
```
class MovieItem(private val content: MovieContent) : Item() {
override fun getLayout() = R.layout.item_with_text
override fun bind(viewHolder: GroupieViewHolder, position: Int) {
viewHolder.description.text = content.title
Picasso.get()
.load(content.url)
.into(viewHolder.image_preview)
}
}
```
Верстка достаточно простая и код можно посмотреть в проекте на GitHub.
### Квадратная ячейка для отображения обложки игры
Эта ячейка тоже является достаточно простой, поэтому лучше посмотрите код проекта.
### Все вместе. Соединяем все ячейки вместе
Для создания списка теперь нужно создать ячейки с контентом и передать их в адаптер RecyclerView. Для создания ячеек были созданы 2 метода getPopularMovies() и getPopularGames() которые возвращают ячейки типа Item.
```
private fun getPopularMovies(): Item {
return MainCardContainer(
"Список фильмов", "Лучшие фильмы", ::onItemClick,
listOf(
MovieItem(
MovieContent(
"Джокер",
"https://upload.wikimedia.....jpg"
)
),
MovieItem(
MovieContent(
"Бойцовский клуб",
"https://upload.wikimedia.org......jpg"
)
)
)
)
}
```
Каждый из методов возвращает 1 ячейку MainCardContainer — которой передаётся в качестве аргумента список ячеек уже с контентом для вложенного RecyclerView. Например, для ячейки которая отображает список фильмов нужно указать список ячеек MovieItem. Для второй ячейки, которая отображает список игр — мы создадим также метод, который создаст основную общую ячейку и передаст ячейки с играми.
В итоге создание списка теперь будет выглядеть так:
```
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val movies = listOf(getPopularMovies(), getPopularGames())
items_container.adapter =
GroupAdapter().apply { addAll(movies) }
}
```
Последняя строка как раз использует GroupAdapter в который мы можем передать любые ячейки, которые являются наследниками Item.
Ну вот и всё! Буквально за 20 минут мы создали сложный список для отображения различного типа контента с вложенным горизонтальным списком! Сравните такой подход с традиционным и сделайте выводы сами! Абсолютно точно, такой подход сэкономит вам время на разработку подобных UI — компонентов и избавит от кучи бесполезного кода. А в телеграм-канале [@android\_school\_ru](https://t.me/android_school_ru) и [на сайте](https://androidschool.ru/) вы сможете найти ещё больше современных туториалов на Kotlin и бесплатных мини-курсов для Android-разработчиков.
Исходный код из статьи можно [посмотреть на GitHub](https://github.com/AndroidStudentClub/Groupie-Sample) | https://habr.com/ru/post/523768/ | null | ru | null |
# Компонент Slider из библиотеки материального дизайна
Началось с небольшой детективной истории — разглядывая сайт Material Design, наткнулся на страницу [Sliders](https://material.io/components/sliders#). В описании говорилось, что данный компонент доступен для Android и даже дана ссылка на [Гитхаб](https://github.com/material-components/material-components-android/blob/master/docs/components/Slider.md). Меня это немножко удивило, так как я ни разу о нём не слышал. Перехожу по ссылке — на Гитхабе говорится, что компонент пока находится в активной разработке и даны куцые примеры на Java. «В этих ваших интернетах» упоминания о **Slider** не нашёл. В [официальной документации по библиотеке](https://developer.android.com/reference/com/google/android/material/packages) тоже нет никаких упоминаний.
К счастью, есть [исходники](https://github.com/material-components/material-components-android/blob/master/lib/java/com/google/android/material/slider/Slider.java).
Любопытство взяло верх и я стал самостоятельно копаться.
По своему внешнему виду **Slider** похож на стандартный **Seekbar**. Но небольшие отличия есть. Чтобы их увидеть, набросал простой проект. Добавим пару слайдеров на экран, кнопку и посмотрим на компонент в действии.
Я использовал последнюю версию библиотеки.
```
implementation 'com.google.android.material:material:1.2.0-alpha06'
```
Разметка:
```
xml version="1.0" encoding="utf-8"?
```
На всякий случай замечу, что когда я вручную прописал код, то Android Studio отказывалась показывать экран активности в режиме «Design», пришлось перезапускать студию. После этого всё нормализовалось.
Код для класса активности.
```
// Если этот код работает, его написал Александр Климов,
// а если нет, то не знаю, кто его писал.
// http://developer.alexanderklimov.ru/android/
package ru.alexanderklimov.as36
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import com.google.android.material.slider.Slider
import kotlinx.android.synthetic.main.activity_main.*
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
button.setOnClickListener {
slider.value = 5.0F
}
slider.values = listOf(1F, 4F, 6F)
slider.addOnSliderTouchListener(object : Slider.OnSliderTouchListener {
override fun onStartTrackingTouch(slider: Slider) {
println("Start Tracking Touch")
}
override fun onStopTrackingTouch(slider: Slider) {
println("Stop Tracking Touch")
}
})
}
}
```
Запускаем и смотрим на результат.
Первое что бросается в глаза — мы можем установить несколько ползунков через **slider.values**. Они ведут себя независимо и не мешают друг другу.
У второго слайдера установлен дискретный режим через атрибут **android:stepSize**. Можно заметить, что в этом режиме на дорожке появились маленькие точки.
Если нажать на ползунок, то сверху появляется плашка с указанием текущего значения.
Щелчок на кнопке программно установит ползунок в нужном месте у первого слайдера. Учтите, что в нашем случае компонент превратится в ~~тыкву~~ слайдер с одним ползунком, так как мы сбросили список значений, оставив только одно.
У слайдера есть несколько слушателей. Для демонстрации привёл один из них — **Slider.OnSliderTouchListener**.
Текст на плашке можно менять. Это пригодится, когда используются большие числа. Тогда вместо чисел с большим количеством нулей (миллионы, триллионы и т.д.) можно использовать сокращенные варианты. За это поведение отвечает интерфейс **LabelFormatter**. Также существует вспомогательный интерфейс **BasicLabelFormatter**, который уже содержит полезные сокращения больших чисел типа 9.1K вместо 9100.
Давайте немного пошалим и напишем слово из трёх букв.
```
slider2.setLabelFormatter {
"Кот"
}
```
Новый элемент показался интересным и вполне пригодным для использования в проекте. | https://habr.com/ru/post/497652/ | null | ru | null |
# WebDav и Nginx
Приветствую вас, господа.
Не так давно в одном из своих проектов мне понадобилось иметь возможность передачи файлов посредством метода PUT, без скрипта-обработчика на принимающей стороне, принять и обработать файл должен был сам сервер. Так же была задача реализовать это не на Apache, а на его собрате — Nginx.
В итоге своих изысканий у меня получилась такая схема — скрипт на PHP получает адрес файла и делает запрос к серверу, а он в свою очередь получает файл и складывает в требуемую папочку.
Приводить дальнейшие примеры по установке, настройке и отработке взаимодействий я буду отталкиваясь от debian-based ОС.
Сторона сервера, Nginx
======================
Скачиваем, компилируем и устанавливаем сервер с требуемым [модулем](http://wiki.nginx.org/HttpDavModule):
`wget nginx.org/download/nginx-1.1.1.tar.gz
tar -xvf nginx-1.1.1.tar.gz
cd nginx-1.1.1
./configure --sbin-path=/usr/sbin --conf-path=/etc/nginx/nginx.conf \
--error-log-path=/var/log/nginx/error.log \
--pid-path=/var/run/nginx.pid \
--lock-path=/var/lock/nginx.lock \
--http-log-path=/var/log/nginx/access.log \
--http-client-body-temp-path=/var/lib/nginx/body \
--http-proxy-temp-path=/var/lib/nginx/proxy \
--http-fastcgi-temp-path=/var/lib/nginx/fastcgi \
--with-http_stub_status_module \
--with-http_ssl_module \
**--with-http\_dav\_module**
make && make install`
Настраиваем конфигурацию:
При компиляции мы указали что конфигурационный файл будет лежать в /etc/nginx/nginx.conf
Прописываем новую секцию server, так как надо чтобы webdav работал на другом порту — так, и безопасней, и удобней.
`server {
listen 7500; #порт на котором будет слушать nginx
server_name ip-адрес-сервера;
charset utf-8;
location /{
expires max;
root /путь/до/требуемой/папки; #по этому пути будут складываться полученный PUT'ом файлы
client_max_body_size 20m;
client_body_temp_path /usr/local/nginx/html/;
dav_methods PUT; #разрешенные методы, нам требуется только PUT
create_full_put_path on; #при отсутствии вложенных папок, при включенной директиве, nginx автоматически создаст иерархию
dav_access user:rw group:r all:r; #права на файлы
limit_except GET {
allow all;
}
}
}`
*Хочу так же заметить что с настроенным модулем так же отрабатывают и остальные директивы WebDav указанные в конфигурационном файле Nginx: DELETE, MKCOL, COPY, MOVE.*
Сторона «клиента», второго сервера, PHP-скрипт
==============================================
Оговорим что в переменной $namefile уже содержится имя файла вида file.zip полученное тем или иным способом.
`$url = "ip-адрес-сервера:7500/$namefile";
$file = "/files/$namefile";
$fp = fopen($file, "r");
$curl = curl_init();
curl_setopt($curl, CURLOPT_VERBOSE, 1);
curl_setopt($curl, CURLOPT_URL, $url);
curl_setopt($curl, CURLOPT_PUT, 1);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($curl, CURLOPT_INFILE, $fp);
curl_setopt($curl, CURLOPT_INFILESIZE, filesize($file));
curl_close($curl);
fclose($fp);`
Итог
====
Теперь, когда все установлено и настроено, мы можем обратиться к скрипту, передать путь до файла и скрипт передаст наш файл серверу, который в свою очередь без PHP, Perl или написанного на другом языке обработчика сможет принять и разместить файл на другом сервере.
Надеюсь что написанный текст был вам интересен, за сим откланяюсь. | https://habr.com/ru/post/127232/ | null | ru | null |
# Развернуть дата-центр за время доставки пиццы
— Да этот ЦОД можно развернуть и настроить, пока ты пиццу заказываешь!
Я бросил эти слова на совещании, и расплата пришла немедленно. Коллега предложила заказать пиццу. Оплачивает проигравший: если я успеваю собрать ЦОД — то она, если не успеваю — то я.
Чёрт!
В общем, встречайте стресс-тест: гиперконвергентное решение от Cisco с простой настройкой против приготовления пиццы.
### Что это такое
К нам на тест пришло гиперконвергентное решение от Cisco. [Вот прошлый пост](https://habr.com/ru/company/croc/blog/471508/) с самим тестом и деталями по железу.
Что имеем:
* Четыре ноды хранения Cisco UCS HXAF240 M4.
* Два Cisco UCS Fabric Interconnect 6248UP.
* Существующий vCenter для добавления туда кластера.
* Коммутатор с портами, работающими на скорости 10 Гбит/с (в проде, пожалуйста, используйте два коммутатора для отказоустойчивости).
Начнём.
**12:28**
Я замонтировал и скоммутировал железки заранее. Серверы подключаем в FI, пару FI подключаем в 10G-коммутатор.
Примерно в это время моя коллега Марина установила приложение и разобралась с заказом.
**12:35**
Пошёл обратный отсчёт заказа. У вендора SLA — один час на доставку, и мне этого должно хватить. Пошёл инициализировать кластер FI.
Кластер можно проинициализировать из web-консольки, если у вас есть DHCP в сети, или подключиться к COM-порту FI и ввести все данные. Я предпочитаю старый надёжный способ через консольку (скорость стандартная — 9 600).
Для инициализации первого FI вводим IP управления и кластерный IP, пароль для админской учётки и параметры DNS при желании.
> `Enter the configuration method. (console/gui) ? console
>
>
>
> Enter the setup mode; setup newly or restore from backup. (setup/restore) ? setup
>
>
>
> You have chosen to setup a new Fabric interconnect. Continue? (y/n): y
>
>
>
> Enforce strong password? (y/n) [y]: n
>
>
>
> Enter the password for "admin":
>
> Confirm the password for "admin":
>
>
>
> Is this Fabric interconnect part of a cluster(select 'no' for standalone)? (yes/no) [n]: yes
>
>
>
> Enter the switch fabric (A/B) []: A
>
>
>
> Enter the system name: HX
>
>
>
> Physical Switch Mgmt0 IP address : XXX.XXX.XXX.XXX
>
>
>
> Physical Switch Mgmt0 IPv4 netmask : XXX.XXX.XXX.XXX
>
>
>
> IPv4 address of the default gateway : XXX.XXX.XXX.XXX
>
>
>
> Cluster IPv4 address : XXX.XXX.XXX.XXX
>
>
>
> Configure the DNS Server IP address? (yes/no) [n]:
>
>
>
> Configure the default domain name? (yes/no) [n]:
>
>
>
> Join centralized management environment (UCS Central)? (yes/no) [n]:
>
>
>
> Following configurations will be applied:
>
>
>
> Switch Fabric=A
>
> System Name=HX
>
> Enforced Strong Password=no
>
> Physical Switch Mgmt0 IP Address= XXX.XXX.XXX.XXX
>
> Physical Switch Mgmt0 IP Netmask= XXX.XXX.XXX.XXX
>
> Default Gateway= XXX.XXX.XXX.XXX
>
> Ipv6 value=0
>
>
>
> Cluster Enabled=yes
>
> Cluster IP Address= XXX.XXX.XXX.XXX
>
> NOTE: Cluster IP will be configured only after both Fabric Interconnects are initialized
>
>
>
> Apply and save the configuration (select 'no' if you want to re-enter)? (yes/no): yes
>
> Applying configuration. Please wait.
>
>
>
> Configuration file - Ok
>
>
>
> Cisco UCS 6200 Series Fabric Interconnect`
Второй FI видит, что у него уже есть сосед, и предлагает добавить себя в кластер.
> `Enter the configuration method. (console/gui) ? console
>
>
>
> Installer has detected the presence of a peer Fabric interconnect. This Fabric interconnect will be added to the cluster. Continue (y/n) ? y
>
>
>
> Enter the admin password of the peer Fabric interconnect:
>
> Connecting to peer Fabric interconnect... done
>
> Retrieving config from peer Fabric interconnect... done
>
> Peer Fabric interconnect Mgmt0 IPv4 Address: XXX.XXX.XXX.XXX
>
> Peer Fabric interconnect Mgmt0 IPv4 Netmask: XXX.XXX.XXX.XXX
>
> Cluster IPv4 address : XXX.XXX.XXX.XXX
>
>
>
> Peer FI is IPv4 Cluster enabled. Please Provide Local Fabric Interconnect Mgmt0 IPv4 Address
>
>
>
> Physical Switch Mgmt0 IP address : XXX.XXX.XXX.XXX
>
>
>
> Apply and save the configuration (select 'no' if you want to re-enter)? (yes/no): yes
>
> Applying configuration. Please wait.
>
>
>
> Configuration file - Ok
>
>
>
> Cisco UCS 6200 Series Fabric Interconnect`
Коллеги из Додо предоставили фотографии процесса испекания пиццы (это другая пицца, не та, что приехала, но такая же):
**12:41. Настройка кластера FI**
Большую часть настроек выполнит установщик HyperFlex, нам же нужно указать роли портов у FI (в установщик ещё не внедрили ИИ, и угадать, что и куда мы подключили, он пока не может). В нашем случае нужно указать порты, куда подключены серверы (Server Port), и указать аплинки до вышестоящего коммутатора (Uplink Port).
После поднятия серверных портов UCSM (Cisco UCS Manager — управлялка FI и серверами, крутится на FI) найдёт за ними наши серверы и начнёт их инициализировать. Это займёт какое-то время.
В это время:
**12:45. Разливка установщика HyperFlex**
Установщик HyperFlex поставляется в виде шаблона. Тут ничего интересного: разливаем OVA-шаблон, попутно внося данные об IP и пароле для доступа в инсталлятор. Я ленив, поэтому отдал всё на откуп DHCP и пару раз ввёл пароль. ВМ нужна только при создании кластера и таких операциях, как добавление нод в кластер, создание Metro-кластера или его обновление. Поэтому её можно будет отключить и не тратить ресурсы.
**13:05. Настройка кластера HyperFlex**
UCSM нашёл наши серверы, определил конфигурацию и готов действовать дальше.
Смотрим адрес установщика и подключаемся на его WEB-интерфейс, выбираем пункт создания стандартного кластера.
Вводим IP и учётные данные от UCSM и vCenter.
Выбираем серверы для добавления в кластер.
Далее нам нужно указать VLAN и адресацию для сети управления, vMotion, сети синхронизации данных между нодами и сети для размещения виртуальных машин.
Выбираем серверы, которые хотим добавить в кластер, указываем адресацию для гипервизоров и новый пароль от рута.
Жмём пару раз Next и идём пить чай.
Это самый длительный этап, потому что установщик создаёт профили для серверов в UCSM, подключается к гипервизору и вносит все заданные настройки, разливает сервисную ВМ на каждом хосте, добавляет серверы в vCenter.
При этом установщик рапортует о текущем шаге и о возникших ошибках. Если некорректно ввели пароль или VLAN, то будет предложено скорректировать данные и начать с последнего успешного этапа.
**Пицца приехала!**
Чёртова пицца доставлена существенно быстрее, чем мне бы хотелось. Это первый раз, когда я жалею, что её привезли раньше.
**13:55. Создание датасторов**
Установщик выполнил свою работу, и кластер фактически готов. Для полноценной работы нам не хватает датасторов. Идём на вебку контроллера управления HyperFlex и выбираем раздел Datastores.
По умолчанию серверы создаются со стандартными коммутаторами (vSwitch) и одним VLAN для сетей ВМ. Но можно создать и распределённый коммутатор (все сервисные сети остаются на стандартном) и дополнительно нарезать новые VLAN, проблем не будет. К тому же у UCS есть возможность интеграции с Cisco ACI, что тоже не будет лишним для владельцев SDN от Cisco.
Всё. Общее время настройки ЦОДа — полтора часа. Доставка пиццы — чуть меньше 40 минут при SLA в один час. Ладно, по крайней мере, это было сравнимо. Итог: 1 час 30 минут, я успел развернуть кластер и поесть.
### Ссылки
* [Тесты решения](https://habr.com/ru/company/croc/blog/471508/)
* Моя почта — StGeneralov@croc.ru. | https://habr.com/ru/post/472406/ | null | ru | null |
# Много лицензий, хороших и разных
Copyright [CartoonStock](http://www.cartoonstock.com/)
В своё время я писал про [то](http://habrahabr.ru/company/intel/blog/206016/), какие типы лицензий есть у Intel и как всё это дело работает. Тот пост крайне рекомендуем к прочтению, потому что принцип лицензирования остался неизменным. Но прошло достаточное количество времени и некоторые моменты серьёзно изменились. Давайте разберёмся в них.
Как обычно, самую последнюю информацию в «сухих» юридических формулировках про лицензирование можно найти в [EULA](https://software.intel.com/sites/default/files/managed/c0/5f/Master-EULA-for-Intel-Sw-Development-Products-March-2015.pdf) (End User License Agreement). Последний документ датирован мартом этого года, и является основным юридическим документом для всех программных решений (компиляторы, пакеты средств Parallel Studio XE, System Studio, Intel INDE и т.д.).
Одно из основных изменений коснулось лицензий для отдельных пользователей. Раньше этот тип лицензий назывался single-user, теперь это named-user, видимо, чтобы подчеркнуть, что данная лицензия именная и может быть использована только одним разработчиком. Кроме того, если в прошлом не было ограничений на количество систем, на которых можно было устанавливать продукт, то теперь оно есть, и это важно. Согласно тексту документа, мы можем установить софт не более чем на 3 системах. К слову, для того же Microsoft Office ограничение составляет 2 системы, потому у Интела на 50 процентов больше. Ну это конечно шутка. При этом, при установке в файле лицензии прописывается адрес (host id) машины, на которой ставится продукт, и когда информация о всех системах будет прописана, поставить софт на «лишнюю» машину будет не так просто – потребуются дополнительные телодвижения.
Правда, они могут потребоваться и так, если у вашей системы нет доступа к сети, что часто встречается в различных «закрытых» организациях. Почему? При установке, скажем, компилятора, installer сам берёт ваш MAC адрес, идёт на нужный сайт и вносит в лицензию эти данные, затем генерируется лицензионный файл и он «заливается» на вашу систему. Если нет доступа к сети, то придётся эти шаги делать самому. Для этого необходимо зайти на [Intel Registration Center](http://http:\\registrationcenter.intel.com) и внести информацию про вашу систему, затем получить лицензионный файл и использовать его во время установки. Весь процесс подробно описан [здесь](https://software.intel.com/en-us/articles/how-do-i-get-a-license-file-for-an-offline-installation-of-intel-parallel-studio-xe-2016).
В итоге, всё усложнилось для тех, у кого нет доступа к сети. Для остальных пользователей, которые ставят продукт на одну/две системы, разницы не будет никакой.
Ещё одно очень важное и очень приятное «нововведение» — это целый набор бесплатных лицензий, которые теперь доступны разработчикам.
Для всех библиотек Intel (MKL, IPP, TBB, DAAL) теперь имеется абсолютно бесплатная community лицензия. При этом нет никаких ограничений на то, кто будет использовать библиотеки и в каких целях – они доступны любому желающему. На [странице](https://software.intel.com/sites/campaigns/nest/) написано, что community лицензия предоставляется как обычная named-user лицензия в соответствии с EULA. Отличия – отсутствие поддержки через [Premier Support](http://premier.intel.com/) и возможность скачать только последнюю версию библиотек (не сможете работать с старыми релизами).
Тем не менее, есть форумы, где вы сможете задавать вопросы: [Intel DAAL](http://software.intel.com/forums/intel-data-analytics-acceleration-library), [IPP](http://software.intel.com/forums/intel-integrated-performance-primitives), [MKL](http://software.intel.com/forums/intel-math-kernel-library) и [TBB](http://software.intel.com/forums/intel-threading-building-blocks).
Кроме community лицензий, имеются так же ряд других, позволяющих тем или иным разработчикам их использовать без финансовых затрат. Например, есть [исследовательская академическая](https://software.intel.com/qualify-for-free-software/academicresearcher), которая также распространяется на те же библиотеки + Intel MPI, и с ней вы сможете скачать любую версию. Для того, чтобы получить такую лицензию, придётся «обзавестись» почтой с доменом учебного заведения.
Студенты также не остались без внимания. Для них имеется [студенческая лицензия](https://software.intel.com/qualify-for-free-software/student), основное ограничение которой – отсутствие денежной компенсации для учащегося. То есть это предложение — не что иное, как некоммерческая лицензия (Noncommercial-use) для студентов. Хороша она тем, что может быть получена на любой продукт – хочешь Parallel Studio XE, или, скажем, System Studio, или INDE.
Аналогичное предложение для всех продуктов есть и для преподавателей университетов. Использовать [преподавательскую лицензию](https://software.intel.com/qualify-for-free-software/educator) можно только в аудиториях университета во время занятий. Условие некоммерческого использования здесь не применимо, так как за свою деятельность преподаватели могут получать денежную компенсацию, aka зарплату. Хотя компенсация звучит более правильно, учитывая её размер.
Ещё одна возможность использовать только Parallel Studio XE Professional Edition (компиляторы, библиотеки и различные средства) и только на Linux – это участие в Open Source проектах, например на GitHub. В этом случае вы можете получить [соответствующую](https://software.intel.com/qualify-for-free-software/opensourcecontributor) лицензию, при этом она будет работать как некоммерческая.
Не стоит забывать, что на 30 дней всегда можно получить пробную лицензию, включающую в себя и поддержку не только на форуме, но и на Premier Support. Отличная обзорная табличка со всеми вариантами предложений есть [здесь](https://software.intel.com/en-us/free_tools_and_libraries).
В прошлом посте я также не рассказал про одну интересную особенность работы лицензий. В лицензионных файлах прописываются компоненты продукта, которые будут работать с этой лицензией. Пример:
```
COMPONENTS="FCompW \
MKernW"
```
Эта строчка в файле лицензии показывает нам, что мы можем устанавливать продукт на Windows (буква W в конце названий компонент), при этом в лицензию входят компилятор Фортрана (FCompW) и библиотека MKL (MKernW). Да, они перечисляются в сокращённом виде, но догадаться можно. Вот ещё один пример, куда входят гораздо больше компонент, потому что это лицензия на Parallel Studio XE Professional Edition (уже Linux – буква L в конце):
```
COMPONENTS="AdvXEl \
ArBBL CCompL DbgL FCompL MKernL PerfAnl PerfPrimL StaticAnlL \
ThreadAnlGui ThreadBB"
```
Конечно же, рассказал я это не для того, чтобы вы запоминали кодовое название каждого компонента, а вот для чего. Периодически в пакетах от Intel появляются новые компоненты, и они должны быть прописаны в файле. Так произошло и с только что выпущенной версией средств 2016 – там появилась новая библиотека Intel DAAL. В итоге, теперь необходимо обновлять все лицензии для тех пользователей, которые использовали предыдущие версии продуктов, например 2015. В новом файле остаются все предыдущие компоненты, и просто добавляются новые, поэтому обратная совместимость остается – новая лицензия всегда позволит вам устанавливать предыдущие версии. А вот без нового файла поставить новый продукт уже не получится, поэтому знайте и обновляйте свои лицензии. К слову, происходит это не очень часто (раз в 4-5 лет).
Надеюсь, что этот пост расширил ваше понимание модели лицензирования от Intel. Кроме того, описанные «новшества» теперь не должны стать для вас сюрпризом. | https://habr.com/ru/post/265683/ | null | ru | null |
# Разработка прогрессивного веб-приложения Nothing за 15 минут
В Google Play есть одно приложение, разработанное Chilango Lab, у которого больше миллиона загрузок и довольно высокий рейтинг. Называется оно [Nothing](https://play.google.com/store/apps/details?id=com.gorro.nothing), что можно перевести как «Ничто», и замечательно оно тем, что не делает абсолютно ничего. В нём, правда, спрятана приятная пасхалка, но это не меняет дела. Если проанализировать это приложение, то окажется, что его размер — 14 Мб, при установке оно занимает 19,24 Мб.
[](https://habr.com/company/ruvds/blog/421349/)
Автор материала, перевод которого мы сегодня публикуем, говорит, что глядя на это приложение, он задался вопросом о том, можно ли переписать его так, чтобы оно занимало меньше места.
Ему это удалось. А именно, он воссоздал функционал Nothing, используя HTML, CSS и JavaScript, оформив его в виде прогрессивного веб-приложения ([PWA](https://developers.google.com/web/progressive-web-apps/), Progressive Web App). Оно работает без подключения к интернету, вызывать его можно, как и обычное приложение, с главного экрана. Основная разница между обычным Android-приложением и его PWA-копией заключается в размерах. Первое, напомним, занимает на устройстве 19,24 Мб. Второе — 205 Кб.
*Обычное приложение и PWA*
Создание значков для Nothing
----------------------------
Прежде чем я расскажу вам о коде, создадим значок для PWA Nothing. Для решения этой задачи я воспользовался отличным [опенсорсным](https://github.com/romannurik/AndroidAssetStudio) инструментом [Launcher Icon Generator](https://romannurik.github.io/AndroidAssetStudio/icons-launcher.html).
*Launcher Icon Generator*
С помощью Launcher Icon Generator мне удалось создать значок для моего варианта Nothing буквально мгновенно. Программа автоматически генерирует значки различных размеров.
PWACompat
---------
После того, как работа над значком была завершена, мне нужно было создать [манифест веб-приложения](https://developers.google.com/web/fundamentals/web-app-manifest/). Благодаря ему браузер Chrome для Android покажет экран-заставку при загрузке PWA. Можно ли сделать так, чтобы такой экран появлялся и в других браузерах? Да, можно, и для этого нам понадобится библиотека PWACompat, которая позволяет реализовать именно то, что нам нужно. Её, вместе с манифестом, достаточно подключить в коде PWA:
```
```
Вот как выглядит экран-заставка в браузере Safari (iOS).
*Экран-заставка в Safari*
Но этим возможности PWACompat не ограничиваются. В частности, эта библиотека позволяет создавать мета теги для различных браузеров, описывающие то, как должно открываться PWA, а также устанавливает цвет темы, основываясь на манифесте веб-приложения.
Добавление приложения на главный экран
--------------------------------------
Одна из моих любимых возможностей PWA называется A2HS (Add to Home screen, добавить на главный экран), благодаря ей можно добавить значок для запуска приложения на главный экран. Однако начиная с Chrome 68 на Android, вместо большого A2HS-баннера, теперь выводится небольшая [информационная панель](https://developers.google.com/web/updates/2018/06/a2hs-updates) с соответствующим предложением.
*Прощай A2HS-баннер (Chrome 67 и более ранние версии)*
В любом случае, информационная панель — это промежуточное решение, когда-то эту возможность из Chrome уберут. Поэтому мне нужно было создать более приятный A2HS-интерфейс для PWA Nothing.
*Кнопка Install (слева), кнопка Install и A2HS-панель (в центре), диалоговое окно Add to Home Screen (справа)*
В данном случае, если браузер поддерживает возможность добавления приложения на главный экран, он выведет, в верхней части страницы, кнопку Install. Когда пользователь щёлкает по этой кнопке, вызывается диалоговое окно Add to Home Screen.
Вот соответствующий код.
```
var installPromptEvent;
var btnInstall = document.querySelector('#install');
window.addEventListener('beforeinstallprompt', function (event) {
event.preventDefault();
installPromptEvent = event;
btnInstall.removeAttribute('disabled');
});
btnInstall.addEventListener('click', function () {
btnInstall.setAttribute('disabled', '');
installPromptEvent.prompt();
installPromptEvent.userChoice.then((choice) => {
if (choice.outcome === 'accepted') {
console.log('User accepted the A2HS prompt');
} else {
console.log('User dismissed the A2HS prompt');
}
installPromptEvent = null;
});
});
```
Если сайт соответствует критериям A2HS, то браузер вызовет событие `beforeinstallprompt`.
Пасхалка
--------
Внимание, тут будет спойлер!
Собственно говоря, пасхалка PWA Nothing — это код Konami и [10-часовое видео на YouTube](https://twitter.com/Nick_Craver/status/720062942960623616).
*Вызов пасхалки (вверх, вверх, вниз, вниз, влево, вправо, влево, вправо и два касания)*
После того, как пользователь справится с кодом, PWA откроет [это видео](https://www.youtube.com/watch?v=jwGfwbsF4c4).
Для добавления поддержки кода Konami в моё приложение я воспользовался библиотекой [Konami-JS](http://snaptortoise.github.io/konami-js/). Она невелика, с ней легко работать, и она, кроме прочего, поддерживает мобильные устройства. Тут кроется единственное различие между моим PWA и исходным приложением для Android. В частности, там, где у меня, при вводе кода, надо выполнить два касания, в исходном приложении нужно воспользоваться панелью с кнопками.
Отключение обновления страницы при протягивании
-----------------------------------------------
У меня, в процессе работы над приложением, возникла небольшая проблема. Когда пользователь пытается протянуть страницу вниз на мобильном устройстве, это вызывает выполнение обновления страницы (pull-to-refresh). Мне это не нужно.
*Нежелательное обновление страницы*
К счастью, справиться с этой проблемой несложно. Для этого нужна лишь [одна строка CSS-кода](https://developers.google.com/web/updates/2017/11/overscroll-behavior):
```
overscroll-behavior-y: contain
```
Хостинг
-------
В качестве хостинга для PWA Nothing была выбрана площадка Netlify. Это универсальная платформа для современных веб-проектов. Причина, по которой я решил разместить моё приложение на Netlify, заключается в том, что тут всё очень легко настраивается. Кроме того, всё это бесплатно.
*Панель управления Netlify*
Для развёртывания проекта на Netlify можно воспользоваться одним из трёх методов. Речь идёт об инструментах командной строки, о ручном развёртывании, и о непрерывном развёртывании.
### ▍Инструменты командной строки Netlify
Это классический способ развёртывания веб-проектов. Для того чтобы им воспользоваться, надо установить CLI Netlify, войти в свою учётную запись, инициализировать проект и развернуть его. Выглядит это так:
```
> brew tap netlify/netlifyctl
> brew install netlifyctl
> netlifyctl login
> netlifyctl init
> netlifyctl deploy
```
### ▍Ручное развёртывание
Этот метод, пожалуй, самый лёгкий, развёртывание приложения выполняется несколькими движениями мыши.
*Ручное развёртывание*
Мне так понравилась эта возможность, что мне бы хотелось, чтобы нечто подобное появилось бы в Firebase. Собственно говоря, развёртывание проекта сводится к перетаскиванию мышью его папки на веб-страницу.
### ▍Непрерывное развёртывание
Сейчас я использую именно этот метод. После того, как я связал свой GitHub-репозиторий с Netlify, когда я отправляю туда код, Netlify автоматически собирает и развёртывает проект. Волшебство, не иначе.
### ▍HTTPS
Так как PWA должны обслуживаться по HTTPS из защищённого источника, мне нужно было обеспечить, чтобы на моём сайте был бы включен HTTPS. Мне, правда, не пришлось прилагать особых усилий в этой области, так как Netlify предоставляет бесплатный HTTPS для всех доменов, включая собственные домены пользователей.
*HTTPS*
Более того, с панели управления Netlify можно включить принудительный переход на HTTPS ([HSTS](https://en.wikipedia.org/wiki/HTTP_Strict_Transport_Security)). Это обеспечит постоянную защиту сайта.
Анализ проекта с помощью Lighthouse
-----------------------------------
[Lighthouse](https://developers.google.com/web/tools/lighthouse/) — это опенсорсный автоматизированный инструмент для улучшения качества веб-страниц. С его помощью можно проанализировать любую страницу — общедоступную, или требующую аутентификации. Он, кроме прочего, позволяет анализировать производительность и доступность страниц, исследовать прогрессивные веб-приложения.
*Lighthouse*
Моему приложению удалось набрать 97 баллов по показателю производительности и по 100 баллов по остальным показателям. Вот полный [отчёт](https://builder-dot-lighthouse-ci.appspot.com/report.1533954675085.html).
Итоги
-----
Как видите, прогрессивное веб-приложение, которое ничего не делает, оказывается гораздо меньше Android-приложения, обладающего столь же богатой функциональностью. [Здесь](https://nothing.limhenry.xyz/) можно испытать PWA Nothing. А [здесь](https://github.com/limhenry/nothing) можно найти его исходный код.
**Уважаемые читатели!** Как вы думаете, какие используемые вами приложения для Android стоило бы воссоздать в форме PWA?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/421349/ | null | ru | null |
# Как проектировать большие и сложные веб-таблицы
Представьте, что вы разрабатываете систему для исследования данных. Или приложение для управления энергией. Или дашборд для продавцов кукурузой. Может быть, вы разрабатываете что-то подобное прямо сейчас. Во всех упомянутых случаях люди будут ожидать таблиц. Не те модные из вдохновляющих сайтов, а выглядящие как Excel монстры с сотнями ячеек и сложным взаимодействием.
В этом случае дизайнер сталкивается со многими проблемами. Например, сопоставление дизайна с существующими фронт-енд фреймворками или борьба с «неудобными» данными, которые разрушают макет. Мы преодолеем эти проблемы с помощью следующих шагов: систематизируем потребности, станем атомарными и определим взаимодействие.
> [](https://www.edsd.ru/ "EDISON Software - web-development")
>
> Статья переведена при поддержке компании EDISON Software, которая [разрабатывает приложения и сайты](https://www.edsd.ru/prilozheniya-i-sajty-moskovskogo-yuvelirnogo-zavoda), а также [занимается пользовательскими интерфейсами](https://www.edsd.ru/ru/portfolio/tehnologiya/interface).
### 1. Систематизация потребностей
Итак, вы опросили целевую аудиторию. Теперь пришло время собрать воедино их потребности и желания и превратить их во что-то полезное для дизайна. Например, один пользователь сказал: «Мне нужно посмотреть, как мои данные влияют на другие части приложения». Или, посмотрев, как другой человек работает со старым программным обеспечением, вы заметили, что он использует горячии клавиши и совсем не касается мыши. Что это значит? Первые требования пользователя касаются валидации ввода и подсказок. Вам нужно будет добавить в таблицу предупреждения и справочную информацию. Или разработать систему значимых цветов. Это зависит от предметной области и ментальной модели. Наблюдая за работой второго пользователя, вы начинаете понимать, что вам нужно разработать все действия, доступные с клавиатуры. И вам, вероятно, нужно подумать о более специализированных горячих клавишах, чем просто «Cmd + C» и «Cmd + V».
В результате у вас будет список потребностей и желаний людей. Открытые вопросы полезны для выяснения реальных потребностей и фильтрации прихотей. Например: «Что помогает вам работать быстрее? Как это повышает эффективность вашей работы? Что изменится, если вы не сможете сделать X? »
Теперь пришло время построить логический каркас для вашей таблицы. Схему того, что она содержит и способна сделать. Если вы перейдете непосредственно к созданию каркаса или созданию прототипа, вы встанете на сложный путь бесконечного перерисовывания. Ниже приведен пример того, с чего вы могли бы начать. Это дерево особенностей.
Самый маленький строительный блок любой таблицы — это ячейка. Ячейки объединяются в строки и столбцы, которые могут иметь специфические особенности, отличные от других ячеек. И, наконец, мы переходим к таким важным дополнениям таблицы, как верхняя панель, клавиатурные команды, обработка ошибок и т. д.
Хорошо организованное дерево функций также полезно для команды разработчиков. Они могут сопоставлять функции с возможностями внешнего интерфейса и находить лучший способ превратить проект в код. В одном из моих проектов мы использовали фреймворк Angular Material. К сожалению, таблицы Angular’а были очень простыми. Мы нашли библиотеку Ag-Grid, которая поддерживала нашу функциональность, но имела одно ограничение. У нее не было возможности расширять строку и помещать что-то внутрь. Мы выявили эту проблему и скорректировали дизайн заранее.
### Подытог
* Начните строить сложную таблицу со сбора и определения приоритетов потребностей пользователей.
* Нарисуйте древовидную диаграмму, которая систематизирует все необходимые функции. Используйте это как план для производства визуальных эффектов.
### 2. Внедрите атомарность
Итак, функциональность определена, и вы знаете ограничения разработки. Пришло время макетировать вашу таблицу. По сути, атомарный подход — сначала разрабатывать небольшие компоненты пользовательского интерфейса, а затем собирать более крупные. Мы постепенно перейдем от элементарных частей, таких как шрифты и цвета, к таким большим модулям, как заголовок или столбец. Я сознательно выбрал строгий брутальный стиль для макетов, чтобы мы могли сосредоточиться на функциональности, а не на внешности.
### Шрифты, цвета и иконки
Эти части могут быть уже определены в используемой вами системе проектирования или в UI фреймворке. Если вы создаете таблицу для существующего продукта, проверьте, соответствуют ли его цветовая палитра, шрифты и иконки требованиям таблицы.
### Ячейки и аксессуары
Когда атомы таблицы готовы, мы можем перейти к молекулам — различным типам ячеек. Прежде всего, важно заранее подумать о нормальном, наведенном и активном состояниях каждого элемента. Позже дизайнер также добавляет нажатое, отключенное и другие состояния.
В одном из моих проектов у нас было восемь типов ячеек с собственным взаимодействием. Самыми простыми являются текстовые и числовые ячейки. В нашем случае было разрешено заполнять числовые ячейки нечисловым содержимым, таким как «N/A» (не применяется) и «N/C» (без контроля). Это была особенность области деятельности. Выпадающие списки и средства выбора даты являются более сложными и имеют дочерние элементы. Наконец, у нас были ячейки таблицы, представляющие собой кнопки.
Ячейки могут иметь такие аксессуары, как тултипы, подсказки ввода, сообщения об ошибках, плейсхолдеры и т. д. На этом этапе они статичны, но позже разработчик должен указать логику их отображения.
### Строки и заголовки
Когда ячейки спроектированы, вы можете сделать строки и посмотреть, хорошо ли работают различные комбинации. Ниже я показал смесь доступных только для чтения и редактируемых ячеек в одном ряду. Однажды я разработал таблицу со сложной логикой редактирования. Некоторые свойства были предоставлены пользователями, тогда как другие были автоматически рассчитаны или заполнены значениями по умолчанию.
Обратите внимание, что при наведении курсора на доступные только для чтения и редактируемые ячейки курсор отличается. И нажатие на них вызывает либо выбор строки, либо переход в режим редактирования ячейки. Ниже вы можете видеть, что люди могут выбрать одну или несколько строк.
Теперь пришло время подумать о заголовках таблицы. Исходя из моего опыта, зачастую невозможно контролировать длину заголовка столбца и придерживаться одной строки. Даже с хорошим писателем в команде вы не будете сокращать все тексты. Некоторые из таблиц требуют длинных технических названий или локализации. Фразы, которые были однострочными на английском языке, могут стать двух- или трехстрочными на греческом, немецком или венгерском языках. Поэтому ниже я показал разные варианты.
Пользователи программного обеспечения на основе данных часто нуждаются в сортировке и фильтрации. Это помогает им находить ценную информацию в больших порциях данных. Задача сортировки и фильтрации состоит в том, чтобы объединить элементы управления сортировкой и поля фильтрации с другими элементами заголовка — заголовками, единицами измерения и т. д.
В отличие от ячеек таблицы, поля фильтров обычно имеют значок «сброса» справа, чтобы пользователи могли явно отключить их и увидеть нефильтрованный контент.
В моем примере есть три типа блоков фильтров. Буквенно-цифровой фильтр позволяет осуществлять поиск по буквам и цифрам. Поддерживаются подстановочные знаки — неизвестное количество неизвестных символов. Например, если я введу «45 \* A1», это может привести к отображению строк с такими значениями, как «45A1», «45982A1B», «45A109B» и «096445-A1».
Подстановочные знаки представляют собой сложную функцию, поскольку они зависят от привычек людей. Когда я разработал таблицы для технических специалистов, мы присвоили знак звездочки (\*) неизвестному числу неизвестных символов. Для страховых аналитиков я выбрал традиционный символ SQL — знак процента (%) — потому что они к нему привыкли. Что касается выпадающего фильтра, он переключается между определенным количеством взаимоисключающих текстовых опций, чисел или числовых диапазонов.
Фильтр выбора даты имеет календарь и работает как его эквивалент ячейки. Хорошо, если пользователи могут вводить дату вручную и выбирать из календаря. Если они знают, что ищут, набрать дату гораздо проще, чем нажать. Еще одна важная вещь — это автоматически форматировать любой значимый ввод и не беспокоить людей ошибками «неверного формата». В одном из моих проектов мы разрешили вводить такие даты, как «25.01.2017», «6 12 17» и «4 сентября 2016», и фильтровать только по месяцам или годам без дня.
### Столбцы
Одна из частых особенностей сложных таблиц — закрепленные столбцы. Обычно столбцы, содержащие ключевую информацию, например, имена элементов или статусы, не прокручиваются.
Хоть столбцы таблицы должны корректно подстраиваться под размер содержимого, это происходит, когда текст усекается. В этом случае помогает изменяемый размера столбца. Пользователи могут перетаскивать край столбца и видеть длинный контент. Им также может понадобиться сжать неважный столбец или столбец с коротким текстом.
Другой способ обработки длинных текстовых строк — это либо растянуть столбец на самое длинное содержимое, либо поместить в несколько строк. Первый подход работает лучше для похожих текстовых строк. Второй вариант работает лучше, когда видеть весь контент для людей важнее, чем делать таблицу вертикально компактной.
В одном из моих проектов мы определили минимальную ширину столбцов по умолчанию, чтобы таблицы не изменяли размер. Мы отключили сжатие столбцов при определенной ширине в зависимости от типа контента.
### Верхняя панель
Что составляет таблицу? Клетки, столбцы, строки. Кроме того, сложные таблицы часто имеют верхнюю панель. Как и остальные компоненты, верхняя панель состоит из более мелких элементов — заголовка и кнопок. Ниже я собрал список кнопок со всем разнообразием состояний, которые мы использовали в одном из продуктов. У нас были очевидные кнопки иконки, такие как «плюс = добавить или создать», «мусорное ведро = удалить», «стрелка = движение». Неуниверсальные кнопки (например, назначить, архивировать, балансировать) нуждались в явном текстовом наименовании. Более того, некоторые кнопки сопровождались выпадающим меню.
Теперь мы можем попытаться объединить различные элементы и посмотреть, работает ли это. Вот несколько примеров.
Конечно, это не полный список функций и элементов. Он отличается от одного проекта к другому и может включать в себя другие вещи, например:
* сортировка по нескольким столбцам;
* настраиваемый набор столбцов (возможность их переключения);
* расширяемые строки (родительская строка может иметь дочерние строки);
* логические операторы для фильтрации и поиска («и», «или», «еще» и т. д.).
Если вы сомневаетесь, какие функции проектировать, а какие нет, вот хороший принцип. Это бритва Оккама или закон скупости. Дизайнер не должен создавать новые экземпляры, если существующие удовлетворяют потребности. Вы должны «вырезать» те гики-функции, которые теоретически могут понадобиться пользователям в неопределенном будущем. Та же история с функциями, которые идеально подходят для одной из ста ситуаций, но бесполезны в оставшихся девяносто девяти случаях.
### Готовая таблица
Когда все строительные блоки готовы, вы можете собрать несколько таблиц для различных целей. Это шанс обнаружить несоответствия и нелогичные решения. Чаще всего я имел дело со следующими тремя типами.
**Таблица только для чтения**. Самый простой тип таблицы для построения, поскольку он показывает только данные как есть. Здесь нет параметров фильтрации или редактирования. Сортировка или иерархия строк может помочь проанализировать большие порции данных. Такая таблица используется для отображения данных, информирования людей о чем-либо.
**Таблица для поиска.** Ячейки недоступны для редактирования, в заголовке есть поля фильтров и элементы управления сортировкой, можно выбирать строки. Из моей практики такие таблицы помогают находить, сравнивать и выбирать предмет или несколько предметов из большого числа похожих вещей. Например, отфильтруйте пять из шести тысяч ненужных инструментов из каталога, а затем выберите один необходимый инструмент.
**Редактируемая таблица**. Все или некоторые ячейки доступны для редактирования, обычно фильтрация отсутствует, поскольку порядок строк может быть изменен. Такие таблицы обычно сопровождаются панелью инструментов и позволяют выполнять действия со строками.
### Подытог
* Начните с самых маленьких компонентов. Затем постепенно переходите к более крупным и, наконец, сделайте макет всего этого.
* Заранее продумайте все возможные состояния для каждого компонента.
* Используйте принцип бритвы оккама, чтобы сохранить минимальное количество элементов, но охватывая все варианты использования.
### 3. Определите взаимодействие и среду
Строительных блоков недостаточно для создания такого сложного элемента интерфейса, как таблица. Дизайнер должен подумать о «правилах игры» и разработать логические принципы и соглашения, стоящие за визуальной частью. Я опишу некоторые типичные вещи, которые вы должны рассмотреть.
### Числовые данные
Сколько десятичных знаков у числа должно быть в вашей таблице? Один, два, пять? Каков оптимальный уровень точности? Я принимаю решение, основываясь на точности, необходимой пользователям для принятия правильного решения. В некоторых профессиях колебания между 10932.01 и 10932.23 имеют значение, в то время как в других областях числа 14 и 15 действительно не имеют значения. Это пример правил числовых данных, которые моя команда использовала в сложном инженерном продукте.
* **Длина**: 2 знака после запятой (57.53 м, 3.16 км), пробелы используются в качестве разделителей тысяч (403 456.56 м).
* **Вес**: 2 знака после запятой (225.08 кг, 108.75 т), пробелы используются в качестве разделителя тысяч (12 032.17 кг).
* **Деньги**: 2 десятичных знака ($9,45), запятые используются в качестве разделителей тысяч ($16,408,989.00).
* **Диаметр**: 3 десятичных знака (10.375 см), разделители не нужны.
* **Широта и долгота**: 8 десятичных знаков (26.4321121), минус используется для западной долготы и южной долготы (-78.05640132).
* **По умолчанию** для единиц, не указанных выше: 2 десятичных знака (32.05 г / м³, 86.13 C °).
Еще одна вещь, которую мы рассмотрели, была разница между «истинными» данными, сохраненными на серверах, и «приблизительными» данными в интерфейсе. Система использовала чрезвычайно точные числа с десятками десятичных знаков во всех вычислениях, но людям не нужно было видеть это все время. Поэтому мы решили показать количество десятичных знаков, описанных выше, и выставить полное число только тогда, когда активна ячейка таблицы. Например, инженер может ввести «134432.97662301», и после нажатия «Enter» в таблице будет показано «134 432.98». Еще раз щелкнув, инженер снова увидит «134432.97662301».
### Подтверждение ввода
В отличие от предыдущего пункта о числах, проверка важна только для редактируемых таблиц. Это имеет два аспекта. Во-первых, правила, которые квалифицируют введенные данные как действительные или недействительные. Во-вторых, либо сообщения, которые помогают исправить недействительные данные, либо механизмы, которые исправляют это автоматически. Обычно правила валидации слишком сложны, чтобы отражать их в макетах или прототипах. Таким образом, дизайнеры могут документировать их в текстовом виде или в формате блок-схем.
Это пример шаблонов сообщений, которые я когда-то использовал. Текст в угловых скобках является динамическим и приходит из механизма расчета или базы данных.
* Должно быть больше `number` `measurement unit`. `Optional explanation`.
* Должно быть меньше `number` `measurement unit`. `Optional explanation`.
* Должно быть между `value 1` и `value 2` `measurement unit`. `Optional explanation`.
* Минимальное значение должно быть меньше максимального значения.
* Максимальное значение должно быть больше минимального значения.
* Минимальное и максимальное значения не должны быть равными.
### Команды
Редактируемые таблицы с панелями инструментов обычно нуждаются в наборе правил, когда кнопки панели инструментов включены и когда отключены. Эти состояния могут зависеть от того, выбрана ли строка, от количества выбранных строк, от положения или содержимого выбранной строки или строк и других условий. Ниже приведен один из многочисленных способов документировать такие логические правила.
Итак, у нас есть таблица с некоторыми химикатами. Она имеет такие кнопки, как «Добавить строку», «Переместить вверх», «Переместить вниз», «Удалить», «Пересчитать» и «Настройки».
А вот и описание состояний кнопок. Оказывается, их доступность зависит от одного или нескольких условий.
Следующим шагом является определение результата каждой команды. Например, что происходит, когда я выбираю две строки, которые находятся не рядом, и нажимаю «Переместить вверх»? Или каков результат нажатия «Пересчитать»? На все эти вопросы нужно ответить или хотя бы рассмотреть заранее.
### Контейнер и адаптивность
Как таблица будет размещена в интерфейсе? Например, она будет занимать некоторое пространство в существующем контейнере или будет отдельным модулем? Ответы на эти вопросы полностью зависят от продукта, и лучше предвидеть возможные проблемы и тщательно определять принципы.
Когда я разрабатываю веб-приложения, я обычно думаю о трех типах контейнеров для таблиц. Наиболее типичный случай, когда большая таблица находится в центре экрана и занимает почти все пространство. Такая таблица может не иметь собственного заголовка и может иметь имя страницы. Небольшие и средние таблицы могут стать модулями панели инструментов, а также другого контента, такого как графики, диаграммы, схемы. В этом случае верхняя панель таблицы играет роль заголовка модуля. И, наконец, в крупных корпоративных приложениях таблицы часто находятся во всплывающих диалоговых окнах. Должны быть мудрые рекомендации, чтобы диалоги не ломались из-за слишком большого количества контента.
Другой аспект размещения таблицы в среде пользовательского интерфейса — доступная область экрана. Большинство корпоративных приложений предназначены для использования в основном на настольных компьютерах. Адаптивность таблицы ограничивается простым растяжением и сжатием. Как правило, таблицы с большим количеством строк и несколькими столбцами занимают 100% доступной ширины. В результате ячейки равномерно распределяются на экране, и большинство текста может отображаться без обрезания или переноса. С другой стороны, между колонками появляются огромные промежутки, что противоречит закону близости. Вот почему некоторые приложения используют линии или бело-серые «зебры», чтобы сделать информацию лучше читаемой.
Лучший способ — определить рациональную ширину по умолчанию и разрешить ручное изменение размера при необходимости. Для чтения таблицы лучше иметь свободное пространство справа, чем пробелы между столбцами. Но если таблица содержит много строк и столбцов, горизонтальные и вертикальные прокрутки неизбежны.
Ключевая сущность сложной таблицы заключается в ее большом размере, что дает представление о данных с высоты птичьего полета. К сожалению, я не могу вспомнить действительно хороший метод использования больших таблиц на экранах смартфонов. Электронные таблицы Excel и Google теряют свою силу на небольших экранах, но существуют эффективные способы обработки небольших таблиц. Например, конвертировать их в список карточек.
### Доступность(Accessibility)
Даже исключительно гладкая и красивая таблица может стать кошмаром для пользователей. Поэтому так важно следовать принципам доступности. В Руководстве по доступности веб-контента ([WCAG 2.0](https://www.w3.org/TR/WCAG20/)) есть глава о таблицах. Большая часть материала о правильном программировании. Однако дизайнеру тоже есть над чем подумать. Вот основные соображения дизайна с точки зрения доступности.
Дайте заголовок таблице и сделайте краткое содержание. Пользователь со слабым зрением должен иметь возможность получить представление о таблице без голосовой обработки всех ее ячеек.
Следите за размером шрифта. Хотя официального минимального размера для веба не существует, оптимальным считается 16 пикселей (12 пт). Кроме того, пользователь должен иметь возможность увеличить его до 200%, не нарушая весь макет.
Проверьте цвета для людей с дальтонизмом. Текст и элементы управления должны иметь достаточный контраст с фоном. Соотношение цветов 3:1 минимально необходимо (чем больше, тем лучше). И цвет не должен быть единственным способом маркировки вещей. Например, сообщения об ошибках не должны опираться только на красный текст, иконка предупреждения даст дополнительную подсказку для дальтоников.
Избегайте небольших и неоднозначных элементов управления. Компоненты, реагирующие на нажатия, считаются хорошими, если они имеют размер не менее 40 × 40 пикселей. Кнопки, представленные иконками, должны быть либо помечены, либо иметь подсказки и альтернативный текст. Дизайнеры не должны злоупотреблять иконками, поскольку пользователи могут неправильно понимать сложные метафоры.
Вы можете использовать онлайн-инструменты для проверки доступности, например, [Wave](http://wave.webaim.org/). Он не только находит проблемы и возможности доступности, но также выделяет их непосредственно на странице и объясняет, как их исправить.
### Подытог
* Унификация и форматирование контента — это тоже работа дизайнера.
* Подумайте не только о «вещах», элементах вашего интерфейса и рассмотрите варианты использования, правила и частые паттерны.
* Когда все элементы таблицы согласованы и совместимы, самое время подумать о том, как таблицы будут соответствовать остальному интерфейсу.
### Заключение и дополнительные материалы для чтения
Мы только что прошли через процесс создания сложной таблицы. Различные проекты требуют разных подходов, но есть один универсальный принцип. Дизайнер должен заставить все элементы работать вместе в любой комбинации. Поэтому хорошо начинать с того, чтобы сначала собрать необходимые вещи и сделать небольшие блоки. И, конечно же, тестирование с пользователями, как только у вас появляется что-то кликабельное и реалистичное.
Здесь вы можете прочитать больше о разработке таблицы.
* "[Table Design Patterns on The Web](https://www.smashingmagazine.com/2019/01/table-design-patterns-web/)", статья Чэнь Хуэй Цзина для журнала «Smashing Magazine».
* "[Atomic Design](http://atomicdesign.bradfrost.com/)", книга Брэда Фроста.
* "[Refactoring UI](https://refactoringui.com/book/)", книга Адама Ватананда и Стива Шогера.
* "[Design Better Data Tables](https://uxdesign.cc/design-better-data-tables-4ecc99d23356)", статья Эндрю Койла для UX Design.
* "[Design Systems](https://shop.smashingmagazine.com/products/design-systems-by-alla-kholmatova)", книга Аллы Холматовой.
### Еще интересные публикации
* [Как заставить ваши веб-приложения работать в автономном режиме](https://habr.com/ru/company/edison/blog/474374/)
* [Ещё 5 дерзких тренировочных проектов для разработчика (Layer, Squoosh, Калькулятор, Website Crawler, Music Player )](https://habr.com/ru/company/edison/blog/474444/) | https://habr.com/ru/post/475730/ | null | ru | null |
# Microsoft пытается подмять веб-стандарты под IE8
Возможно, я глубоко ошибаюсь в заголовке; очень хочется услышать мнение Хабралюдей по поводу того, [как в IE8 предполагается «решить» проблему рендеринга старого HTML-кода](http://flash-ripper.com/archives/002181.php), напичканного хаками для IE6 / IE7 (вот [оригинальная статья](http://www.alistapart.com/articles/beyonddoctype) с A List Apart, плюс Джон Резиг [по этому же поводу](http://ejohn.org/blog/meta-madness/)).
Вкратце — Microsoft предлагает ввести специальный мета-тэг `X-UA-Compatible` для обозначения версии целевого браузера, чтобы IE8 мог корректно отображать страницы, созданные ранее для его предшественников.
Update: интересно, как на это отреагируют онлайн-сервисы создания веб-страниц, например, движки MovableType, WordPress и прочая. От их решения будет зависеть развитие ситуации, верно? | https://habr.com/ru/post/19236/ | null | ru | null |
# Как мы в ISPsystem резервные копии делали. Часть вторая
Продолжение истории о похождениях отдельной задачи в ISPsystem. Рассказывает руководитель разработки Александр Брюханов. Первая часть [здесь](https://habrahabr.ru/company/ispsystem/blog/352260/).
*Лучшее — враг хорошего*
Написание резервного копирования или установки и настройки ПО у нас всегда были расстрельными задачами. Когда ставишь что-либо из репозиториев, не можешь быть до конца уверен в результате. Да даже если всё сделано идеально, мэнтейнеры рано или поздно что-нибудь сломают. Что же касается резервных копий: о них вспоминают, когда возникают проблемы. Люди уже на взводе, а если еще что-то идет не так, как они ожидали… ну вы поняли.
Подходов к резервному копированию существует довольно много, но каждый преследует одну цель: сделать процесс как можно более быстрым и при этом максимально дешевым.
Попытка угодить всем
--------------------
На дворе 2011 год. Прошел не один год с тех пор, как тотальное резервное копирование серверов кануло в Лету. Нет, резервные копии виртуальных серверов делали, делают их и сейчас. Например, на WHD.moscow мне рассказали по-настоящему элегантный способ резервного копирования виртуальных серверов через живую миграцию. И все равно сейчас это не происходит так массово, как 10-15 лет назад.
Мы начали разработку пятой версии наших продуктов на основе собственного фреймворка, в котором была реализована мощная система событий и внутренних вызовов.
Решено было реализовать по-настоящему гибкий и универсальный подход к настройке резервного копирования, чтобы пользователи могли настраивать время, выбирать тип и содержимое резервных копий, раскладывать их в различные хранилища. Да еще мы задумали растянуть это решение на несколько продуктов.
Кроме того, цели резервного копирования тоже могут существенно отличаться. Кто-то делает резервные копии для защиты от сбоев оборудования, кто-то страхуется от потери данных по вине администратора. Наивные, мы хотели угодить всем.
Со стороны наша попытка сделать гибкую систему выглядела так:
> *Носком правой ноги вы давите окурок*. Добавили пользовательские хранилища. Ведь в чем проблема: лить готовые архивы в два места? На самом деле, проблема есть: если архив невозможно залить в одно из хранилищ, можно ли считать резервное копирование успешным?
>
>
>
> *Второй окурок вы давите носком левой ноги*. Ломаем копья, реализуя шифрование архивов. Всё просто, пока вы не думаете о том, что должно произойти когда пользователь захочет сменить пароль.
>
>
>
> *А теперь оба окурка вы давите вместе!*
К чему я это? Безумная гибкость породила бесконечное количество сценариев использования, и все их протестировать стало практически невозможно. Поэтому мы решили пойти по пути упрощения. Зачем спрашивать у пользователя, хочет ли он сохранять метаданные, если они занимают несколько килобайт. Или, к примеру, вам правда интересно, какой архиватор мы используем?
*Еще одна забавная ошибка: нашелся пользователь, который ограничил время работы резервного копирования с 4:00 до 8:00. Проблема была в том, что сам процесс запускался через планировщик ежедневно в 3:00 (стандартная настройка @daily). Процесс запускался, определял, что в это время ему запрещено работать, и выходил. Резервные копии не делались.*
Пишем свой велосипед dar
------------------------
В середине 10x стал нарастать хайп про кластеры, а следом облака. Появилась тенденция — давайте будем управлять уже не одним сервером, а группой серверов и назовем это облаком :) Коснулось это и ISPmanager.
И, раз у нас появилось много серверов, возродилась идея вынести сжатие данных на отдельный сервер. Как и много лет назад, мы предприняли попытку найти готовое решение. Как ни странно, обнаружили bacula живой, но такой же сложной. Чтобы ей управлять, надо было, пожалуй, отдельную панель писать. И тут мне на глаза попался dar, реализовавший многие идеи, которые когда-то вкладывались в ispbackup. Казалось, вот оно, ~~счастье! Ан нет, опыт!~~идеальное решение, которое позволит управлять процессом резервного копирования как нам захочется.
В 2014 году решение с использованием dar было написано. Но оно содержало две серьезные проблемы: во-первых, полученные dar архивы можно распаковать только оригинальным архиватором (т. е. самим dar); во-вторых, dar формирует листинг файлов в памяти в XML, мать его!, формате.
> Именно благодаря этой утилите я узнал, что выделяя память в Си маленькими блоками (на centos 7 блок должен быть меньше 120 байт), невозможно вернуть её системе, не завершив процесс.
Но в остальном, он был мне очень симпатичен. Поэтому в 2015 году мы решили написать свой ~~велосипед~~dar — isptar. Как вы, наверное, догадались, был выбран формат tar.gz — довольно легко реализуемый. Со всевозможными PAX headers я разобрался еще когда писал ispbackup.
*Надо сказать, что документации по данному вопросу немного. Поэтому в свое время, мне пришлось потратить время на изучение того, как tar работает с длинными именами файлов и большими размерами, ограничения на которые были изначально заложены в tar-формате. 100 байт на длину имени файла, 155 на каталог, 12 байт на десятичную запись размера файла и т. п. Ну да, 640 килобайт хватит всем! Ха! Ха! Ха!*
Оставалось решить несколько проблем. Первая — быстрое получение листинга файлов без необходимости полной распаковки архива. Вторая — возможность извлечь произвольный файл, опять же, без полной распаковки. Третья — сделать так, чтобы это был всё еще tgz, который может быть развёрнут любым архиватором. Каждую из этих проблем мы решили!
**Как начать распаковку архива с определенного смещения?**
Оказывается, gz потоки можно склеивать! Простой скрипт докажет вам это:
```
cat 1.gz 2.gz | gunzip -
```
Вы получаете склеенное содержимое файлов без каких-либо ошибок. Если каждый файл писать так, как будто это отдельный поток, то проблема решится. Конечно, это уменьшает степень сжатия, но не очень значительно.
**Получение листинга — еще проще.**
Давайте положим листинг в конец архива как обычный файл. А в листинг, еще и смещения файлов в архиве запишем (кстати, dar тоже листинг в конце архива хранит).
Почему в конце? Когда вы делаете резервную копию размером в сотни гигабайт, у вас может не оказаться достаточно места для хранения всего архива. Поэтому по мере создания вы сливаете его в хранилище по частям. Самое замечательное, что если вам надо достать один файл, вам необходимы лишь листинг и та часть, которая содержит данные.
**Осталась только одна проблема: как получить смещение самого листинга?**
Для этого в конец самого листинга я сложил служебную информацию об архиве, включая запакованный размер самого листинга, а в самый конец служебной информации, в виде отдельного gz потока, запакованный размер самой служебной информации (это всего две цифры). Для быстрого получения листинга достаточно прочитать последних несколько байт и распаковать их. Потом прочитать служебную информацию (смещение относительно конца файла мы теперь знаем), а потом и сам листинг (смещение которого мы взяли из служебной информации).
Простой пример листинга. Разными цветами выделены отдельные gz потоки. Соответственно, вначале мы распаковываем красный (просто анализируя последние 20–40 байт). Затем распаковываем 68 байт, содержащих запакованную короткую информацию (выделенную синим). И, наконец, распаковываем еще 6247 байт, чтобы прочитать листинг, реальный размер которого 33522 байта.
`etc/.billmgr-backup root#0 root#0 488 dir
etc/.billmgr-backup/.backups\_cleancache root#0 root#0 420 file 1487234390 0
etc/.billmgr-backup/.backups\_imported root#0 root#0 420 file 1488512406 92 0:1:165:0
etc/.billmgr-backup/backups root#0 root#0 488 dir
etc/.billmgr-backup/plans root#0 root#0 488 dir
…
listing\_header=512
listing\_real\_size=33522
listing\_size=6247
header\_size=68`
Звучит немного заморочено, мне даже пришлось заглянуть в исходник, чтобы вспомнить, как я это делаю. Вы тоже можете взглянуть на исходник isptar, который, как и исходники ispbackup, я выложил на [github](https://github.com/ispsystem/isptar).
Ну а история на этом, конечно же, не заканчивается. Можно вечно смотреть на огонь, паркующуюся женщину и на то, как люди при помощи одних костылей пытаются победить другие. | https://habr.com/ru/post/352808/ | null | ru | null |
# Эй, Симулятор! Покажи свой язык
Написанию этого материала способствовала статья [Зачем язык Verilog программисту микроконтроллеров](http://habrahabr.ru/post/212507/), где описывается возможность тестирования алгоритма (Си файла) проекта микроконтроллера в Verilog проекте. Т.е. симулятор Verilog HDL взаимодействует с Сишным кодом микроконтроллера и тестирует реализованный алгоритм на возможные логические ошибки.
Подобные методы отладки кода для микроконтроллеров уже реализованы производителями. За всех не поручусь, но могу показать на примере симулятора MPLAB SIM компании Microchip Technology Inc.
История
=======
Много-много лет назад, в Microchip, в команде разработчиков симулятора MPLAB был разработан VHDL-подобный язык **SCL** – Stimulus Control Language, с помощью которого можно создавать testbench для помощи в отладке кода. Однако, в связи с уходом из команды автора реализации SCL и «сложности» языка, было решено создать [GUI](https://ru.wikipedia.org/wiki/Графический_интерфейс_пользователя), которая освобождает embedded-программиста от вникания в тонкости VHDL-подобного SCL и помогает создать последовательности тестовых сигналов и инжекций данных в регистры симулируемого микроконтроллера. Такая GUI-обертка в среде разработки MPLAB IDE называется **Stimulus**.
**Секретный язык**Microchip особо не продвигал SCL и не предоставлял описание языка. В 2006 году даже было объявлено, что в следующей версии MPLAB IDE v8.xx вообще уберут поддержку SCL, но участники [forum.microchip.com](http://forum.microchip.com) высказались против этого и SCL оставили в следующих релизах.
Некоторые энтузиасты даже начали «реверсить» SCL (благо Stimulus может генерировать SCL-файлы) и создавать учебник по SCL и репозиторий примеров. Особо стоит отметить [русскоязычный труд](http://pic24.ru/doku.php/osa/articles/scl) с описанием SCL, сопровождающийся несколькими примерами (от простого генератора, до эмуляции UART и генерации DTMF сигналов).
В связи с тем, что новое поколение MPLAB X IDE полностью переписано и получило кроссплатформенность (MPLAB X основан на NetBeans), то реализация SCL так же переписана и нынешние разработчики включили «неофициальный» SCL User’s Guide в документацию к MPLAB X IDE.
Возможности GUI Stimulus
========================
Сейчас Stimulus позволяет:
А) создавать синхронные последовательности изменений состояний выводов или значений регистров (удобно для формирования повторяющихся последовательностей:
Во время Хn состояние (pin, регистр) = ХХ
Во время Хm состояние (pin, регистр) = YY
Процесс можно повторять начиная с шага i; между повторами задать задержку ii.
Б) создавать комплексные воздействия:
Если выполняется условие, что (pin, bit или регистр) становится (=, !=, <=, <, >= или >), то через N (тактов, нс, мкс, мс или ч.м.с) выполнить (однократно или с периодом M) воздействие (одно или несколько): записать в регистр значение, изменить состояние pin или bit, установить напряжение на аналоговом входе.
В) генерировать сигналы:
На выводе (pin\_уу) с начальным значением (ВЫСОКОЕ или НИЗКОЕ) выдать последовательность (задается длительность ВЫСОКОГО и НИЗКОГО состояния). Задаются условия запуска и останова (старт программы или по значению программного счетчика или в заданное время или когда значение на pin\_хх == ВЫСОКОЕ или НИЗКОЕ).
Г) инжекция данных в регистры:
Из указанного файла взять значение и записать его в заданный регистр. Действие произвести когда: происходит чтение из регистра (т.е. в отлаживаемой программе читаем регистр) или программный счетчик примет зафиксированное значение или выполнится указанное в файле условие. Например, можно инжектировать в UART данные из файла вида:
`wait 1 sec // ждать 1 секунду`
`01 54 106 // инжектируемые данные`
`02 55`
`wait 200 ms // ждать 200 мс`
`“hello” // инжектируемые данные`
`rand 1 15 sec // случайная пауза от 1 до 15с`
`32 33 34`
Stimulus, помимо описанного, позволяет сохранить созданные воздействия в виде SCL файла и (!) загружать собственные SCL сценарии.
SCL
===
Stimulus является достаточно мощным инструментом, но имеет существенные ограничения – служит в основном для задания простых и детерминированных воздействий, не всякую модель поведения «внешней среды» можно описать с помощью предлагаемой в среде разработки GUI.
SCL, являясь языком программирования, дает больше гибкости: доступны условные выражения (конструкции if-elsif-else), циклы, инструкции работы с файлами и др.
Некоторые возможности SCL:
* Инжектирование значения в pin или в память данных микроконтроллера
* Чтение значения pin или из памяти данных
* Чтение и обработка файлов
* Выполнение действий на основании времени симуляции, командных циклов и на основании значения программного счетчика
* Выдача информационных сообщений в окно симулятора
То есть SCL может все, что доступно через GUI Stimulus в MPLAB IDE. Но SCL имеет более широкие возможности и позволяет формировать сложные зависимости между значениями на выводах и значениями регистров микроконтроллера; моделировать взаимодействие с внешней периферией; моделировать воздействия, которые сложно воспроизвести в «железе» и выявлять ситуации, приводящие к ошибкам. Кроме того, среда разработки позволяет подключать несколько SCL файлов, для их параллельного выполнения. Это может пригодиться, например, для подключения к проекту типовых testbench-ев.
Примеры
=======
Допустим, для отладки и тестирования программного декодера нужно сформировать манчестерский код на входе микроконтроллера. С применением Stimulus задачу можно выполнить с помощью формирования последовательности изменения состояния вывода, но это слишком муторное занятие, так как каждое изменение битов нужно прописывать руками, типа так:
Теперь, если нужно изменить первый бит, то нужно переписать всю последовательность.
Другое дело, если формировать последовательность с использованием SCL: пишем testbench, который берет входной битовый поток (не кодированный), кодирует его и отправляет на вход симулируемого микроконтроллера. Для удобства изменения данных, входной битовый поток можно брать из внешнего файла. Попутно наш testbench может выводить информационные сообщения в окно симулятора.
### Пример SCL файла:
```
configuration for "pic16f1509" is
end configuration;
testbench for "pic16f1509" is
begin
process is
file fileVar : text;
variable lineVar : line; -- Строка, прочитанная из файла
variable status : file_open_status;
variable data_in : integer;
begin
loop
file_open(status, fileVar, "dat.txt", read_mode);
while endfile(fileVar) == false loop -- Обрабатываем, пока файл не пуст
readline(fileVar, lineVar);
report("Прочитана строка");
RB5 <= '1'; -- стартовый бит (1/2 битового интервала)
report ("== start bit ==");
wait for 500 us;
while match(lineVar, "") == false loop -- Обрабатываем строку, пока она не пуста
read(lineVar, data_in);
if data_in == 0 then -- кодируем 0
report ("== 0 ==");
RB5 <= '0';
wait for 500 us;
RB5 <= '1';
wait for 500 us;
elsif data_in == 1 then -- кодируем 1
report ("== 1 ==");
RB5 <= '1';
wait for 500 us;
RB5 <= '0';
wait for 500 us;
else
report("Ошибка данных!");
end if;
end loop; -- match InLine
end loop; -- endfile
RB5 <= '0';
file_close(fileVar);
wait for 15 ms; -- пауза между пакетами
end loop;
wait;
end process;
end testbench;
```
### Файл внешних данных с битовой последовательностью:
`0 0 0 0 0 0 0 0 0 0 0 0 0 0 0`
`1 0 1 0 1 1 1 0 0 0 0 0 0 1 1`
`1 1 1 0 1 0 1 0 0 1 1 1 0 0 0`
В случае применения SCL гораздо проще изменять данные, длину последовательности и временные параметры симулируемого потока, что облегчает проверку алгоритма, обработку ошибок и т.п…
Скрипт SCL может разбирать входной файл и получать внешние команды. Например, помимо битового потока, можно изменять параметры сигналов.
Пример задания параметров ШИМ-кодированной посылки с синхро-преамбулой (команды парсятся SCL-скриптом и выставлябт соответствующие задержки):
`sync_bit_hi 2000 us`
`sync_bit_lo 500 us`
`pulse_lo 500 us`
`pulse_hi_0 500 us`
`pulse_hi_1 1000 us`
`1 0 0 0 1 1 0 1`
`wait 2 ms`
`1 1 1 1 0 0 0 0 1 0 1 0 1 0 1 0`
`wait 3 ms`
`0 0 0 0 1 1 1 1`
`1 0 1 0 1 0 1 1`
`wait 15 ms`
Умение работать с внешними файлами существенно расширяет возможности симуляции. Так, в «репозитории SCL» (ссылка в конце статьи) есть пример получения данных для симуляции из внешнего приложения (Input to a Simulation From an External Application). Данный пример симулирует матричную клавиатуру и входной сигнал для АЦП (написано на VBA в Excel). «Нажатия» кнопок и изменения напряжения записываются в два файла, SCL скрипт читает эти файлы и симулирует изменение логических уровней портов В/В и напряжение на входе АЦП.
Итоги
=====
SCL-программе доступны метки, адреса и переменные отлаживаемого.с или .asm кода. Доступно состояния регистров, программного счетчика микроконтроллера, время симуляции. SCL позволяет формировать несколько параллельных процессов в пределах одного testbench. Например, на одном входе формируем битовую последовательность, читаем данные с другого pin, обрабатываем и управляем состоянием других входов или состоянием регистров микроконтроллера.
Таким образом, SCL помогает организовать testbench-и для отладки кода микроконтроллера. Так как SCL является частью родного симулятора, то в одном проекте и в одном цикле отладки доступны SCL-сценарии (да, к отлаживаемому проекту можно подключать несколько SCL скриптов), точки останова, секундомер, стек, логический анализатор и др., выполняется симуляция периферии (таймера, UART, АЦП и пр.), прерывания и все это работает в одной среде разработки.
Следует отметить и некоторые недостатки текущей реализации SCL:
— ограниченные возможности отладки SCL кода (при подключении к проекту скрипта с ошибкой получаем лишь сообщение типа «ошибка парсера в строке № xx»). Если при подключении скрипта вы получили сообщение о дублировании переменных, то, скорее всего, вы подключили этот же тестбенч второй раз
— некоторые упрощения в текущей реализации (MPLAB X)
#### Подробнее о SCL можно почитать тут:
* SCL User's Guide (в составе документации пакета MPLAB X IDE, [www.microchip.com/mplabx/](http://www.microchip.com/mplabx/))
* [Язык SCL](http://pic24.ru/doku.php/osa/articles/scl)
* [SCL Code repository](http://www.microchip.com/forums/m109149.aspx)
* [SCL PRIMER / TUTORIAL](http://www.microchip.com/forums/m111255.aspx) | https://habr.com/ru/post/262845/ | null | ru | null |
# Аппаратное ускорение корпоративных вычислений
“Ускоренные вычисления” (Accelerated Computing) – модель вычислений, при которой в тандеме с традиционными CPU применяются узкоспециализированные сопроцессоры (“ускорители”). Основной задачей сопроцессоров является высокопараллельное выполнение интенсивной вычислительной нагрузки и высвобождение ресурсов CPU для других нужд приложения (“offloading”).
Хорошими примерами таких “ускорителей” могут служить GPU от NVIDIA или сопроцессоры Xeon Phi, без которых не обходится практически ни один проект в сфере научных или инженерных вычислений. Однако в корпоративном секторе подобные технологии практически не применялись (если не считать использование GPU в [фермах виртуализации рабочих мест](http://www.jetinfo.ru/article/oblaka-virtualizatsiya/3d-grafika-udalenno-i-v-sredakh-vdi-obzor-na-360)).
Именно поэтому выход серверов на чипе Oracle SPARC M7, содержащего помимо ядер общего назначения специализированные сопроцессоры Data Analytics Accelerators (DAX), можно считать отправной точкой в проникновении “ускоренных вычислений” на корпоративный рынок.
Основной задачей DAX является ускорение [in-memory вычислений](https://habrahabr.ru/company/jetinfosystems/blog/260455/) за счёт разгрузки основных ядер путём выполнения операций поиска по содержимому оперативной памяти на сопроцессорах.
В случае необходимости переноса операции поиска на DAX ядро общего назначения формирует запрос и передаёт его на выполнение “ускорителям”, после чего продолжает выполнение основного кода. При этом происходит автоматическое распараллеливание задачи по всем акселераторам чипа, а затем сбор результатов (похоже на MapReduce) в кэше чипа и уведомление ядра о завершении операции. Сопроцессоры подключены к L3-кэшу чипа, что позволяет обеспечить быстрое взаимодействие с ядрами общего назначения и передачу результатов поиска:
Стоит отметить, что для обеспечения возможности поиска по данным с помощью DAX они должны располагаться в памяти в специальном формате (In-Memory Column Store). Характерным свойством этого формата является возможность хранения данных в сжатом виде (алгоритм сжатия – проприетарный Oracle Zip), что позволяет разместить в оперативной памяти больший объём информации и положительно влияет на скорость обработки данных акселераторами за счёт экономии пропускной способности шины, связывающей чип и оперативную память. При поиске декомпрессия выполняется аппаратно, средствами DAX, и не влияет на производительность. Другой особенностью является наличие индексов, содержащих минимальные и максимальные значения для каждого из множества сегментов памяти (In-Memory Compression Units – IMCUs), составляющих In-Memory Column Store. Получается, что “ускорение” выборки имеет свою цену – долгое первичное размещение данных в памяти, во время которого происходит их сжатие и предварительный анализ (своего рода индексирование).
Основным потребителем данной технологии на данный момент является СУБД Oracle Database 12c, использующая DAX для ускорения операций поиска по таблицам, расположенным в In-Memory Column Store. СУБД автоматически переносит часть операций на DAX, что приводит к значительному ускорению некоторых запросов.
Однако нам в “Инфосистемы Джет” было интересно изучить технологию DAX без промежуточного “чёрного ящика” в виде СУБД Oracle Database, скрывающего интересные подробности и создающего дополнительные накладные расходы, не позволяющие точно оценить преимущества, создаваемые использованием сопроцессоров.
### Использование сопроцессоров DAX из сторонних приложений
В начале марта 2016 года Oracle открыла API доступа к DAX для независимых разработчиков (Open DAX API). Теперь DAX можно использовать не только в СУБД Oracle Database, но и в любых других приложениях.
Oracle пригласила всех желающих в [свое облако протестировать DAX](https://swisdev.oracle.com/DAX/) не только из СУБД, но и с использованием SDK для различных языков программирования (C, Python и Java). Поскольку низкоуровневый API, предназначенный для взаимодействия непосредственно с аппаратной частью сопроцессора, достаточно сложен, для ознакомления с новой технологией помимо самого SDK было предложено использовать дополнительную библиотеку, предоставляющую высокоуровневые средства для работы с данными (libvector), расположенными в оперативной памяти. Именно на её основе и был сделан ряд тестов для проверки работы DAX.
**Компоненты SDK**
### Сценарий тестирования
В качестве тест-кейса рассматривалась простая аналитическая задача – поиск значений в расположенном в памяти целочисленном массиве, удовлетворяющих заданному условию. В виде SQL-запроса эту задачу можно было бы записать так:
```
SELECT value FROM values WHERE value BETWEEN value_low AND value_high;
```
Задачу планировалось решать двумя способами – классическим перебором всех элементов и с помощью сопроцессоров DAX.
### Реализация
На языке C решение этой задачи выглядело приблизительно следующим образом:
```
#define RANDOM_SEED 42
int *values, *results;
int low = VALUE_LOW, high = VALUE_HIGH;
values = generate_random_values_array(NUM_VALUES, RANDOM_SEED);
results = malloc(NUM_VALUES * sizeof(int));
for (i=0; i= low && values[i] <= high) {
results[n] = values[i];
n++;
}
}
```
Отметим, что при поиске сразу происходит сохранение результатов в новый массив. Еще раз отметим, что вышеприведенный код выполняется на ядре основного процессора.
Для DAX поиск и получение результатов разделены на две операции:
```
#include /\* DAX \*/
#define RANDOM\_SEED 42
int low = VALUE\_LOW, high = VALUE\_HIGH;
vector valuesVec, bitVec, resultsVec;
valuesVec = generate\_random\_values\_vector(NUM\_VALUES, RANDOM\_SEED);
/\* Поиск \*/
bitVec = vector\_in\_range(valuesVec, &low, &high);
/\* Подсчёт количества значений, удовлетворяюших условию \*/
n = bit\_vector\_count(bitVec);
/\* Извлечение значений, удовлетворяюших условию \*/
resultsVec = vector\_extract(valuesVec, bitVec);
```
В случае с DAX операция поиска значений (функция vector\_in\_range), удовлетворяющих условию, возвращает битовый вектор (bit vector), на основе которого еще одним запросом (vector\_extract) формируется новый вектор с результатами. Искомые записи будут извлечены из своих IMCU и записаны в новые IMCU, с которыми снова можно работать через DAX.
Такой подход позволяет эффективно работать с наборами данных типа ключ/значение, когда требуется найти ключи, значения которых удовлетворяют условию. В этом случае в памяти формируются два массива данных – вектор ключей и вектор значений:
```
vector keysVec, valuesVec;
int low = VALUE_LOW, high = VALUE_HIGH;
populateKeyValueVectors(&keysVec, &valueVec);
```
Выполняется поиск по вектору значений с помощью DAX, результатом которого является битовая карта:
```
bitVec = vector_in_range(valuesVec, &low, &high);
```
Для извлечения искомых элементов полученная битовая карта применяется с помощью DAX к вектору ключей:
```
resultsVec = vector_extract(keysVec, bitVec);
```
К тому же над множеством битовых векторов можно проводить операции типа AND и OR, то есть перекладывать на DAX объединение результатов нескольких сравнений, как, например, в запросе:
```
SELECT part FROM parts WHERE mass > 100 AND volume < 30;
```
Наши эксперименты с объединением через AND двух битовых векторов показали преимущество вызова, выполненного на DAX:
```
bit_vector_and2(bitVec1, bitVec2);
```
Перед поэлементным (с элементами типа long) объединением битовых карт на процессоре вида:
```
for (i=0; i
```
в 3–6 раз по скорости выполнения в зависимости от количества элементов.
Но вернемся к программе. Элементами нашего массива будут случайные целые числа, а поиск будет выполняться по диапазону от –109 до 109 (то есть примерно половина чисел будет удовлетворять условию).
Мы запустили оба варианта реализации нашего теста несколько раз на количествах чисел в массиве от 1 миллиона до 500 миллионов и измерили время выполнения поиска и время копирования результатов в новый массив, с которым можно снова работать. Для классического перебора не имеет смысла разделять эти две операции, т.к. копировать в новый массив придется либо адрес элемента (8 байт), либо сам элемент (4 байта).
### Результаты
Итак, ниже представлен график зависимости времени поиска и получения данных от количества элементов массива:
Использование DAX показало 2-кратное превосходство над простым перебором. Если сравнивать только поиск (без сохранения найденных значений, т.е. при выполнении операции вида “SELECT COUNT (\*)" или в целях получения битовой карты), то скорость поиска через DAX более чем в 5 раз выше.
Следить за использованием сопроцессоров в системе можно с помощью утилиты busstat, собирающей метрики производительности с различных компонентов процессора (busstat -w dax 30 1). Во время выполнения наших тестов мы наблюдали распараллеливание запросов на 8 из 32 сопроцессоров DAX (в каждом процессоре M7 их по восемь). При использовании нескольких пользовательских процессов параллельно загрузка будет видна на всех 32 сопроцессорах.
Безусловно, можно реализовать все алгоритмы DAX программно (что и было реализовано в Oracle Database In-Memory Option до появления DAX), сделать дополнительные оптимизации и получить ещё более впечатляющие результаты, чем с DAX (особенно если вручную распараллелить задачу на все процессорные нити SPARC M7). Но назначение DAX в том, чтобы переложить работу ядер процессора на специализированные сопроцессоры. Т.е. в целом важен не сам прирост производительности, а именно возможность разгрузки основного CPU.
### Прочие интересные моменты
В числе примеров кода для DAX инженеры Oracle реализовали его поддержку в [приложении для Apache Spark](https://community.oracle.com/docs/DOC-994843). По заверениям производителя, при использовании DAX производительность выросла в 6 раз. Суть оптимизации заключалась во множестве операций с битовыми картами через DAX, что получилось гораздо быстрее, чем на процессоре.
### Выводы
Перенос исполнения программной логики с процессоров на специализированные устройства в очередной раз доказал свою целесообразность. Особенно в такой «горячей» в настоящий момент области как In-Memory Computing.
Возможность использовать DAX через открытый API может привлечь в мир SPARC новые программные продукты.
Однако подобные функции могут быть реализованы в будущем и на платформе Intel на уже существующих аппаратных решениях – с использованием сопроцессора Xeon Phi. Как минимум исследования в этой области уже ведутся:
1. [Rethinking SIMD Vectorization for In-Memory Databases](http://www.cs.columbia.edu/~orestis/sigmod15.pdf).
2. [Design of an In-Memory Database Engine Using Intel Xeon Phi Coprocessors](http://worldcomp-proceedings.com/proc/p2014/PDP3429.pdf).
### Post Scriptum
Тестовые программы собирались с помощью компилятора Solaris Studio 12.4. Использовался максимальный уровень оптимизации (-xO5), с помощью которого удавалось значительно ускорить “классические” вычисления. Исходные коды доступны на [github](https://github.com/dglushenok/labDAX).
[SPARC M7 и DAX – официальный релиз Oracle](https://www.oracle.com/ru/corporate/pressrelease/free-open-apis-and-developer-kit-for-dax-20160308.html).
---
Статья подготовлена Дмитрием Глушенком, системным архитектором Центра проектирования вычислительных комплексов компании «Инфосистемы Джет». Мы будем рады вашим конструктивным комментариям. | https://habr.com/ru/post/307862/ | null | ru | null |
# Асимметричный алгоритм для генерации коротких серийных номеров
**Введение**
Хуже всего, когда для вашей программы создан генератор серийных номеров. Взломанные (переделанные) версии программ используют куда менее охотно – есть риск подхватить вирус или потерять данные. А вот когда есть возможность скачать подлинную программу с официального сайта и самостоятельно сгенерировать номер – это катастрофа для разработчика.
Единственный известный мне способ обезопасить себя от SNG (Serial Number Generator) – применение асимметричного алгоритма цифровой подписи. В таком случае, генерируется 2 ключа: открытый и закрытый. В программе зашит открытый ключ, он служит для проверки серийных номеров. Закрытый ключ есть только у разработчика: с его помощью можно сгенерировать серийный номер (по сути, серийный номер является подписью имени пользователя и лицензионной информации).
Подобрать закрытый ключ и сделать SNG в таком случае – практически невозможно. Данная защита взламывается только созданием модифицированной версии программы с подменой публичного ключа. Но и это не всегда простая задача.
Очень часто разработчики применяют RSA, в качестве алгоритма цифровой подписи для геренации SN. Очевидный недостаток: SN получается весьма длинным. Вот подпись ключом длиной 512 бит (практически, минимальная длина ключа):
`7095C60FC9ABE8968A1DDB8A9E36FCF0DBDDAC6ACE0B648E9ED72B6DC7E06880
ACF7DCC058A7433340B01E2409579210B8ACE2B3F663D2368ACEE815E3FF6E1B`
Очевидно, что такой SN ввести с этикетки коробочной версии продукта или продиктовать по телефону будет довольно проблематично :)
Какие же есть решения?
Один из известных алгоритмов цифровой подписи с короткой подписью – **HFE**. К сожалению, он запатентован и его использование стоит денег.
**Теперь о главном**
Хочу предложить вашему вниманию альтернативный алгоритм с открытым/закрытым ключом, который идеально подходит для генерации коротких серийных номеров. Он очень простой, надежный и абсолютно бесплатный. К статье прикреплен файл с реализацией алгоритма на языке C#.
Алгоритм весьма простой, но достаточно устойчив против SNG.
По вопросу авторства. Мне не встречалось описание этого алгоритма, по-этому пока считаю себя его первооткрывателем (пусть даже он очень простой). Если кто-нибудь докажет обратное, буду благодарен.
Итак, несколько фактов об этом алгоритме:
Данные приведены в формате: длина подписи; процессорное время, необходимое для взлома:
4 байта ~100 лет
5 байт ~35 тыс. лет
6 байт 8 млн. лет
Как видите, даже очень короткая подпись является весьма надежной. Хотя, время взлома можно задавать в разумных пределах: чем большее время взлома вы зададите, тем дольше будет и проверяться цифровая подпись, тем дольше будут генерироваться открытый/закрытый ключи. В таблице выше приведено время взлома, при котором цифровая подпись проверяется 1 сек. (вполне приемлемо для проверки SN при регистрации программы). За время подписи отвечает константа INTRICACY, объявленная в классе KuSigner.
Второй важный параметр – длина ключа. Чем длиннее ключ, тем меньше коллизий, но и тем дольше он генерируется. Длина должна быть равной количеству продвинутых недобросовестных пользователей вашей программы (у которых хватит ума и наглости объединиться с целью поиска коллизий).
Стойкость алгоритма основана на необратимости функции хеширования. В моей реализации используется алгоритм MD4 (моя собственная реализация на C#). Хотя в этом алгоритме (MD4) найдены коллизии и для многих задач он не подходит, для нашей задачи он является вполне надежным. Параноики, конечно, могут заменить его на SHA1.
Чтобы понять в деталях как работает мой алгоритм – лучше всего посмотрите исходный код. Имхо, так будет проще всего.
Теперь несколько простых примеров использования моего кода:
1. Генерация ключей:
> `KuSigner kuSigner = new KuSigner(1000, 5); // стойкость ключа (в недобросовестных клиентах :)), длина подписи
>
> kuSigner.GenerateKeys(); // генерация ключей: открытый и закрытый
>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/69623/ | null | ru | null |
# Выпущена 3CX v16 Beta 1 с поддержкой Raspberry Pi
С удовольствием представляем очередную версию нашей системы 3CX v16 Beta 1. Финальный релиз не за горами! стали еще ближе к выпуску финального релиза. А сейчас позвольте представить новые возможности, улучшения и поддержку новой платформы, появившиеся в Beta 1.
Работа на платформе Raspberry Pi
--------------------------------
Не так часто сложный программный продукт адаптируется для поддержки новой аппаратной архитектуры. Да, это было непросто реализовать для системы реального времени, которой является 3CX.
Но мы сделали это! 3CX v16 теперь работает на устройствах размером с мыльницу — Raspberry Pi 3B+. Мы подготовили руководство по установке v16 на Raspberry Pi, которое приведено ниже. Устанавливайте и [пользуйтесь бесплатно](https://www.3cx.ru/ip-pbx/download-atc/)!
Записи разговоров на внешнем хранилище
--------------------------------------
3CX v16 Beta 1 включает новую систему управления записями разговоров, поддерживающую перенос файлов записей на внешнее хранилище, поиск, отбор, а также автоматическое удаление старых записей. Теперь можно автоматически, по расписанию, переносить записи разговоров на Google Drive или FTP-сервер, включив опцию Remote Archiving. Таким образом вы освобождаете ценное место на диске (или Flash-карте) сервера АТС. Кроме того, это решение позволяет ускорить обновление или переустановку 3CX.
В разделе **Записи разговоров** также появилась новая функция **Purge**. Она удаляет локальные или находящиеся во внешнем хранилище записи. Также она позволяет перенести локальные записи во внешнее хранилище (заархивировать). Теперь можно удешевить «железо» АТС, перемещая архив разговоров в недорогое внешнее облачное хранилище. Функция **Фильтр** позволяет отобрать записи разговоров за нужный период или на определенные номера телефонов. Подробнее об этих возможностях в нашем [руководстве](https://www.3cx.com/docs/manage-recordings/).
Панель Оператора АТС в отдельном окне
-------------------------------------
Веб-клиент в 3CX v16 Beta 1 получил важное обновление — вкладки Панели оператора АТС теперь можно открывать в отдельных окнах. Руководители и операторы колл-центра могут использовать отдельные окна для мониторинга вызовов так же, как это работало в клиенте 3CX для Windows. В целом, все функции клиента для Windows, связанные с мониторингом вызовов, уже перенесены в веб-клиент — все работает в браузере!
Демонстрация экрана в 3CX WebMeeting без плагинов
-------------------------------------------------
При внедрении любой новой системы возникает важный вопрос – сложность первоначального запуска. Стараясь упростить начало работы с видеоконференциями, мы использовали последние технологии браузера Chrome 72 и доработали WebMeeting, чтобы отказаться от установки дополнительного плагина.
Теперь пользователи могут демонстрировать свой экран как с установленным плагином 3CX Click2Call (старые версии Chrome), так и без него.
Просто выберите режим отображения — весь экран или окно приложения — и ваш рабочий стол будет демонстрироваться в конференцию! Для использования этой возможности установите [последнюю версию Chrome](https://www.google.com/chrome/).
Загрузки 3CX v16 Beta 1
-----------------------
3CX v16 Beta 1 доступна для Windows или Linux, либо через сервис [PBX Express](https://pbxexpress.3cx.com/) для создания готовой АТС в облаке.
* Windows: [3CX v16](https://downloads-global.3cx.com/downloads/3CXPhoneSystem_16.0.0.1375.exe)
* Linux: [3CX v16 on Debian 9 ISO](https://downloads-global.3cx.com/downloads/debian9iso/debian-amd64-netinst-3cx.iso) — выберите «Beta» на экране «3CX Update Channel».
* [Журнал изменений](https://www.3cx.com/blog/change-log/phone-system-change-log/)
### Известные проблемы и ограничения
* Пользователи не могут отбирать свои записи разговоров и записи разговоров группы в веб-клиенте (будет доступно в релизе 3CX v16).
* Не отображается индикация фоновой архивации записей в интерфейсе управления 3CX (будет доступно в релизе 3CX v16).
* Неуспешные обратные вызовы из Очереди не включаются в отчет «Неудачные обратные вызовы», если был запрошен обратный вызов, но в 3CX вызов ушел по правилу «Направление при неответе» (будет устранено в релизе 3CX v16).
* Аудиоконференции, запланированные в календаре Google, содержат пустое описание события (будет устранено в релизе 3CX v16).
Установка АТС 3CX на Raspberry Pi
---------------------------------
Начиная с 3CX v16, можно установить АТС на новейшие устройства Raspberry Pi, model 3B+. Система устанавливается на ОС Raspbian Stretch — дистрибутив Debian Linux для архитектуры Raspberry Pi ARM. Управлять ОС Debian можно как через веб-интерфейс 3CX (основные команды администрирования), так и через интерфейс командной строки, если вы опытный пользователь Linux.
Обратите внимание, что установка 3CX на Raspberry Pi рекомендуется для систем на 8 одновременных вызовов с 16-24 пользователями. У каждого пользователя может быть настроено в среднем до 8 BLF-индикаторов (передача BLF-статусов оказывает нагрузку на сервер АТС).
Дополнительные требования:
* Карта памяти: 32+GB Class 10 Micro SDHC
* Источник питания: совместимый с Raspberry Pi, 2.5 A, Micro USB
### Подготовка SD-карты для Raspbian ОС
Для установки Raspbian на карту micro-SD скачайте и разархивируйте образ Raspbian Stretch Lite [отсюда](https://www.raspberrypi.org/downloads/raspbian/).
Запишите образ на SD-карту, используя утилиты [Etcher](https://etcher.io/) или [Win32 Disk Imager](https://sourceforge.net/projects/win32diskimager/). Затем вставьте карту и запустите устройство.
После загрузки ОС, зайдите в систему с учетными данными администратора по умолчанию (пользователь `pi`, пароль `raspberry`). Пароль по умолчанию pi можно изменить командой `passwd`.
Обратите внимание, что в Raspbian Linux для выполнения административных задач следует использовать команду `sudo`. Например, для проверки обновлений пакетов в репозиториях используйте команду `sudo apt update`.
### Установка имени хоста и IP-адреса устройства
Для установки имени хоста в системе Pi запустите утилиту настройки Raspbian командой `sudo raspi-config`.
Выберите 2. Network Options > N1 Hostname и OK в предупреждающем диалоговом окне. Укажите имя хоста и перезагрузите устройство. Проверить новое имя хоста можно командой `hostname`.
Для установки статического IP-адреса интерфейса eth0, измените файл /etc/dhcpcd.conf используя редактор nano: `sudo nano /etc/dhcpcd.conf`
Перейдите в конец файла и измените значения параметров: ip\_address, routers (шлюз по умолчанию) и domain\_name\_servers. Используйте соответствующие параметры вашей сети, например:
```
#eth0 static IP configuration
interface eth0
static ip_address=192.168.1.111/24
static routers=192.168.1.1
static domain_name_servers=192.168.1.1 8.8.8.8
```
Сохраните новые параметры и перезагрузите устройство `sudo reboot`. Проверить новый IP-адрес можно командой `ifconfig eth0`.
### Установка 3CX на Raspbian
Для установки 3CX на Raspbian, зайдите в систему через SSH под пользователем pi, а затем:
Установите ключ 3CX APT для аутентификации пакетов:
```
wget -O- http://downloads-global.3cx.com/downloads/3cxpbx/public.key | sudo apt-key add -
```
Создайте файл исходников 3CX APT (релизов и тестовых):
```
echo "deb http://downloads-global.3cx.com/downloads/debian stretch main" | sudo tee /etc/apt/sources.list.d/3cxpbx.list
echo "deb http://downloads-global.3cx.com/downloads/debian stretch-testing main" | sudo tee /etc/apt/sources.list.d/3cxpbx-testing.list
```
Обновите исходники APT и пакеты
```
sudo apt update
```
Проверьте доступность пакета АТС 3CX
```
sudo apt-cache policy 3cxpbx
```
Установите стабильный релиз АТС 3CX
```
sudo apt -t stable install 3cxpbx
```
Также можно установить тестовый релиз
```
sudo apt -t testing install 3cxpbx
```
Установка пакетов занимает примерно 5-10 минут в зависимости от производительности устройства.
После завершения установки выберите способ первоначальной настройки 3CX: (1) через веб-браузер и (2) через командную строку. Если выбрана первая опция, в браузере введите URL первоначальной настройки: http://:5015 (см. [подробное руководство](https://www.3cx.ru/docs/manual/configuring-your-pbx/)).
Повторный запуск Мастера первоначальной настройки 3CX командой `sudo /usr/sbin/3CXWizard --cleanup` инициализирует конфигурацию 3CX. При этом удаляются все данные, включая резервные копии и записи разговоров! Если необходимо, сохраните эти данные на другом устройстве.
### Удаление 3CX в Raspbian
Для деинсталляции 3CX в Raspbian используйте одну из следующих команд:
* `sudo apt remove 3cxpbx` — удаляются системные файлы 3CX, сохраняя рабочие данные (записи разговоров, базу данных АТС, файлы пользователей и т.п.). Используйте, если в дальнейшем планируете переустановить 3CX.
* `sudo apt remove --purge 3cxpbx` — полностью удаляется система 3CX, включая рабочие данные. | https://habr.com/ru/post/440478/ | null | ru | null |
# Точность через неточность: Улучшаем Time-объекты
> При создании value-объекта для хранения времени, я рекомендую выбирать вместе с экспертами в предметной области и вокруг нее с какой точностью он будет храниться.
Моделируя работу с числами считается хорошим тоном указывать точность. Неважно о чем идет речь — о деньгах, размере или весе; округляйте до заданного десятичного знака. Наличие округления делает данные предсказуемее для обработки и хранения, даже если это число только для отображения пользователю.
К сожалению, так делают не часто, и, когда приходит момент, проблема дает о себе знать. Рассмотрим следующий код:
```
$estimatedDeliveryDate = new DateTimeImmutable('2017-06-21');
// представим, что сегодня ТАКЖЕ 2017-06-21
$now = new DateTimeImmutable('now');
if ($now > $estimatedDeliveryDate) {
echo 'Package is late!';
} else {
echo 'Package is on the way.';
}
```
Ожидаемо что, что 21 июня этот код выведет `Package is on the way.`, ведь день еще не закончился и пакет, например, доставят ближе к вечеру.
Несмотря на это код так не делает. Так как не указана часть со временем, PHP заботливо подставляет нулевые значения и приводит `$estimatedDeliveryDate` к `2017-06-21 00:00:00`.
С другой стороны `$now` вычисляется как… сейчас. `Now` включает в себя текущий момент времени, который, скорее всего, не полночь, так что получится `2017-06-21 15:33:34` или вроде того, что будет позднее, чем `2017-06-21 00:00:00`.
Решение 1
---------
“О, это легко исправить.” скажут многие, и обновят необходимую часть кода.
```
$estimatedDeliveryDate = new DateTimeImmutable('2017-06-21');
$estimatedDeliveryDate = $estimatedDeliveryDate->setTime(23, 59);
```
Круто, мы изменили время до полуночи. Но теперь время дополняется до `23:59:00`, так что если вы запустите код в последние 59 секунд дня, вы получите те же проблемы.
“Брр, ладно.” — последует ответ.
```
$estimatedDeliveryDate = new DateTimeImmutable('2017-06-21');
$estimatedDeliveryDate = $estimatedDeliveryDate->setTime(23, 59, 59);
```
Отлично, теперь это исправлено.
… До тех пор, пока вы не обновитесь до PHP 7.1, который добавляет микросекунды в `DateTime`-объекты. Так что теперь проблема возникнет на последней секунды дня. Возможно я стал слишком предвзят, работая с высоконагруженными трафик-системами, но пользователь или процесс обязательно наткнутся на это. Удачи в поисках ЭТОГО бага. :-/
Окей, добавим микросекунд.
```
$estimatedDeliveryDate = new DateTimeImmutable('2017-06-21')
$estimatedDeliveryDate = $estimatedDeliveryDate->modify('23:59:59.999999');
```
И теперь это работает.
Пока не получим наносекунды.
В PHP 7.2.
Ладно, ладно, мы МОЖЕМ уменьшать погрешность все дальше и дальше до того момента, когда появления ошибки станет малореалистичным. На этом моменте ясно, что такой подход ошибочен: [мы гонимся за бесконечно делимым значением и становимся все ближе и ближе к точке, которую не можем достичь](https://en.wikipedia.org/wiki/Zeno%27s_paradoxes#Dichotomy_paradox). Давайте попробуем другой подход.
Решение 2
---------
Вместо того, чтобы вычислять последний момент перед нашей границей, давайте проверим вместо этого сравнение границ.
```
$estimatedDeliveryDate = new DateTimeImmutable('2017-06-21');
// Начнем считать от момента, когда уже поздно, а не от последнего необходимого момента
$startOfWhenPackageIsLate = $estimatedDeliveryDate->modify('+1 day');
$now = new DateTimeImmutable('now');
// Мы изменили оператор > на >=
if ($now >= $startOfWhenPackageIsLate) {
echo 'Package is late!';
} else {
echo 'Package is on the way';
}
```
Этот вариант работает и будет работать в течении дня. Такой код выглядит сложнее. Если не инкапсулировать эту логику в value-объект или во что-то похожее, вы обязательно пропустите это где-нибудь в вашем приложении.
Даже если сделать это, только один тип операций (>=) будет логичным и последовательным, для остального это не работает. Если мы реализуем поддержку проверки равенства, придется сделать еще один тип данных, а затем жонглировать ими для корректной работы. Хех.
Наконец (возможно только для меня) это решение имеет неприятные моменты в виде потенциально пропущенной концепции домена. "Существует ли LatePeriodRange? A DeliveryDeadline?" могли бы вы спросить. "Пакет опоздал и… что-то будет? Эксперт не говорил о сроках, вроде бы сроков нет. Чем это отличается от EstimatedDeliveryDate? Что потом?". Пакет никуда не идет. Это просто странная особенность построенной логики, которая застряла теперь в голове.
Это лучшее решение в предоставлении правильного ответа… но это не очень хорошее решение. Посмотрим, что еще можно сделать.
Решение 3
---------
Наша цель — сравнить два дня. Представим `DateTime`-объект c `now` в виде набора цифр (год, месяц, день, час, минута, секунда и т.д.), тогда часть до дня будет работать нормально. Проблемы начинаются из-за дополнительных показателей: час, минута, секунда. Можно спорить о хитрых способах решения проблемы, но факт остается фактом — компонент времени вредит нашим проверкам.
Если нам важна только часть с днем, то зачем мириться с этими дополнительными значениями? дополнительные часы или минуты не должны менять логику бизнес-правил, если важен только переход в следующий день.
Просто выкинем лишний хлам подальше.
```
// Упрощаем дату до дня, отбрасывая остальное
$estimatedDeliveryDate = day(new DateTimeImmutable('2017-06-21'));
$now = day(new DateTimeImmutable('now'));
// Теперь сравнение стало проще
if ($now > $estimatedDeliveryDate) {
echo 'Package is late!';
} else {
echo 'Package is on the way.';
}
// Неуклюжий, но эффективный способ уменьшения точности
// Как мы видели, PHP подставит ноль для неуказанных значений
function day(DateTimeImmutable $date) {
return DateTimeImmutable::createFromFormat(
'Y-m-d',
$date->format('Y-m-d')
);
}
```
Это упрощает сравнение или расчет того что есть в решении 1, с точностью из решения 2. Но… это самый уродливый вариант, плюс, при такой реализации очень легко забыть вызвать `day()`.
Такой код легко превратить в абстракцию. Теперь, когда прояснилась ситуация с предметной областью, ясно: когда мы говорим о сроках доставки, мы говорим о дне, не о времени. Обе эти вещи делают код хорошим кандидатом для инкапсуляции внутрь типа.
Инкапсуляция
------------
Другими словами, давайте сделаем этот value-объект.
```
$estimatedDeliveryDate = EstimatedDeliveryDate::fromString('2017-06-21');
$today = EstimatedDeliveryDate::today();
if ($estimatedDeliveryDate->wasBefore($today)) {
echo 'Package is late!';
} else {
echo 'Package is on the way.';
}
```
Посмотрите как читается код. Теперь реализуем value-объект:
```
class EstimatedDeliveryDate
{
private $day;
private function __construct(DateTimeInterface $date)
{
$this->day = DateTimeImmutable::createFromFormat(
'Y-m-d',
$date->format('Y-m-d')
);
}
public static function fromString(string $date): self
{
// Тут можно валидировать YYYY-MM-DD формат и т.д.
return new static(new DateTimeImmutable($date));
}
public static function today(): self
{
return new static(new DateTimeImmutable('now'));
}
public function wasBefore(EstimatedDeliveryDate $otherDate): bool
{
return $this->day < $otherDate->day;
}
}
```
Имея в наличии класс, автоматически получаем полезное ограничение: сравнение `EstimatedDeliveryDate` идет только с другим `EstimatedDeliveryDate`, теперь точность будет сходиться.
Обработка с необходимой точностью расположена в одном месте. Консьюмерский код никак не касается этой работы.
Это легко тестировать.
И у вас есть отличное место для централизованного хранения обработки часовых поясов (не обсуждается в статье, но важно).
Один совет: Я использовал метод `today()` чтобы показать, что есть возможность создавать несколько конструкторов. На практике я бы рекомендовал добавить класс системных часов и получать экземпляры `now` оттуда. Так намного легче писать юнит-тесты. "Реальная" версия будет выглядеть так:
```
$today = EstimatedDeliveryDate::fromDateTime($this->clock->now());
```
Точность через неточность
=========================
Важно понимать, нам удалось снять несколько различных видов ошибок за счет уменьшения точности `DateTime`, обработкой которого мы занимались. Если бы мы это не сделали, нам пришлось бы обрабатывать все проблемные стороны и, скорее всего, в каком-нибудь случае все пошло бы не так.
Снижение качества данных для получения правильного результата может показаться нелогичным, но на самом деле это более реалистичный взгляд на систему, которую мы пытаемся моделировать. Наши компьютеры могут работать за пикосекунды, но наш бизнес (скорее всего) нет. Плюс, [компьютер, вероятно, лжет](https://blogs.msdn.microsoft.com/ericlippert/2010/04/08/precision-and-accuracy-of-datetime/).
Возможно, как разработчики, мы чувствуем. что лучше быть более гибким и перспективным, сохраняя всю возможную информацию. В конце концов, кто вы такой, чтобы решать какую информацию выбрасывать? Истина заключается в том, что информация *потенциально* может стоить денег в будущем, в настоящем же она *наверняка* стоит расходов на ее содержание до наступления возможного будущего. Это не только стоимость места на жестком диске, это стоимость проблем, людей, времени, и, в случае ошибки, репутации. Иногда работала с данными в наиболее полной их форме будет оправдывать себя, но иногда слепое сохранение всего, что вы можете, только потому что можете, не стоит того.
Чтобы было понятней: я не рекомендую вам просто бездумно удалять доступную информацию о времени.
**Я рекомендую**: четко выбрать точность для ваших отметок времени вместе с экспертами в предметной области. Если вы можете получить большую точность, чем ожидаете — это может повлечь за собой ошибки и дополнительную сложность. Если вы получаете меньше необходимой точности — это также вызовет проблемы и несрабатывание бизнес-логики. Важно то, что мы определяем ожидаемый и необходимый уровень точности.
Также, выбирайте точность отдельно для каждого случая использования. Округление обычно реализуется внутри value-объекта, а не на уровне системных часов. Кое-где нужна точность до наносекунд, но кому-то может понадобиться только год. Правильное получение точности сделает ваш код более ясным.
Оно везде
---------
Стоит отметить, что мы говорили только об одном конкретном типе ошибок: несовпадение требуемой точности для проверок. Но этот совет применим к гораздо более широкому кругу ошибок. Не буду вдаваться во все из них, но все же хочу отметить мою любимую, "остаточная" погрешность.
```
// Предположим, что сегодня 21 июня, таким образом перменная будет иметь значение 28 июня
$oneWeekFromNow = new DateTimeImmutable('+7 days');
// Также 28 июня возьмем из БД
$explicitDate = new DateTimeImmutable('2017-06-28');
// Сравним, эти же одинаковые даты?
var_dump($oneWeekFromNow == $explicitDate);
```
Нет, они неодинаковы, потому что `$oneWeekFromNow` также хранит текущее время, в то время как `$explicitDate` имеет значение `00:00:00`. Восхитительно.
Приведенные выше примеры говорили о точности, в первую очередь, при сравнении времени против даты, но моделирование точности распространяется на любую единицу времени. Представьте, какому количеству приложений для планирования требуется только время, а какому количеству финансовых приложений требуется поддержка точности по кварталам года.
Как только начинаешь смотреть на проблему, понимаешь, сколько ошибок со временем может быть объяснено неопределенной точностью. Они могут выглядеть как некорректные проверки или плохо спроектированные логические рамки, но при погружении в это, вы начнете видеть как вырисовывается картина.
Мой опыт показывает, что этот класс ошибок часто пропускается при тестировании. Объекты с системными часами не являются привычными вещами (пока), поэтому тестирование кода, использующего текущее время немного сложнее. Данные для тестов часто не предоставляются в таком формате, который получается в системе, что приводит к появлению ошибок.
И это не проблема конкретной `DateTime`-библиотеки в PHP. Когда я писал об этом на прошлой недели, Anthony Ferrara упомянул, что точность времени в Ruby варьируется в зависимости от операционной системы, но библиотека для работы БД имеет фиксированный уровень. Весело такое отлаживать
Работать со временем сложно. Сравнивать время — вдвойне.
Выбор уровня точности
---------------------
Говоря, что выбор уровня точности важен, мы не говорили о том как выбрать правильный. Как правило, нужно иметь достаточную точность временных отметок для технических нужд и одновременно задавать уровень точности для объектов домена.
Для логов, отметках о событиях, метрик выбирайте детализацию по желанию. Такие данные в первую очередь необходимы техническому персоналу, для них дополнительная точность часто необходима при отладке. Также, вероятно, высокая точность понадобится для системных или последовательных данных.
В случае бизнес-задач поговорите с экспертами в предметной области о необходимой точности информации. Они могут помочь сбалансировать между тем, что используются сейчас и тем, что понадобится в будущем. Бизнес-логика часто бывает областью, где приходится оперировать заемными знаниями, поэтому уменьшение сложности будет умным ходом. Помните, вы не строите модель прямо-как-в-реальной-жизни, вы строите полезную модель.
В жизни это приводит к необходимости наличия различной степени точности, даже в пределах одного класса. Рассмотрим этот класс приложения:
```
class OrderShipped
{
// Объект из бизнес-логики (доставка), требуется точность до дня
private $estimatedDeliveryDate;
// Объект из бизнес-логики (доставка), требуется точность до секунды
private $shippedAt;
// Event sourcing объект, требуется точность до микросекунд
private $eventRecordedAt;
}
```
Если наличие нескольких уровней точности кажутся странными, напомню, что эти отметки времени используются по разному. Даже `$shippedAt` и `$eventRecordedAt` указывают на одно и тоже "время", но относятся к совершенно разным частям кода.
Вам возможно попадется бизнес, который работает с блоками времени, которые вы можете не ожидать: кварталы, финансовые календари, смены, делением на утро, день или вечер. Много интересного опыта получится при работе с этими дополнительными единицами.
Изменение требований
====================
Еще одна хорошая часть обсуждений: если бизнес-правила изменятся в будущем, потребуется больше точности, чем изначально договаривались, то это будет совместным решением и станет ясно что делать с уже накопленными данными. В идеале, это избавит бизнес от технических проблем.
Это несложно: "Изначально требовалась только дата регистрации, но теперь нужно время, чтобы увидеть регистрации до времени закрытия офиса". Простым способом решения будет установить время до начала следующего рабочего дня, возможно, небольшое количество учетных записей будет некорректным, но для большинства приемлемо. Или просто нули. Или в компании есть дополнительные бизнес-правила, когда после 18-00 дата окончания подписки выставляется в `tomorrow +1 year` вместо `today +1 year`. Обсудите с ними это. Люди активнее и лояльнее к изменениям, если их включить в обсуждение с самого начала.
В более сложных случаях обратитесь к восстановлению данных на основе других данных в системе. Возможно, время регистрации хранится в логах или метриках. В некоторых случаях сделать это будет просто невозможно и вам придется создавать новую логику для переноса легаси-случаев. Но ведь невозможно спланировать все, и, скорее всего, не знаете что поменяется. Это жизнь.
Мое заключение о точности времени: используйте что нужно, не больше.
Приложение: Идеальное Решение
-----------------------------
Двигаясь вперед, я чувствую, что есть практическая польза от выбора фиксированной точности и использования классов. Моя идеальная PHP библиотека для работы со временем выглядела бы так: набор абстрактных классов обозначающих точность, от которых я наследуюсь в моих value-объектах и использую при сравнении.
```
class ExpectedDeliveryDate extends PointPreciseToDate
{
}
class OrderShippedAt extends PointPreciseToMinute
{
}
class EventGenerationTime extends PointPreciseToMicrosecond
{
}
```
Перемещая вопрос точности в класс, мы берем ответственность за решение. Можно ограничить методы, такие как `setTime()` до необходимой точности, округлять `DateInterval`, делать все, что имеет смысл при работе со временем. Инкапсулируем большинство методов value-объектов и наружу выставим только необходимые для предметной области. Кроме того, таким образом мы поощрим людей создавать сами value-объекты. Очень. Много. Value-объектов. Даааааа.
Бонусом будет, если библиотека дает возможность легко определять пользовательские единицы времени.
Кто-нибудь сделал такую? Неужели ни у кого нет времени? | https://habr.com/ru/post/335494/ | null | ru | null |
# Настройка playbook в Ansible
В этой статье мы настроим playbook Ansible таким образом, чтобы c его помощью мы могли удаленно автоматизировать Windows Server 2019 платформа x64, с Linux Ubuntu.
Для этого нужно подготовить Ubuntu и Ansible, а также Windows Server 2019 платформа x64.
Предварительная настройка
-------------------------
* Установим pip;
* Установим pywinrm;
* Установим ansible;
Package Installer for Python (pip) — система управления пакетами в Unix\Linux системами. Установим данный пакет следующей командой:
```
sudo apt-get install python-pip python-dev build-essential
```
Модуль `pywinrm` нужен для того, чтобы взаимодействовать с WinRM. Используем команду:
```
sudo pip install pywinrm
```
Ansible установим командой:
```
sudo pip install ansible
```
Настройка playbook
------------------
Для начала нам нужно настроить конфигурационный файл `ansible.cfg`
```
mkdir ~/ansible
cd ~/ansible
```
Создаем папку для хранения логов:
```
mkdir ~/ansible/modules
mkdir ~/ansible/logs
```
Редактируем файл следующим образом:
```
hostfile = ~/ansible/inventory
sudo_user = root
log_path = ~/ansible/logs/ansible.log
```
В host указываем ip адреса подключаемых удаленных компьютеров на базе Windows.
Для экспериментов ранее мы создали пару серверов, которые и будем настраивать:
ip\_первой\_машины
ip\_второй\_машины
Пакет для использования модуля winrm
------------------------------------
Устанавливаем пакет для использования модуля winrm следующими командами:
```
zorchik@srv-bionic:~$ sudo pi install
http://github.com/diyan/pywinrm/archive/master.zip#egg=pywinrm
ekzorchik@srv-bionic:~$ sudo find / -name "winrm"
/usr/local/lib/python3.6/dist-packages/winrm
/usr/local/lib/python2.7/dist-packages/winrm
```
Чтобы подключить Windows делаем команду:
```
PS C:\Windows\system32> set-executionpolicy remotesigned
Execution Policy Change
The execution policy helps protect you from scripts that you do not trust. Changing the execution policy might expose
you to the security risks described in the about_Execution_Policies help topic at
http://go.microsoft.com/fwlink/?LinkID=135170. Do you want to change the execution policy?
[Y] Yes [N] No [S] Suspend [?] Help (default is "Y"): Y
```
После этого нужно запустить скрипт для создания правила в Firewall: Allow 5986/TCP.
Скачиваем и распаковываем скрипт PowerShell [ConfigureRemotingForAnsible](https://www.ekzorchik.ru/2019/05/we-manage-through-ansible-domain-windows-systems/configureremotingforansible/).
```
PS C:\Windows\system32> cd c:\1
PS C:\1> .\ConfigureRemotingForAnsible.ps1
После чего подключаем Ubuntu к Windows
ekzorchik@srv-bionic:~$ sudo mkdir -p /etc/ansible/windows/group_vars
ekzorchik@srv-bionic:~$ sudo nano /etc/ansible/windows/hosts
[windows]
10.90.90.2
ekzorchik@srv-bionic:~$ sudo nano /etc/ansible/windows/group_vars/windows.yml
file: group_vars/windows.yml
ansible_user: ekzorchik@POLYGON.LOCAL
ansible_password: 712mbddr@
ansible_winrm_transport: basic
#Если получила эта системе kerberos билет
#ansible_winrm_transport: kerberos
ansible_connection: winrm
ansible_winrm_server_cert_validation: ignore
validate_certs: false
ekzorchik@srv-bionic:~$ sudo ansible windows -i /etc/ansible/windows/hosts -m win_ping
10.90.90.2 | SUCCESS => {
"changed": false,
"ping": "pong"
}
```
Автоматизированное управление Windows через Ansible
---------------------------------------------------
В качестве управляющего сервером Ansible используем сервер Ubuntu 16.04. **Управляющий сервер** – это место, с которого с помощью Ansible мы будем запускать наши модули, сценарии, задачи и т.п. В нашем стенде это сервер с Ansible Tower. Для использования Ansible и работы с этой системой из командной строки нам просто потребуется установить несколько небольших утилит. Поскольку в нашем случае используется сервер с Tower, то нам не требуется устанавливать Ansible, так как он входит в состав установки Tower. Однако пройдем по всем простым шагам, нужным для установки Ansible
Для этого настроим PIP в Ubuntu. Выполним следующие команды:
```
sudo pip install ansible
```
После этого мы готовы взаимодействовать с сервером Windows.
Настройка WinRM для Ansible
---------------------------
Для конфигурации используем конфигурационный скрипт, который лежит на Githab по ссылке: https://github.com/ansible/ansible/blob/devel/examples/scripts/ConfigureRemotingForAnsible.ps1
Для проверки соединения из Ansible, вы можете использовать команду win\_ping, которая использует соединение с WinRM для подключения к серверу. Она проверяет, все ли в соединении с WinRM работает так, как ожидается.
Создайте файл `inventory.yml`, в котором перечислены хосты, которые вы хотите проверить. Файл `inventory.yml` имеет только один хост для проверки.
Для проверки соединения с хостами, указанными в инвентаризационном файле, используйте приведенную ниже команду, которая выполняет проверку WinRM соединения.
```
Ansible test -i inventory.yml -m win_ping
```
Если вы все верно настроили, то увидите сообщение SUCCESS. Теперь мы можем использовать автоматизацию Ansible для управления Windows Server.
Запуск команд из Ansible на Windows Server
------------------------------------------
Для начала работы мы можем использовать несколько основных команд. Мы можем взаимодействовать с нашим сервером, как если мы работали бы с ним с консоли. Ниже приводится команда для получения IP конфигурации на нашем Windows Server.
```
Ansible test -i inventory.yml -m raw -a "ipconfig"
```
Мы также можем остановить, запустить и перезапустить любые службы:
```
ansible test -m win_service -a "name=Spooler state=stopped"
```
Как научиться писать playbook
Если вы хотите повысить экспертизу и начать писать собственные плейбуки, приходите курс [«Ansible: Infrastructure as Code»](https://slurm.club/3WczAMa), который пройдет **с 23 января по 19 февраля**.
Когда у вас один сервер, им можно управлять вручную: набирать команды, что-то править, настраивать. Если их десять — это всё ещё реально. Но, представим, что у вас сотни серверов, которые разбросаны по разным городам. Тут уже ручным управлением не обойтись. **Ansible – один из самых популярных инструментов управления конфигурациями**.
Курс полезен для администраторов, инженеров и желающих подняться вверх по карьерной лестнице в качестве девопса. Учиться будет интересно не только тем, кто недавно начал свое знакомство с инструментом, но и тем, кто хочет освежить имеющиеся знания и закрепить их на практике и выстроить структуру.
**На курсе вы:**
✅ Узнаете как работать с переменными, как писать плейбуки и роли;
✅ Развернете LEMP стек, PostgreSQL и Mongo кластеры,
✅ Задеплоите Flask приложение;
✅ Напишите свой модуль для Ansible;
✅ Настроите IaC в Gitlab;
✅ Разберетесь с работой с облаками и enterprise решениями.
После обучения вы сможете конфигурировать рутинные задачи с помощью удобного инструмента без страха правок конфигураций. Вы будете понимать, когда и как писать свои модули, а также смело залазить под капот Ansible.
Купите курс до 28 декабря и участвуйте в **розыгрыше сертификата на 500 000Р** на курсы Слёрма.
[**Посмотреть программу курса и записаться.**](https://slurm.club/3WczAMa) | https://habr.com/ru/post/704970/ | null | ru | null |
# 6 самых распространённых ошибок разработчиков при написании HTML и CSS
Привет, Хабр! Представляю вашему вниманию перевод статьи «[The 6 most common mistakes developers when writing HTML and CSS](https://dev.to/melnik909/the-6-most-common-mistakes-developers-when-writing-html-and-css-f92)» автора Stas Melnikov.
### Использование атрибута placeholder вместо элемента label
Часто разработчики используют атрибут placeholder вместо элемента label. Но в этом случае пользователи скринридера (программы чтения с экрана) не могут заполнять поля, потому что скринридер не может прочитать текст из атрибута placeholder.
Поэтому я рекомендую использовать элемент label для поля имени и атрибут placeholder для примера данных, которые пользователь должен заполнить.
```
Enter your email
```
### Использование элемента img для разметки декоративной графики
Я часто вижу, как разработчики путают декоративную графику с изображениями контента. Например, они размечают социальные иконки с помощью элемента img.
```
[
Twitter](https://twitter.com)
```
Но иконка социальной сети — это декоративная иконка, которая помогает пользователям быстрее понять смысл элемента, не читая текст. Если мы удаляем значок, мы не теряем значение элемента, поэтому мы можем использовать для него свойство background-image.
```
[Twitter](https://twitter.com)
```
```
.social::before {
background-image: url("twitter.svg");
}
```
### Использование свойства resize
При отключении изменения размера текстовой области с помощью свойства resize доступность ухудшается. Таким образом, пользователь не может ввести данные удобным для себя способом.
```
textarea {
width: 100%;
height: 200px;
resize: none;
}
```
Вы можете использовать свойства min-width, max-width, min-height и max-height, которые ограничивают размеры элемента, и пользователь может заполнять поля удобным для себя способом.
```
textarea {
min-width: 100%;
max-width: 100%;
min-height: 200px;
max-height: 400px;
}
```
### Использование display: block и position: absolute (fixed) вместе.
Я часто вижу, как разработчики используют свойства display и position следующим образом:
```
.button::before {
content: "";
display: block;
position: absolute;
top: 0;
left: 0;
}
```
Но браузер устанавливает значение блока по умолчанию. Поэтому вам не нужно добавлять это значение для элементов с абсолютным или фиксированным позиционированием. Поэтому следующий код дает те же результаты, что и предыдущий.
```
.button::before {
content: "";
position: absolute;
top: 0;
left: 0;
}
```
### Нет значения для свойства структуры
Я не могу работать с веб-сайтом, используя клавиатуру. Я не могу перейти по ссылке. Я не могу зарегистрироваться. Это происходит потому, что разработчики отключают фокус на элементах, когда они добавляют значение none для свойства outline.
```
.button:focus {
outline: none;
}
/* or */
.button:focus {
outline: 0;
}
```
Если вам нужно отключить фокусировку по умолчанию, не забудьте сделать состояние альтернативной фокусировки.
```
.button:focus {
outline: none;
box-shadow: 0 0 3px 0 blue;
}
```
### Пустые элементы
Часто разработчики используют пустые элементы HTML для оформления элементов. Например, разметка меню-гамбургера с использованием пустых элементов div или span:
```
```
```
.hamburger {
width: 60px;
height: 45px;
position: relative;
}
.hamburger span {
width: 100%;
height: 9px;
background-color: #d3531a;
border-radius: 9px;
position: absolute;
left: 0;
}
.hamburger span:nth-child(1) {
top: 0;
}
.hamburger span:nth-child(2) {
top: 18px;
}
.hamburger span:nth-child(3) {
top: 36px;
}
```
Но вы можете использовать псевдо-элементы :: before и :: after и достичь аналогичных результатов.
```
Open menu
```
```
.hamburger {
width: 60px;
height: 45px;
position: relative;
}
.hamburger::before,
.hamburger::after,
.hamburger__text::before {
content: "";
width: 100%;
height: 9px;
background-color: #d3531a;
border-radius: 9px;
position: absolute;
left: 0;
}
.hamburger::before {
top: 0;
}
.hamburger::after {
top: 18px;
}
.hamburger__text::before {
top: 36px;
}
.visually-hidden {
position: absolute !important;
clip: rect(1px, 1px, 1px, 1px);
width: 1px !important;
height: 1px !important;
overflow: hidden;
}
``` | https://habr.com/ru/post/479762/ | null | ru | null |
# NumPy в Python. Часть 3
Предисловие переводчика
=======================
И снова здравствуйте! Продолжаем наш цикл статей по переводу мана о numpy. Приятного чтения.
* [Часть 1](https://habr.com/post/352678/)
* [Часть 2](https://habr.com/post/353416/)
* [Часть 4](https://habr.com/post/415373/)
* [Оригинал](https://engineering.ucsb.edu/~shell/che210d/numpy.pdf)
Операторы сравнения и тестирование значений
===========================================
Булево сравнение может быть использовано для поэлементного сравнения массивов одинаковых длин. Возвращаемое значение это массив булевых True/False значений:
```
>>> a = np.array([1, 3, 0], float)
>>> b = np.array([0, 3, 2], float)
>>> a > b
array([ True, False, False], dtype=bool)
>>> a == b
array([False, True, False], dtype=bool)
>>> a <= b
array([False, True, True], dtype=bool)
```
Результат сравнения может быть сохранен в массиве:
```
>>> c = a > b
>>> c
array([ True, False, False], dtype=bool)
```
Массивы могут быть сравнены с одиночным значением:
```
>>> a = np.array([1, 3, 0], float)
>>> a > 2
array([False, True, False], dtype=bool)
```
Операторы any и all могут быть использованы для определения истинны ли хотя бы один или все элементы соответственно:
```
>>> c = np.array([ True, False, False], bool)
>>> any(c)
True
>>> all(c)
False
```
Комбинированные булевы выражения могут быть применены к массивам по принципу элемент — элемент используя специальные функции logical\_and, logical\_or и logical\_not:
```
>>> a = np.array([1, 3, 0], float)
>>> np.logical_and(a > 0, a < 3)
array([ True, False, False], dtype=bool)
>>> b = np.array([True, False, True], bool)
>>> np.logical_not(b)
array([False, True, False], dtype=bool)
>>> c = np.array([False, True, False], bool)
>>> np.logical_or(b, c)
array([ True, True, True], dtype=bool)
```
Функция where создает новый массив из двух других массивов одинаковых длин используя булев фильтр для выбора межу двумя элементами. Базовый синтаксис: where(boolarray,
truearray, falsearray):
```
>>> a = np.array([1, 3, 0], float)
>>> np.where(a != 0, 1 / a, a)
array([ 1. , 0.33333333, 0. ])
```
С функцией where так же может быть реализовано «массовое сравнение»:
```
>>> np.where(a > 0, 3, 2)
array([3, 3, 2])
```
Некоторые функции дают возможность тестировать значения в массиве. Функция nonzero возвращает кортеж индексов ненулевых значений. Количество элементов в кортеже равно количеству осей в массиве:
```
>>> a = np.array([[0, 1], [3, 0]], float)
>>> a.nonzero()
(array([0, 1]), array([1, 0]))
```
Также можно проверить значения на конечность и NaN(not a number):
```
>>> a = np.array([1, np.NaN, np.Inf], float)
>>> a
array([ 1., NaN, Inf])
>>> np.isnan(a)
array([False, True, False], dtype=bool)
>>> np.isfinite(a)
array([ True, False, False], dtype=bool)
```
Хотя здесь мы использовали константы numpy чтобы добавить значения NaN и бесконечность, они могут быть результатами применения стандартных математических операций.
Выбор элементов массива и манипуляция с ними
============================================
Мы уже видели, как и у списков, элементы массива можно получить используя операцию доступа по индексу. Однако, в отличии от списков, массивы также позволяют делать выбор элементов используя другие массивы. Это значит, что мы можем использовать массив для фильтрации специфических подмножеств элементов других массивов.
Булевы массивы могут быть использованы как массивы для фильтрации:
```
>>> a = np.array([[6, 4], [5, 9]], float)
>>> a >= 6
array([[ True, False],
[False, True]], dtype=bool)
>>> a[a >= 6]
array([ 6., 9.])
```
Стоит заметить, что когда мы передаем булев массив a>=6 как индекс для операции доступа по индексу массива a, возвращаемый массив будет хранить только True значения. Также мы можем записать массив для фильтрации в переменную:
```
>>> a = np.array([[6, 4], [5, 9]], float)
>>> sel = (a >= 6)
>>> a[sel]
array([ 6., 9.])
```
Более замысловатая фильтрация может быть достигнута использованием булевых выражений:
```
>>> a[np.logical_and(a > 5, a < 9)]
>>> array([ 6.])
```
В придачу к булеву выбору, также можно использовать целочисленные массивы. В этом случае, целочисленный массив хранит индексы элементов, которые будут взяты из массива. Рассмотрим следующий одномерный пример:
```
>>> a = np.array([2, 4, 6, 8], float)
>>> b = np.array([0, 0, 1, 3, 2, 1], int)
>>> a[b]
array([ 2., 2., 4., 8., 6., 4.])
```
Иными словами, когда мы используем b для получения элементов из a, мы берем 0-й, 0-й, 1-й, 3-й, 2-й и 1-й элементы a в этом порядке. Списки также могут быть использованы как массивы для фильтрации:
```
>>> a = np.array([2, 4, 6, 8], float)
>>> a[[0, 0, 1, 3, 2, 1]]
array([ 2., 2., 4., 8., 6., 4.])
```
Для многомерных массивов, нам необходимо передать несколько одномерных целочисленных массивов в оператор доступа индексу (*Прим. переводчика: в нашем случае индексы это массивы*) для каждой оси. Потом каждый из массивов проходит такую последовательность: первый элемент соответствует индексу строки, который является первым элементом массива b, второй элемент соответствует индексу столбца, который является первым элементом массива c и так далее. (*Прим. переводчика: первый массив [2, 2] и второй [1, 4], имеем на выходе элементы с индексами [2, 1] и [2, 4]*) Пример:
```
>>> a = np.array([[1, 4], [9, 16]], float)
>>> b = np.array([0, 0, 1, 1, 0], int)
>>> c = np.array([0, 1, 1, 1, 1], int)
>>> a[b,c]
array([ 1., 4., 16., 16., 4.])
```
Специальная функция take доступна для выполнения выборки с целочисленными массивами. Это работает также как и использования оператора взятия по индексу:
```
>>> a = np.array([2, 4, 6, 8], float)
>>> b = np.array([0, 0, 1, 3, 2, 1], int)
>>> a.take(b)
array([ 2., 2., 4., 8., 6., 4.])
```
Функция take также предоставляет аргумент axis (ось) для взятия подсекции многомерного массива вдоль какой-либо оси. (*Прим. переводчика: по строкам или столбцам (для двумерных массивов)*).
```
>>> a = np.array([[0, 1], [2, 3]], float)
>>> b = np.array([0, 0, 1], int)
>>> a.take(b, axis=0)
array([[ 0., 1.],
[ 0., 1.],
[ 2., 3.]])
>>> a.take(b, axis=1)
array([[ 0., 0., 1.],
[ 2., 2., 3.]])
```
В противоположность к функции take есть функция put, которая будет брать значения из исходного массива и записывать их на специфические индексы в другом put-массиве.
```
>>> a = np.array([0, 1, 2, 3, 4, 5], float)
>>> b = np.array([9, 8, 7], float)
>>> a.put([0, 3], b)
>>> a
array([ 9., 1., 2., 8., 4., 5.])
```
Заметим, что значение 7 из исходного массива b не было использовано, так как только 2 индекса [0, 3] указаны. Исходный массив будет повторен если необходимо в случае не соответствия длин:
```
>>> a = np.array([0, 1, 2, 3, 4, 5], float)
>>> a.put([0, 3], 5)
>>> a
array([ 5., 1., 2., 5., 4., 5.])
```
Векторная и матричная математика
================================
NumPy обеспечивает много функций для работы с векторами и матрицами. Функция dot возвращает скалярное произведение векторов:
```
>>> a = np.array([1, 2, 3], float)
>>> b = np.array([0, 1, 1], float)
>>> np.dot(a, b)
5.0
```
Функция dot также может умножать матрицы:
```
>>> a = np.array([[0, 1], [2, 3]], float)
>>> b = np.array([2, 3], float)
>>> c = np.array([[1, 1], [4, 0]], float)
>>> a
array([[ 0., 1.],
[ 2., 3.]])
>>> np.dot(b, a)
array([ 6., 11.])
>>> np.dot(a, b)
array([ 3., 13.])
>>> np.dot(a, c)
array([[ 4., 0.],
[ 14., 2.]])
>>> np.dot(c, a)
array([[ 2., 4.],
[ 0., 4.]])
```
Также можно получить скалярное, тензорное и внешнее произведение матриц и векторов. Заметим, что для векторов внутреннее и скалярное произведение совпадает.
```
>>> a = np.array([1, 4, 0], float)
>>> b = np.array([2, 2, 1], float)
>>> np.outer(a, b)
array([[ 2., 2., 1.],
[ 8., 8., 4.],
[ 0., 0., 0.]])
>>> np.inner(a, b)
10.0
>>> np.cross(a, b)
array([ 4., -1., -6.])
```
NumPy также предоставляет набор встроенных функций и методов для работы с линейной алгеброй. Это всё можно найти в под-модуле linalg. Этими модулями также можно оперировать с вырожденными и невырожденными матрицами. Определитель матрицы ищется таким образом:
```
>>> a = np.array([[4, 2, 0], [9, 3, 7], [1, 2, 1]], float)
>>> a
array([[ 4., 2., 0.],
[ 9., 3., 7.],
[ 1., 2., 1.]])
>>> np.linalg.det(a)
-48.
```
Также можно найти собственный вектор и собственное значение матрицы:
```
>>> vals, vecs = np.linalg.eig(a)
>>> vals
array([ 9. , 2.44948974, -2.44948974])
>>> vecs
array([[-0.3538921 , -0.56786837, 0.27843404],
[-0.88473024, 0.44024287, -0.89787873],
[-0.30333608, 0.69549388, 0.34101066]])
```
Невырожденная матрица может быть найдена так:
```
>>> b = np.linalg.inv(a)
>>> b
array([[ 0.14814815, 0.07407407, -0.25925926],
[ 0.2037037 , -0.14814815, 0.51851852],
[-0.27777778, 0.11111111, 0.11111111]])
>>> np.dot(a, b)
array([[ 1.00000000e+00, 5.55111512e-17, 2.22044605e-16],
[ 0.00000000e+00, 1.00000000e+00, 5.55111512e-16],
[ 1.11022302e-16, 0.00000000e+00, 1.00000000e+00]])
```
Одиночное разложение (аналог диагонализации не квадратной матрицы) может быть достигнут так:
```
>>> a = np.array([[1, 3,4], [5, 2, 3]], float)
>>> U, s, Vh = np.linalg.svd(a)
>>> U
array([[-0.6113829 , -0.79133492],
[-0.79133492, 0.6113829 ]])
>>> s
array([ 7.46791327, 2.86884495])
>>> Vh
array([[-0.61169129, -0.45753324, -0.64536587],
[ 0.78971838, -0.40129005, -0.46401635],
[-0.046676 , -0.79349205, 0.60678804]])
```
Заканчиваем третью часть. Удачи и до скорого! | https://habr.com/ru/post/413381/ | null | ru | null |
# Сказ о полукольцах
Привет, Хабр! Предлагаю вашему вниманию перевод статьи ["A tale on Semirings"](https://typelevel.org/blog/2018/11/02/semirings.html) автора Luka Jacobowitz.
Когда-нибудь задумывались, почему сумма типов называется суммой типов. Или, может, вы всегда хотели узнать, почему оператор `<*>` записывается именно так? И что это имеет общего с полукольцами? Заинтересовавшихся прошу под кат!
*Данная статья является переводом [поста в блоге компании Typelevel](https://typelevel.org/blog/2018/11/02/semirings.html) под авторством Луки Якобовича. Для наилучшего ее восприятия требуется хотя бы поверхностное знакомство с языком Scala и его экосистемой (в том числе, библиотекой cats) и знание базовых понятий абстрактной алгебры: полугруппа, моноид и т.д.*
### Алгебраические структуры
Многие из нас знают о моноидах и полугруппах и даже пользуются ими. Эти структуры обладают свойствами, которые позволяют применять их напрямую для получения более высокого уровня абстракции (если вы о них не знаете, можете прочитать в [документации библиотеки *сats*](https://typelevel.org/cats/typeclasses/semigroup.html)). Тем не менее, иногда тип данных обладает более чем одним моноидом или полугруппой. Очевидным примером являются различные численные типы, где умножение и сложение образуют два полноценных моноида.
В абстрактной алгебре существует отдельный класс структур с двумя моноидами, взаимодействующими определенным образом. Этот класс полуколец. Поскольку моноиды часто используются для описания численных типов, их обычно разделяют на мультипликативный и аддитивный. Как и в случае с числами, законы полукольца определяют, что умножение дистрибутивно по сложению, а умножение любого числа на единицу по сложению — ноль — дает ноль.
Существуют различные способы представить это в виде *классов типов* и разные библиотеки делают это по-своему, но давайте рассмотрим как это сделано в проекте [алгебра](https://typelevel.org/algebra/). Базой в ней являются `AdditiveSemigroup` и `MultiplicativeSemigroup`.
[*Примечание: поскольку название "класс типов" не особо прижилось в русском языке, далее будет использоваться его английский вариант — type class*]
```
import simulacrum._
@typeclass trait AdditiveSemigroup[A] {
def +(x: A)(y: A): A
}
@typeclass trait AdditiveMonoid[A] extends AdditiveSemigroup[A] {
def zero: A
}
@typeclass trait MultiplicativeSemigroup[A] {
def *(x: A)(y: A): A
}
@typeclass trait MultiplicativeMonoid[A] extends MultiplicativeSemigroup[A] {
def one: A
}
```
[*Примечание: Аннотация @typeclass из проекта simulacrum позволяет автоматически генерировать часто-используемые методы для type class-ов и не влияет на логическую составляющую кода*]
В таком случае, полукольцо (`Semiring`) — это аддитивный моноид (`AdditiveMonoid`), объединенный с мультипликативным моноидом (`MultiplicativeMonoid`) и снабженный следующими дополнительными законами:
1. Коммутативность по сложению: 
2. Дистрибутивность справа: 
3. Дистрибутивность слева: 
4. Наличие нуля справа: 
5. Наличие нуля слева: 
Чтобы задать соответствующий полукольцу type class, объединим `AdditiveMonoid` и `MultiplicativeMonoid`:
```
@typeclass trait Semiring[A] extends MultiplicativeMonoid[A] with AdditiveMonoid[A]
```
Теперь, когда у нас есть `Semiring`, мы можем использовать его с различными численными типами: `Int`, `Long`, `BigDecimal` и т.д., но разве это стоит целой статьи о полукольцах? Оказывается, множество других вещей также являются полукольцами, включая логические значения, множества и даже [анимации](https://bkase.github.io/slides/algebra-driven-design).
Хотелось бы отметить, что можно сформировать полукольцевой гомоморфизм из множества типов в общее число возможных представителей этих типов. Что это значит? Что ж, наберитесь терпения, а я постараюсь объяснить, что я имею в виду.
### Кардинальные числа
Давайте начнем с того, что вообще подразумевается под кардинальным числом. Каждому типу соответствует число значений, которые представители этого типа могут принимать. Например, тип `Boolean` обладает кардинальным числом , потому что у него всего два возможных значения: `true` и `false`.
Итак, у `Boolean` — , а сколько у других типов? У `Byte` — , у `Short` — , у `Int` — , а у `Long` — . А что насчет строк? `String` — формально неограниченный тип и теоретически обладает бесконечным числом значений (на практике, естественно, мы не обладаем бесконечной памятью, поэтому конкретное число будет зависеть от конфигурации компьютера).
Для каких еще типов мы можем определить их кардинальное число? Два довольно простых примера: `Unit`, у которого ровно один представитель, и `Nothing`, который является нижней границей всех возможных типов в Scala и соответственно имеет  возможных значений. То есть, вы никогда не сможете создать значение `Nothing`, что соответствует кардинальному числу .
Отлично, теперь можно попробовать выразить это в коде. Мы можем создать type class, способный дать нам общее число значений соответствующего типа.
```
trait Cardinality[A] {
def cardinality: BigInt
}
object Cardinality {
def of[A: Cardinality]: BigInt = apply[A].cardinality
def apply[A: Cardinality]: Cardinality[A] = implicitly
}
```
Теперь попробуем создать несколько экземпляров этого класса:
```
implicit def booleanCardinality = new Cardinality[Boolean] {
def cardinality: BigInt = BigInt(2)
}
implicit def longCardinality = new Cardinality[Long] {
def cardinality: BigInt = BigInt(2).pow(64)
}
implicit def intCardinality = new Cardinality[Int] {
def cardinality: BigInt = BigInt(2).pow(32)
}
implicit def shortCardinality = new Cardinality[Short] {
def cardinality: BigInt = BigInt(2).pow(16)
}
implicit def byteCardinality = new Cardinality[Byte] {
def cardinality: BigInt = BigInt(2).pow(8)
}
implicit def unitCardinality = new Cardinality[Unit] {
def cardinality: BigInt = 1
}
implicit def nothingCardinality = new Cardinality[Nothing] {
def cardinality: BigInt = 0
}
```
[*Примечание: приведенные значения могут быть также объявлены как `implicit val`*]
Давайте опробуем их в REPL:
```
scala> Cardinality.of[Int]
res11: BigInt = 4294967296
scala> Cardinality.of[Unit]
res12: BigInt = 1
scala> Cardinality.of[Long]
res13: BigInt = 18446744073709551616
```
Здорово, но все это очень просто, что насчет ADT? Можем ли мы обрабатывать их подобным образом? Оказывается, можем, нужно лишь понять, как обращаться с простейшими суммами и произведениями типов. Для начала, рассмотрим простейшее произведение типов: `(Boolean, Byte)`
Как много представителей у этого типа? Мы знаем, что у `Boolean` их , а у `Byte` — . Таким образом, получаются числа от  до  объединенные с `true` или `false`. Получается  уникальных значений.
 выглядит как , умноженное на , так что, возможно, нужно просто умножить число значений первого типа на число значений второго? Если вы проверите это с остальными примерами, то убедитесь, что это действительно так. Давайте представим это в виде экземпляра type class’а:
```
implicit def tupleCardinality[A: Cardinality, B: Cardinality] =
new Cardinality[(A, B)] {
def cardinality: BigInt = Cardinality[A].cardinality * Cardinality[B].cardinality
}
```
Теперь рассмотрим пример суммы типов: `Either[Boolean, Byte]`. В этом случае ответ еще более очевиден, поскольку значением этого типа (по сути) может быть либо `Boolean`, либо `Byte`, так что достаточно просто сложить кардинальные числа. Таким образом, у `Either[Boolean, Byte`] должно быть  представителей.
Давайте аналогичным образом выразим это в коде и подтвердим результаты в REPL:
```
implicit def eitherCardinality[A: Cardinality, B: Cardinality] =
new Cardinality[Either[A, B]] {
def cardinality: BigInt = Cardinality[A].cardinality + Cardinality[B].cardinality
}
scala> Cardinality.of[(Boolean, Byte)]
res14: BigInt = 512
scala> Cardinality.of[Either[Boolean, Byte]]
res15: BigInt = 258
scala> Cardinality.of[Either[Int, (Boolean, Unit)]]
res16: BigInt = 4294967298
```
Следовательно, для суммы типов кардинальные числа складываются, а для произведения — перемножаются. Это логично, учитывая их названия.
Так что насчет того гомоморфизма, о котором шла речь ранее? Гомоморфизм — это сохраняющее структуру отображение между двумя алгебраическими структурами одного типа (в данном случае, полукольцами).
Это означает, что для любых ,  и гомоморфизма  мы имеем:
1. 
2. 
Последние выражения могут показаться достаточно абстрактными, но они имеют непосредственное отношение к тому, что мы только что сделали. Если мы “сложим” два типа `Byte` и `Boolean`, то получим `Either[Byte, Boolean]`, и если мы применим к нему гомоморфизм `cardinality`, то получим . Это равносильно применению `cardinality` к `Byte` и к `Boolean` отдельно с последующим сложением результатов.
Конечно, то же самое применимо к умножению и произведению типов. Тем не менее, нам не хватает еще кое-чего для корректного полукольца, поскольку мы упомянули только сложение и умножение, но не соответствующие единичные элементы.
Как мы уже видели, у типа `Unit` — один представитель, а у типа `Nothing` — ни одного. Можем ли мы использовать эти два типа, чтобы образовать полукольцо?
Давайте попробуем! Если `Unit` — единица по умножению, то произведение любого типа с `Unit` должно быть эквивалентно первому типу. Естественно, это выполняется, поскольку мы легко можем отобразить что-нибудь из разряда `(Int, Unit)` в `Int` и обратно без потерь, так что и кардинальное число остается без изменения.
```
scala> Cardinality.of[Int]
res17: BigInt = 4294967296
scala> Cardinality.of[(Unit, Int)]
res18: BigInt = 4294967296
scala> Cardinality.of[(Unit, (Unit, Int))]
res19: BigInt = 4294967296
```
А что насчет `Nothing`? Поскольку это единица по сложению, сумма любого типа с `Nothing` должна быть эквивалентна этому же типу. Совпадает ли `Either[Nothing, A]` с `A`? Да! Поскольку у `Nothing` нет ни одного значения, то `Either[Nothing, A]` может быть только `Right` и, как следствие, только `A`, так что эти типы эквивалентны.
Нам также необходимо проверить корректность нуля по умножению: любое число, умноженное на единицу по сложению `zero`, должно совпадать с `zero`. Поскольку `Nothing` является нашей единицей по сложению, такое произведение типов как `(Int, Nothing)` должно быть эквивалентно `Nothing`. Это выполняется, поскольку мы не можем создать значение типа `Nothing` и, как следствие, содержащий такое значение кортеж.
Проверим, как это соотносится с кардинальными числами.
Единица по сложению:
```
scala> Cardinality.of[Either[Nothing, Boolean]]
res0: BigInt = 2
scala> Cardinality.of[Either[Nothing, (Byte, Boolean)]]
res1: BigInt = 258
```
Поглощение нулем:
```
scala> Cardinality.of[(Nothing, Boolean)]
res0: BigInt = 0
scala> Cardinality.of[(Nothing, Long)]
res1: BigInt = 0
```
Осталось проверить дистрибутивность. В контексте типов это означает, что `(A, Either[B, C])` должно совпадать с `Either[(A, B), (A, C)]`. Если проверить, то эти два типа действительно окажутся эквивалентными.
```
scala> Cardinality.of[(Boolean, Either[Byte, Short])]
res20: BigInt = 131584
scala> Cardinality.of[Either[(Boolean, Byte), (Boolean, Short)]]
res21: BigInt = 131584
```
### Алгебраические структуры высшего порядка
Некоторые возможно уже слышали о type class-е `Semigroupal`. Но почему он так называется и как соотносится с `Semigroup`? Для начала, давайте посмотрим на сам `Semigroupal`:
```
@typeclass trait Semigroupal[F[_]] {
def product[A, B](fa: F[A], fb: F[B]): F[(A, B)]
}
```
Есть определенная схожесть с `Semigroup`: комбинируются два значения, причем соответствующая операция должна быть ассоциативна (аналогично `Semigroup`).
Пока все в порядке, но имя функции `product` немного смущает. Оно логично, поскольку мы объединяем `A` и `B` в кортеж, который является произведением типов, но если мы используем произведение, возможно, это не произвольный `Semigroupal`, а мультипликативный? Давайте его переименуем.
```
@typeclass trait MultiplicativeSemigroupal[F[_]] {
def product[A, B](fa: F[A], fb: F[B]): F[(A, B)]
}
```
Теперь рассмотрим, как мог бы выглядеть `Semigroupal` по сложению. Естественно, все, что мы должны поменять, это произведение типов на сумму:
```
@typeclass trait AdditiveSemigroupal[F[_]] {
def sum[A, B](fa: F[A], fb: F[B]): F[Either[A, B]]
}
```
Выглядит неплохо — можем ли мы добавить единицы, чтобы получить `Monoidal`? Конечно можем! Это будут опять `Nothing` и `Unit` для суммы и произведения соответственно:
```
@typeclass trait AdditiveMonoidal[F[_]] extends AdditiveSemigroupal[F] {
def nothing: F[Nothing]
}
@typeclass trait MultiplicativeMonoidal[F[_]] extends MultiplicativeSemigroupal[F] {
def unit: F[Unit]
}
```
Теперь у нас есть эти type class-ы, но как мы можем их использовать? Что ж, с уверенностью заявляю, что они уже используются в библиотеке *cats*, но под другими именами.
Что вообще может быть похоже на эти классы? Для начала, взглянем на функцию `sum` и попробуем найти что-то похожее на `AdditiveSemigroupal`. Поскольку у аналогов этих классов для типов низшего порядка есть соответствующие символьные операторы, давайте добавим такой оператор и в `AdditiveSemigroupal`.
Так как речь идет о сумме, этот оператор скорее всего должен содержать `+` и показывать, что операция выполняется в каком-то контексте. Идеальным было бы использование чего-то вроде `[+]`, но это некорректный идентификатор, так что попробуем `<+>` вместо него.
```
def <+>[A, B](fa: F[A], fb: F[B]): F[Either[A, B]]
```
Функция `<+>` уже существует в *cats* в качестве псевдонима для `combineK`, который можно найти в `SemigroupK`, но он ведет себя по-другому. Он принимает на вход два `F[A]` и возвращает `F[A]` — не совсем похоже на то, что мы имеем.
Или похоже? На самом деле, эти две функции совпадают и мы можем определить одну через другую при наличии функтора:
```
def sum[A, B](fa: F[A], fb: F[B]): F[Either[A, B]]
def combineK[A](x: F[A], y: F[A]): F[A] = {
val feaa: F[Either[A, A]] = sum(x, y)
feaa.map(_.merge)
}
```
Поскольку `AdditiveSemigroupal` эквивалентен `SemigroupK`, возможно, `AdditiveMonoidal` совпадает с `MonoidK`? Да, и это показать это достаточно легко. `MonoidK` дополнен функцией `empty`:
```
def empty[A]: F[A]
```
Эта функция использует универсальный квантор для `A`, то есть, работает для любого `A`, что означает, что на самом деле она не может оперировать никаким конкретным `A` и тем самым эквивалентна `F[Nothing]` в `AdditiveMonoidal`.
Что ж, мы нашли аналоги для аддитивных классов и уже знаем, что `MultiplicativeSemigroupal` эквивалентен `cats.Semigroupal`. Все, что нам осталось, это найти эквивалент `MultiplicativeMonoidal`.
Я немного сжульничаю и скажу, что этим эквивалентом является `Applicative`. Он добавляет функцию `pure`, которая принимает `A` и возвращает `F[A]`. `MultiplicativeMonoidal` в свою очередь обладает функцией `unit`, не принимающей параметров и возвращающей `F[Unit]`. Как перейти от одного к другому? Ответ опять подразумевает использование функтора:
```
def unit: F[Unit]
def pure(a: A): F[A] = unit.map(_ => a)
```
`Applicative` использует ковариантный функтор, но в общем случае мы можем использовать также инвариантные и контравариантные структуры. В дополнение к этому `Applicative` включает в себя `<*>` в качестве псевдонима для комбинации `product` и `map`, что выглядит как еще одна подсказка, что это мультипликативный класс и интуиция нас не подвела.
Теперь в *cats* у нас есть `<+>` и `<*>`, но существует ли type class, объединяющий их, аналогично как `Semiring` объединяет `+` и `*`? Есть, и он называется `Alternative`. Он наследуется от `Applicative` и `MonoidK`. Чтобы быть последовательными, мы назовем его `Semiringal`:
```
@typeclass
trait Semiringal[F[_]] extends MultiplicativeMonoidal[F] with AdditiveMonoidal[F]
```
Отлично, теперь у нас есть и `Semiring`, и его аналог для типов высшего порядка. К сожалению, первого в *cats* нет, но, возможно, он появится в будущих версиях.
Если бы он был доступен, мы могли бы вывести `Semiring` для любого `Alternative` аналогично выведению `Monoid` для `MonoidK` или `Applicative`. Также, мы могли бы превратить `Semiring` обратно в `Alternative`, используя `Const`, аналогично превращению `Monoid` в `Applicative`.
В завершение, посмотрим, как можно записать данное преобразование:
```
import Semiring.ops._
case class Const[A, B](getConst: A)
implicit def constSemiringal[A: Semiring] = new Semiringal[Const[A, ?]] {
def sum[B, C](fa: Const[A, B], fb: Const[A, C]): Const[A, Either[B, C]] =
Const(fa.getConst + fb.getConst)
def product[B, C](fa: Const[A, B], fb: Const[A, C]): Const[A, (B, C)] =
Const(fa.getConst * fb.getConst)
def unit: Const[A, Unit] =
Const(Semiring[A].one)
def nothing: Const[A, Nothing] =
Const(Semiring[A].zero)
}
```
### Заключение
Кольца и полукольца представляют собой весьма интересные алгебраические структуры, и, даже если вы не задумывались об этом, скорее всего вы уже ими пользовались. Этот пост был написан, чтобы показать как `Applicative` и `MonoidK` соотносятся с `Monoid`, почему алгебраические типы данных образуют полукольцо и как эти алгебраические структуры распространились в Scala и других языках программирования. Лично для меня осознание того, как все это взаимосвязано и образует очень занятную симметрию, было просто взрывом мозга, и я надеюсь, что этот пост сможет помочь найти аналогичные интересные параллели в `Cats` и других библиотеках, основанных на различных математических абстракциях. Дальнейший материал по этой теме вы сможете найти [здесь](https://www.youtube.com/watch?v=YScIPA8RbVE).
### Дополнение
В этом посте я умолчал о коммутативности в записи type class-ов. Коммутативность — очень важное свойство для полуколец и код должен отражать это свойство. Тем не менее, поскольку пост уже содержит множество определений, дополнение его еще несколькими коммутативными type class-ами, которые не делают ничего, кроме внесения новых законов, выглядело излишним и отвлекающим от основной цели поста.
Более того, я фокусировался на кардинальных числах только тех классов, которые были нам нужны, но для полноты можно добавить определения `Cardinality` для таких вещей как `A => B`, `Option[A]`, `Ior[A, B]`:
1. ```
Cardinality.of[A => B] === Cardinality.of[B].pow(Cardinality.of[A])
```
2. ```
Cardinality.of[Option[A]] === Cardinality.of[A] + 1
```
3. ```
Cardinality.of[Ior[A, B]] === Cardinality.of[A] + Cardinality.of[B] + Cardinality.of[A] * Cardinality.of[B]
``` | https://habr.com/ru/post/446082/ | null | ru | null |
# Создание аналога посмертного сore dump для микроконтроллера
При разработке программного обеспечения любого класса и назначения, зачастую приходится заниматься поиском ошибок, которые привели к краху всего приложения. И если в случае обычного компьютера, анализ логов и core dump`ов как правило не вызывает сложностей, то для устройств на основе микроконтроллеров бывает сложно получить «посмертную» информацию, необходимую для изучения проблемы.
Конечно, при подключенном программаторе и при постоянном выводе логов в какой нибудь отладочный порт можно достаточно комфортно вести отладку, но что делать, когда требуется искать причину сбоев устройства во время штатной эксплуатации устройства, когда инструментальные средства для отладки не подключены и нет внешней памяти для хранения логов?
В продолжение серии статей про различные полезности для STM32 ([1](https://habr.com/ru/company/timeweb/blog/547106/) и [2](https://habr.com/ru/company/timeweb/blog/546670/)), предлагаю вашему вниманию решение для сохранения посмертной информации микроконтроллера при возникновении различных критических ситуаций с целью последующего анализа ошибки.
Ну и в соответствии с собственным наблюдением [Хабр — ума палата](https://habr.com/ru/post/539674/), буду рад любым комментариям и предложениям, которые помогут протестировать или улучшить предлагаемое решение.
Исходные данные и ограничения реализации
----------------------------------------
* Фрагменты кода в статье приведены для микроконтроллеров серий STM32F10xx, STM32F20xx и STM32F40xx, хотя адаптировать данный способ можно наверно для любых серий микроконтроллеров.
* Сохранение посмертного дампа или просто дампа (буду называть его так), интегрировано со сторожевым таймером. Другими словами, при срабатывании сторожевого таймера в посмертном дампе сохраняется информация, предшествующая непосредственной перезагрузке устройства.
* Сохранение дампа происходит в программную флеш память, так как не во всех устройствах могут быть внешние микросхемы флеш памяти или MicroSD карты, а хотелось сделать именно универсальное решение.
* В качестве посмертного дампа используется не состояние регистров и стека, а текстовый буфер логов, предшествующих сбою. Данная информация является универсальной для любых типов устройств и не зависит от типа микроконтроллера, количества тредов в приложении и т.п.
* Из-за ограниченных ресурсов, сохраняется только один последний дамп. И хотя при большом желании можно реализовать сохранение нескольких дампов (в том числе и с состоянием стека и регистров), мне кажется это излишним. Гораздо проще сделать индикацию/мониторинг самого факта наличия посмертного дампа и сразу его анализировать в случае сбоя.
Сторожевой таймер
-----------------
Основная сложность с реализацией сохранения информации о креше микроконтроллера возникла при срабатывании сторожевого таймера.
С одной стороны, при возникновении нештатной ситуации, информацию об этом следует сохранить, с другой, сторожевой таймер достаточно примитивен, и далеко не каждый тип микроконтроллера умеет генерировать прерывание, чтобы была возможность сохранить дамп перед перезагрузкой для последующего анализа.
По этому реализация сторожевого таймера состоит из двух частей:
Первая часть, это обычный таймер, в обработчике которого располагается процедура сохранения посмертного дампа, а после его сохранения происходит обычная программная перезагрузка микроконтроллера.
И вторая часть, непосредственно сам сторожевой таймер, время срабатывания которого настраивается чуть больше, чем у предыдущего.
Таким образом, при включении питания и старте прошивки, остается только проверить тип выполненной перезагрузки. Если перезагрузка была произведена штатным (программным) способ, то ничего не делаем (это означает, что если посмертный дамп перед этим и требовалось сохранить, то это уже было сделано перед перезагрузкой).
А если стоит признак перезагрузки по сторожевому таймеру, значит по какой то причине не отработала процедура рестарта обычного таймера, о чем следует создать записать в журнале логов. А возможно и сохранить сам журнал как посмертный дамп для последующих разбирательств.
Конкретный код настройки таймеров не привожу, т.к. он будет зависеть от тактовой частоты, установленных делителей и т.д. Самое главное, не забыть прописать в обработчике прерываний что-то вроде этого (например, для первого таймера):
```
/* USER CODE BEGIN Callback 1 */
if (htim->Instance == TIM1) {
LOG_FAULT("Writing CRASH DUMP on WDT!");
stm32_save_dump_and_restart();
}
/* USER CODE END Callback 1 */
```
Сохранение дампа
----------------
Наверно понятно, что для записи дампа в память и выполнения последующей перезагрузки, используется функция *stm32\_save\_dump\_and\_restart()*. Её вызов нужно вставить везде, где требуется сохранять состояние, приведшее к возникновению ошибки и перезагрузить микроконтроллер.
Для себя я решил, что буду таким образом анализировать возникновение любых исключений, ошибок при выделения памяти или инициализации стека, при контроле таймаута блокировок на dead lock, а так же срабатывание любого ASSERT`а или выявление перезагрузки по настоящему сторожевому таймеру.
Для последнего случая реализована отдельная функция, которая однократно запускается при старте прошивки. В ней происходит проверка причины перезагрузки и в случае установленного флага перезагрузки по сторожевому таймеру, т.е. когда программная перезагрузка не отработала, делается соответствующий дамп.
Примерно так:
```
void stm32_check_wdt_status() {
if (__HAL_RCC_GET_FLAG(RCC_FLAG_IWDGRST)
&& __HAL_RCC_GET_FLAG(RCC_FLAG_PORRST)) {
LOG_FAULT("Start after IWDGRST. Timer WDG did not work!");
stm32_save_dump_and_restart();
}
}
```
#### Очень важный момент!
Так как ресурс программной флеш памяти довольно ограничен, то обязательно следует предусмотреть защиту от её постоянной перезаписи. Для этого служит проверка бита холодного старта \_\_HAL\_RCC\_GET\_FLAG(RCC\_FLAG\_PORRST).
Другими словами, после подачи напряжения питания дамп может быть записан только однократно. Для разбора ошибок это не принципиально, т.к. дамп все равно будет записан, но это предотвратит флеш память от исчерпания ресурса в случае постоянного циклического сбоя ПО.
Нужно помнить про эту особенность, чтобы во время отладки не забывать снимать напряжение питания с микроконтроллера (или отключать программатор), для установки флага RCC\_FLAG\_PORRST, если при отладке требуется сохранять информацию о креше.
**Инициализация и обновление самих таймеров тривиальна:**
```
void stm32_wdt_init() {
__HAL_TIM_CLEAR_FLAG(&htim1, TIM_SR_UIF);
__HAL_TIM_CLEAR_IT(&htim1, TIM_IT_UPDATE);
HAL_TIM_Base_Start_IT(&htim1);
__HAL_TIM_SetCounter(&htim1, 0);
__HAL_IWDG_START(&hiwdg);
}
void stm32_wdt_refresh() {
__HAL_TIM_SetCounter(&htim1, 0);
HAL_IWDG_Refresh(&hiwdg);
}
```
**Как и сама процедура сохранения дампа с последующей перезагрузкой:**
```
void stm32_save_dump_and_restart() {
stm32_wdt_refresh(); // Не перезагружаться по WDT
if (__HAL_RCC_GET_FLAG(RCC_FLAG_PORRST)) {
// Если записываем дамп, то очищаем флаги
// Запись дампа может быть после физического выключения питания только однократно!!!!!
__HAL_RCC_CLEAR_RESET_FLAGS();
uint8_t *ptr;
size_t size;
utils::Logger::Instance()->GetPointerToDump(ptr, size);
BoardModbus::stm32_flash_erase(&dump_section[2][0]);
size &= (~1); // Размер блока должен быть кратен 2
size = std::min(size, static_cast(FLASH\_PAGE\_SIZE));
stm32\_flash\_write((uint8\_t\*) &dump\_section[2][0], ptr, size);
}
HAL\_NVIC\_SystemReset();
}
```
Куда сохраняем?
---------------
В изначальной реализации данного функционала, я сохранял дамп в последний сектор флеш памяти программ, в расчете на то, что она будет заполнена не полностью и оставшийся хвост можно безопасно использовать для хранения дампов.
И для младшей серии микроконтроллеров (STM32F10xx) с этим не возникало никаких проблем, т.к. все сектора были одного размера. А вот в старших сериях, начиная уже с STM32F20xx, сектора программной памяти имеют переменный размер, который увеличивается для более старших секторов.
И если с резервированием 2к под нужды посмертного дампа не возникает никаких сложностей и моральных мук, то резервировать 128к тогда как из них будет реально использоваться всего несколько процентов, меня реально душила жаба.
> В действительности, из-за особенностей защиты от записи программной флеш памяти, приходится резервировать не один сектор, а сразу три, поэтому в действительности не рациональное использование памяти получается еще более расточительным.
А так как хотелось именно универсального решения, то пришлось залезать в дебри линковщика и резервировать место в памяти сразу после таблиц прерываний.
Для этого в ld файле немного изменяется секция **.isr\_vector**. А сразу после таблицы векторов прерываний резервируется секция для хранения посмертного лога.
```
.isr_vector :
{
. = ALIGN(4);
KEEP(*(.isr_vector)) /* Startup code */
KEEP(*(.core_dump_section)) /* Место под дамп */
. = ALIGN(4);
} >FLASH
```
После этого, в коде приложения остается объявить буфер для сохранения дампа с аллокацией в правильном месте.
Очень важно, чтобы буфер был выровнен по границе сектора *aligned(FLASH\_PAGE\_SIZE)*, а начало буфера инициализировано 0xFF (как будто страница флеш память чистая).
Конечно, можно определить переменную и по жестко заданному адресу (изначально, я так и делал), но такое решение будет не универсальным, так как размер сегмента, а следовательно и адрес размещения буфера в программной памяти у разных серий микроконтроллеров могут отличаться.
```
const uint8_t dump_section[3][FLASH_PAGE_SIZE] __attribute__ ((used, section(".core_dump_section"), aligned(FLASH_PAGE_SIZE))) = {{0xFF, 0xFF, 0xFF, 0xFF}, {0xFF, 0xFF, 0xFF, 0xFF}, {0xFF, 0xFF, 0xFF, 0xFF}};
```
Первый элемент массива (который идет сразу после таблицы прерываний), для записи дампа использовать нельзя, т.к. [при включении защиты прошивки у серий STM32F1xx, блокировка от модификации включается сразу у двух соседних секторов](https://habr.com/ru/company/timeweb/blog/547106/).
Для хранения дампа я использую последний элемент в объявленном массиве. Все его элементы имеют одинаковый размер (равный сектору), а сам массив выравнен по его границе без каких либо сложных вычислений.
У STM32F10xx размер страницы (сектора) программной флеш памяти — 2k, значит дамп будет начинаться с адреса 0x08001800, а у STM32F20xx — STM32F40xx — 16к, а адрес буфера под дамп начинается с 0x0800C000.
Правда совсем без кодинга все же не обошлось, т.к. препроцессорные определения для разных серий микроконтроллеров STM32 отличаются. В частности у STM32F20xx и STM32F40xx макроопределение FLASH\_PAGE\_SIZE отсутствует (и это совершенно логично, т.к. размеры сегментов флеш памяти имеют разный размер), а у STM32F10xx в свою очередь не определен макрос FLASH\_END.
Хотя именно это в конечном итоге и позволило остановиться на максимально простом заголовочном файле.
```
#ifdef FLASH_END
// У STM32F2xx и STM32F4xx размер начальных секторов 16к
#define FLASH_PAGE_SIZE 0x4000
#endif
```
Запись дампа в память программ
------------------------------
В записи данных в память программ нет ничего особенного. Типовые функции очистки сектора и записи блока данных по указанному адресу с использованием штатных функций HAL.
**Очистка и запись данных в программную флеш память**
```
void stm32_flash_erase(void *address) {
HAL_FLASH_Unlock();
FLASH_EraseInitTypeDef log_erase;
#ifdef FLASH_END // STM32F4x и STM32F2x
log_erase.TypeErase = FLASH_TYPEERASE_SECTORS;
log_erase.Banks = FLASH_BANK_1;
log_erase.Sector = reinterpret_cast(address) / FLASH\_PAGE\_SIZE;
log\_erase.NbSectors = 1;
log\_erase.VoltageRange = FLASH\_VOLTAGE\_RANGE\_3;
#else // STM32F1x
log\_erase.TypeErase = FLASH\_TYPEERASE\_PAGES;
log\_erase.Banks = FLASH\_BANK\_1;
log\_erase.PageAddress = reinterpret\_cast(address);
log\_erase.NbPages = 1;
#endif
uint32\_t PageError;
HAL\_FLASHEx\_Erase(&log\_erase, &PageError);
HAL\_FLASH\_Lock();
}
void stm32\_flash\_write(void \*address, uint8\_t \*data, size\_t size) {
ASSERT((((uint32\_t )address) & 0x1) != 0x1); // Адрес выровненный на два
if ((((uint32\_t) address) & 0x1) == 0x1) {
return;
}
HAL\_FLASH\_Unlock();
uint32\_t temp;
for (size\_t i = 0; i < size / 4; i++) {
temp = \*(uint32\_t\*) (&data[i \* 4]);
HAL\_FLASH\_Program(FLASH\_TYPEPROGRAM\_WORD, (uint32\_t) address, temp);
address = (uint8\_t\*) address + 4;
}
uint32\_t remainder = size % 4;
if (remainder) {
temp = \*(volatile uint32\_t\*) address;
if (remainder == 1) {
temp &= 0xFFFFFF00;
temp |= (uint32\_t) data[size - 1];
} else if (remainder == 2) {
temp &= 0xFFFF0000;
temp |= (uint32\_t) data[size - 2];
temp |= (uint32\_t) data[size - 1] << 8;
} else { // 3
temp &= 0xFF000000;
temp |= (uint32\_t) data[size - 3];
temp |= (uint32\_t) data[size - 2] << 8;
temp |= (uint32\_t) data[size - 1] << 16;
}
HAL\_FLASH\_Program(FLASH\_TYPEPROGRAM\_WORD, (uint32\_t) address, temp);
}
HAL\_FLASH\_Lock();
}
```
Что сохраняем?
--------------
В текущей реализации сохраняется циклический буфер логов, который представляет собой последовательность текстовых строк и управляющих символов, отличных от "\xFF" и "\0". Ограничение на значения символов связаны с тем, что требуется каким-то образом детектировать наличие записанного посмертного дампа. А эти символы вполне подходят для таких целей.
Другими словами, если буфер начинается на 0xFF, значит флеш память чистая и буфер перед этим не сохранялся. А при чтении дампа, например, для его передачи в отладчный порт или по линии связи, он считывается либо до 0xFF, либо до нулевого байта.
Исходники логгера не привожу, т.к. каждый разработчик должен написать его сам :-). (шутка).
Хотя может и не совсем, потому что сколько я их не перепробывал, а в результате все равно остановился на собственной реализации, которая использую уже много лет и на десктопных приложениях и при разработке под микроконтроллеры.
Точнее, использую одни и те же исходники, включая библиотеку логирования, для всех вариантов платформ. Но это уже другая история… | https://habr.com/ru/post/546820/ | null | ru | null |
# Простой пример написания Dockerfile. Использование многоэтапной сборки
Всем привет! В данной статье хочу показать простой пример написания Dockerfile, объяснить как это все работает, а также показать на примере использование многоэтапной сборки.
Для понимания данной статьи необходимы минимальные знания Docker, а также для использования примеров - установленный Docker Desktop локально на компьютере.
Вначале немного теории.
Dockerfile - это файл, который содержит инструкции для сборки образа. На основании образа создается и запускается контейнер.
Обратимся к официальной документации <https://docs.docker.com/get-started/overview/>
 Это скриншот взят с официальной страницы.
На этом скриншоте мы видим схему как создаются и запускаются контейнеры. Мы как клиенты через команды docker обращаемся к Docker daemon, который берет локальный образ (image) и на основании его запускает контейнер, если образа локально нет - то он идет в registry (это может быть docker hub) и вначале стягивает его себе на компьютер. И может кто-то спросит "А где тут во всем этим dockerfile?". Именно на основании dockerfile и создается первоначально образ.
Для тестирования написания dockerfile создадим простой проект, который по сути ничего особо делать не будет, просто будет приветствовать нас.
Зайдем на <https://start.spring.io/> и создадим проект назовем его simple-dockerfile-example. Из зависимостей подключим только Spring Web.
Генерируем и открываем этот проект в IDEA.
Создаем класс ClientService:
```
@Service
public class ClientService {
@Value("${client}")
private String client;
public String sayHello(){
return "Hello!: " + client;
}
}
```
и класс ClientController:
```
@RestController
@RequestMapping("api/v1/client")
public class ClientController {
private final ClientService clientService;
@Autowired
public ClientController(ClientService clientService) {
this.clientService = clientService;
}
@GetMapping()
public String sayHello(){
return clientService.sayHello();
}
}
```
Также в application.properties пропишем одно свойство (client), то есть имя того кого будем приветствовать.
```
client=Ivan
```
Можем протестировать наш код, запустить проект и через postman отправить get запрос на http://localhost:8080/api/v1/client
Должны получить приветствие.
Сейчас попробуем на основании нашего проекта сделать образ и его запустить в контейнере. Для этого в корне нашего проекта создадим файл Dockerfile:
и в данном файле пишем:
```
FROM eclipse-temurin
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "/app.jar"]
```
Разберем что тут происходит в данном файле.
В первой строке мы указываем какой образ нужно стянуть с docker hub.
Этот образ нужен для того чтобы в контейнере была развернута своя JDK для запуска нашего проекта.
ARG JAR\_FILE=target/\*.jar - здесь мы создаем просто локальную переменную, которая ссылается на jar-ник нашего проекта.
COPY ${JAR\_FILE} app.jar - мы копируем наш jar-ник в образ и называем его app.jar.
EXPOSE 8080 - указываем на каком внешнем порту будет доступен наш контейнер.
ENTRYPOINT ["java", "-jar", "/app.jar"] - мы запускаем наш jar-ник.
Если кому-то не очень понятно что происходит в последней строчке, то это то же самое, что если бы мы предварительно запустили команду package и получили simple-dockerfile-example-0.0.1-SNAPSHOT.jar в папке target.
А затем с помощью командной строки зашли в папку target и выполним команду java -jar simple-dockerfile-example-0.0.1-SNAPSHOT.jar
И мы таким образом запустили наш проект. Можем сейчас зайти в postman и отправить get запрос на http://localhost:8080/api/v1/client и получить снова Hello!: Ivan.
Останавливаем проект. Заходим в терминале в корень нашего проекта, где лежит Dockerfile и сейчас будем строить наш образ. Выполним команду docker build .
Docker daemon должен стянуть всё необходимое с docker hub. Наш образ готов.
Посмотреть наши образы можно через команду docker images в командной строке или использовать Docker Desktop. Находим его во вкладке Images:
Мы видим, что образ есть и он занимает 490,84 МВ. Также выполним команду docker images в командной строке.
Дальше давайте запустим наш образ, то есть поместим его в контейнер.
Выполним команду docker run -p 8080:8080 b472
-p в данной команде мы указываем порты. Первый порт -это порт на нашем компьютере то есть наш localhost, а второй порт - это порт внутри контейнера.
b472 - это первые 4 буквы ID нашего контейнера, у Вас они будут отличаться.
После выполнения данной команды контейнер должен запуститься с нашим проектом и отправив через postman get запрос на http://localhost:8080/api/v1/client мы снова должны получить Hello!: Ivan.
Таким образом мы создали проект, создали образ с данным проектом и развернули его через docker в контейнере.
Что плохо написано в нашем Dockerfile.
Мы не указали версию JDK (это первая строка FROM eclipse-temurin), если версия не указана, то будет скачана самая последняя доступная версия, что может привести к несовместимости нашего приложения с JDK. И во-вторых здесь мы не компилируем jar, а только его запускаем, поэтому нам бы хватило и JRE и это уменьшит размер нашего образа. Переделаем это.
```
FROM eclipse-temurin:17-jre-alpine
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "/app.jar"]
```
Остановим наш контейнер через Docker Desktop и запустим снова команду docker build.
Выполним команду docker images:
И мы увидим, что размер нового образа 188 МВ в 2,5 раза меньше, чем предыдущий, а работает все также.
Перейдем сейчас к использованию многоэтапной сборки. Суть ее в том, что как вначале чтобы сделать образ мы сами вручную запускали команду мавена и создавали jar-ник нашего проекта, а при многоэтапной сборке jar-ник будет генерироваться автоматически.
Перепишем dockerfile.
```
FROM eclipse-temurin:17-jdk-alpine as builder
WORKDIR /opt/app
COPY .mvn/ .mvn
COPY mvnw pom.xml ./
RUN ./mvnw dependency:go-offline
COPY ./src ./src
RUN ./mvnw clean install
FROM eclipse-temurin:17-jre-alpine
WORKDIR /opt/app
COPY --from=builder /opt/app/target/*.jar /opt/app/*.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "/opt/app/*.jar"]
```
Разберемся что тут происходит.
FROM eclipse-temurin:17-jdk-alpine as builder - здесь, как мы уже знаем, указываем docker-у какой образ мы будем использовать для сборки нашего проекта и тут мы уже указываем именно jdk, так как нам понадобятся инструменты для компиляции нашего проекта. as builder - это название, которое мы присвоили, для того чтобы обратиться с другого слоя контейнера для получения данных.
WORKDIR /opt/app - создаем папки в данном слое
COPY .mvn/ .mvn - копируем папку mvn и все ее содержимое в такую же папку в корень данного слоя, для того чтобы у нас был maven.
COPY mvnw pom.xml ./ - копируем mvnw и pom.xml тоже в корень данного слоя.
RUN ./mvnw dependency:go-offline - данной строчкой мы подтягиваем все зависимости из pom.xml в наш слой, чтобы у нас в контейнере были все зависимости, необходимые для нашего проекта.
COPY ./src ./src - копируем непосредственно папку с нашим проектом.
RUN ./mvnw clean install - запускаем мавен, который все чистит и создает jar-ник нашего проекта.
строчка 10 WORKDIR /opt/app - создаем папки в другом слое.
COPY --from=builder /opt/app/target/\**.jar /opt/app/\**.jar - используя доступ к первому слою копируем jar-ник с нашим проектом в данный слой.
Давайте сейчас запустим все это дело.
Вначале остановим и удалим предыдущий запущенный контейнер через Docker Desktop.
Запустим снова команду docker build .
Немного подождем пока maven подтянет все зависимости.
Запустим команду docker images и посмотрим, что у нас появился новый образ.
и запустим его командой docker run -p 8080:8080 86ed
Контейнер запустился тестируем.
Еще хочу показать одну вещь. На основании одного образа можно запустить несколько контейнеров на разных портах и с разными свойствами.
Открываем например еще одну командную строку, я буду использовать PowerShell. Заходим в наш каталог, где лежит dockerfile и выполняем команду: docker run -p 7070:8080 -e client=test 86ed. Здесь мы запускаем контейнер с доступом на порту 7070 и с переменной client=test.
Заходим в postman.
И мы видим что мы изменили переменную с Ivan на test.
Запустим еще один контейнер с параметром develop на порту 9090.
Тестим.
Заходим в Docker Desktop и можем посмотреть, что все наши контейнеры работают, но работают на разных портах и с разными параметрами.
Это нужно для того, чтобы, например, развернуть один и тот же проект, но один для тестирования с подключенной тестовой базой данных, а один с рабочей.
Спасибо Всем кто дочитал до конца. | https://habr.com/ru/post/713942/ | null | ru | null |
# Своими руками. Как я сделал сервис сбора статистики цен на туры
Работа — работой, но иногда хочется отдохнуть. Предположим, вы собрались в отпуск в жаркие края. Перед вами сразу возникает несколько вопросов, основные из которых:
**1) Куда поехать отдыхать**
Действительно, нужно перечитать множество источников, чтобы определиться, где сейчас (или когда вы там собрались) тепло, нужна ли для въезда в страну виза, сколько стоит путёвка и т.д.
**2) Когда поехать отдыхать**
Допустим, вы знаете, что хотите провести свой отпуск в Египте, но не знаете когда. Самый важный вопрос для многих — когда дешевле всего туда ехать? Так же важно знать, какая там погода и т.д.
Как это работает
================
Загрузка
--------
У многих туроператоров имеются так называемые xml-шлюзы для выгрузки цен. Через эти шлюзы можно получить цены на те или иные туристические продукты. К сожалению, для доступа к этим данным очень часто требуется договор с туроператором. Так что просто так выполнить экспорт не получится. Для этого пришлось зарегистрироваться как юридическое лицо и помучаться с подписанием множества документов.
Данные, поставляемые туроператорами, выглядят приблизительно так:
```
18.11.2014
Трансаэро (аэропорт Пафос / Ларнака)
Пафос / Paphos
STANDARD Inland View BB
18.11.2014
102610001680
104610415895
1
1
9
121132934133
435
25435
14+, 14+
102510005340
```
Раз в неделю встроенный в Java scheduler начинает процесс сборки информации. За один проход осуществляется просмотр более 4000 отелей в 21 стране мира.
Сбор данных осуществляется более чем со 100 туроператоров.
Данные бережно укладываются в базу данных до востребования.
Новые отели так же добавляются автоматически. Это решает проблему изменения названия отеля или его закрытия.
Так же автоматически осуществляется сбор множества дополнительной информации.
Приблизительная схема базы данных наглядно демонстрирует множество параметров:
На текущий момент в базе данных под управлением Apache Derby содержит примерно 2 Гб данных.
Куда поехать отдыхать
---------------------
Отталкиваемся от того, что пользователь знает некоторые критерии своего будущего путешествия, но не знает пункт назначения.
На основе статистических данных о ценах, а так же используя вспомогательные данные, а именно:
— Даты и краткое описание праздников;
— Экскурсии, цены на них, краткое описание и тип (познавательные, экстремальные, обзорные);
— Необходимость в визе в ту или иную страну, а так же примерная цена, срок изготовления и место её получения;
— Время перелёта;
— Питание в отеле;
можно рассчитать в процентном соотношении, на сколько подходит каждая из 21 страны, предложенной сервисом.
Все параметры равновесные, так что применяя не очень хитрую формулу можно получить интересный результат:
Когда поехать отдыхать
----------------------
В этом случае пользователь знает, куда он хочет поехать и просто хочет посмотреть, как менялась цена и погода, а так же дополнительные параметры страны.
В этом случае мы просто отображаем так называемую «Карточку страны», которая отразит много полезной информации:
История создания
================
Идея зародилась ещё на 3м курсе (далёкий 2010) моего университета (спасибо СПбГПУ).
Захотелось мне как-то в отпуск, но возникла проблема — непонятно, когда дешевле и где теплее отдыхать.
На форумах пишут разные, порой противоречивые сведения, а сайтов с реальной статистикой хоть каких-то данных я не нашел.
Как это принято в IT-сфере, если не нашел решение — напиши сам.
**Первым шагом** была ручная сборка данных. Была табличка в Excel и пару функций, которые строили графики по данным. Через некоторое время стало лень (или просто забывал) добавлять данные.
**Вторым шагом** стало изучение языка C++. Практически вовремя в университете мы стали изучать язык C++ и делать на нём простенькие проекты. Мне сразу же захотелось автоматизировать процесс сборки данных и я написал сервис, который собирает данные с нескольких туроператоров. Данные он складывал в файлик и ни о каких базах данных или веб-серверах тогда речи не шло. Запускался сервис по крону на домашнем компьютере.
**Третьим шагом** стало полное переписывание проекта на Java с одновременным изучением EJB (Java EE), добавлением реляционной СУБД и веб-сервером для отображения данных пользователю (табличный вид).
В дальнейшем я добавлял различные js-библиотеки для построения графиков, улучшал производительность, устранял ошибки и так далее.
Перенёс сервис на «настоящий» сервер с моего домашнего компьютера
Заказал дизайн сайта у своего коллеги с одной из прошлых работ.
Зачем всё это?
==============
На самом деле, всё просто — проект был придуман исключительно для собственного использования. Мне просто хотелось получить сведения для наиболее дешевого и приятного отдыха.
Затем мне захотелось поделиться информацией со всем миром, чтобы каждый мог найти для себя полезную информацию.
Сейчас это хобби, время от времени я занимаюсь его развитием. Особых вложений денег я не осуществляю, кроме хостинга, домена, сертификатов, дизайна и времени (время же деньги).
Могут быть ошибки в вёрстке или другие мелкие проблемы — прошу не судить строго.
Шейринг приветствуется
[protury.info](https://protury.info) | https://habr.com/ru/post/289316/ | null | ru | null |
# Ошибка 404, которая спасла тысячи пользователей ВКонтакте
Вчера у службы технической поддержки REG.RU день начался не как всегда — число обращений было больше, чем в любой другой майский день. В своих письмах люди просили разблокировать Гугл или показать Яндекс, открыть доступ к Твиттеру и т.д.
В определенный момент писем уже пришло настолько много, что это было похоже на какой-то флешмоб.
В то же время в статистике посещаемости сайта [reg.ru](http://reg.ru) наблюдался всплеск переходов со страниц социальной сети vkontakte.ru – совпадение первое, следующее совпадение еще интереснее…
Событие только стало набирать масштабы, а специалисты компании уже разбирались детально в статистике: осуществлено по 2-3 перехода с тысяч страниц разных пользователей ВКонтакте, но на этих страницах не было никакого упоминания о REG.RU.
*(Скриншот из Google Analytics)*
Но страница одного события показалась очень подозрительной, с нее было всего около десятка переходов за начало дня — [vkontakte.ru/event27158053](http://vkontakte.ru/event27158053) В мероприятии говорится о программе, которая делает подарки ВКонтакте бесплатными и указана ссылка на скачивание \_ttp://vkliker.ru/FreePresents.exe *(не запускайте, там троян!)*.
Сотрудники произвели контрольное скачивание приложения, которое, как оказалось, не отличается оригинальностью и производит запись вида «IP адрес – название домена» для ресурсов:
`95.163.12.18 baidu.com
95.163.12.18 blogger.com
95.163.12.18 facebook.com
95.163.12.18 google.com
95.163.12.18 google.ru
95.163.12.18 live.com
95.163.12.18 livejournal.com
95.163.12.18 mail.ru
95.163.12.18 msn.com
95.163.12.18 myspace.com
95.163.12.18 odnoklassniki.ru
95.163.12.18 rambler.ru
95.163.12.18 rutube.ru
95.163.12.18 twitter.com
95.163.12.18 vk.com
95.163.12.18 vkontakte.ru
95.163.12.18 webmoney.ru
95.163.12.18 wikipedia.org
95.163.12.18 ya.ru
95.163.12.18 yahoo.com
95.163.12.18 yandex.net
95.163.12.18 yandex.ru
95.163.12.18 youtube.com
95.163.12.18 durov.ru
95.163.12.18 www.baidu.com
95.163.12.18 www.blogger.com
95.163.12.18 www.facebook.com
95.163.12.18 www.google.com
95.163.12.18 www.google.ru
95.163.12.18 www.live.com
95.163.12.18 www.livejournal.com
95.163.12.18 www.mail.ru
95.163.12.18 www.msn.com
95.163.12.18 www.myspace.com
95.163.12.18 www.odnoklassniki.ru
95.163.12.18 www.rambler.ru
95.163.12.18 www.rutube.ru
95.163.12.18 www.twitter.com
95.163.12.18 www.vk.com
95.163.12.18 www.vkontakte.ru
95.163.12.18 www.webmoney.ru
95.163.12.18 www.wikipedia.org
95.163.12.18 www.ya.ru
95.163.12.18 www.yahoo.com
95.163.12.18 www.yandex.net
95.163.12.18 www.yandex.ru
95.163.12.18 www.youtube.com
95.163.12.18 www.durov.ru`
При обращении по IP-адресу 95.163.12.18 отображается фишинговая страница Вконтакте. Пользователь, запустивший программу, попадает на страницу-фальшивку, вводит свои авторизационные данные и получает некое предупреждение об ошибке входа. Тем временем его логин и пароль входа уже пересланы злоумышленнику.
Совпадение номер два. Несколько дней назад в службу технической поддержки обратился человек, представившись владельцем хостинга для домена vkliker.ru, с вопросом о неработоспособности метода проверки сайта путем добавления записи в файл %WINDOWS%/system32/drivers/etc/hosts до того, как произойдет обновление DNS-серверов.
Обратившийся утверждал, что способ не работоспособен и при его использовании по адресу сайта отображается страница об ошибке. Сотрудник, уточняя детали, услышал фразу: *«Александр, у меня этот способ не работает, я добавляю еще другие домены, кроме своего, и именно они не работают».* Специалист технической поддержки хостинга, предположив возможные недобросовестные намерения, устно предупредил клиента, что его действия могут подпадать под определение «фишинга», т.е. являться незаконными. Клиент, ничего не ответив, предпочел закончить разговор.
Мошенник не справился с правильной настройкой дополнительного IP виртуального хостинга, в итоге «зараженным» посетителям, которые скачали и запустили зловредный FreePresents.exe выдавалась не фишинговая страница, а заглушка REG.RU с информацией о несуществующей странице. Зараженные пользователи набирали в браузере vkontakte.ru и попадали на страницу ошибки 404, где сообщалось, что такой страницы не существует. Поэтому расстроенные писали на первый попавшийся контакт с этой страницы, а именно в поддержку REG.RU.
Страница 404, которую все так не любят, чудесным образом спасла аккаунты тысяч пользователей ВКонтакте (прим. слово «тысяч» основано на количестве обращений к этой странице за первую половину дня).
Команда REG.RU максимально быстро отреагировала, поставив индивидуальную страницу, оповещающую пользователей о попытке взлома и с инструкцией по очистке файла hosts, рекомендацией поменять пароль к аккаунту на всякий случай и больше не запускать подозрительные файлы на своем компьютере.
Из всего сказанного можно сделать выводы, что бесплатный сыр бывает только в мышеловке. (ведь, на это намекает само изображение на странице мероприятия):
 | https://habr.com/ru/post/119654/ | null | ru | null |
# Реализация на Verilog цифрового БИХ-фильтра
Приветствую Хабр. Не так давно здесь уже появлялись статьи на эту тему [Verilog. Цифровой фильтр на RAM](http://habrahabr.ru/post/134485/) и [Построение цифрового фильтра с конечной импульсной характеристикой](http://habrahabr.ru/post/128140/). Хочу и я внести свой скромный вклад и представить вашему вниманию реализацию цифрового БИХ-фильтра на Verilog.
Не смотря на то, что занимающиеся данной темой всё из ниже описанного знают, хочу, для начала, все-таки дать совсем немного теории для широкого круга читателей.
[БИХ-фильтр](http://ru.wikipedia.org/wiki/%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D1%81_%D0%B1%D0%B5%D1%81%D0%BA%D0%BE%D0%BD%D0%B5%D1%87%D0%BD%D0%BE%D0%B9_%D0%B8%D0%BC%D0%BF%D1%83%D0%BB%D1%8C%D1%81%D0%BD%D0%BE%D0%B9_%D1%85%D0%B0%D1%80%D0%B0%D0%BA%D1%82%D0%B5%D1%80%D0%B8%D1%81%D1%82%D0%B8%D0%BA%D0%BE%D0%B9)(IIR-фильтр) — фильтр с бесконечной импульсной характеристикой (infinite impulse response). Отличительной чертой этого типа фильтра от [КИХ-фильтра](http://ru.wikipedia.org/wiki/%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D1%81_%D0%BA%D0%BE%D0%BD%D0%B5%D1%87%D0%BD%D0%BE%D0%B9_%D0%B8%D0%BC%D0%BF%D1%83%D0%BB%D1%8C%D1%81%D0%BD%D0%BE%D0%B9_%D1%85%D0%B0%D1%80%D0%B0%D0%BA%D1%82%D0%B5%D1%80%D0%B8%D1%81%D1%82%D0%B8%D0%BA%D0%BE%D0%B9) (фильтр с конечной импульсной характеристикой) является наличие обратной связи, когда значение на выходе фильтра зависит не только от входных данных, но и от выходных данных, полученных фильтром на предыдущих итерациях. Структуру БИХ-фильтра можно представить следующим образом:
Не буду останавливаться на методиках расчета коэффициентов аналогового фильтра, с этой темой можно ознакомиться в большом количестве изданий, таких как *Аналоговые и цифровые фильтры. Расчет и реализация Г.Лем* или *Синтез фильтров. Херреро Дж. Уиллонер Г.* Так же существует много программ, позволяющих это сделать. Опишу кратко только процесс преобразования аналогового фильтра в цифровой.
Любой фильтр можно представить с помощью аналоговой передаточной функции. Например для БИХ-фильтра второго порядка она будет выглядеть так:
Подставив в это выражение вместо нормированной комплексной переменной
получим передаточную функцию *A(z)*, которая может быть реализована в цифровом фильтре:
Коэффициенты для фильтра 2-го порядка будут определяться по следующим формулам:
где
 — тактовая частота
 — частота среза фильтра
d0...2 и с0...2 — коэффициенты аналогового фильтра, предполагается что вы их посчитали заранее.
Воспользовавшись этими нехитрыми вычислениями и зная соответствующие коэффициенты для аналогового фильтра, можно рассчитать коэффициенты для цифровой передаточной функции фильтра любого порядка. (Меня, правда, в свое время хватило только до 4-го порядка, причем сложности никакой в этом нет, просто приходится много писать длинные формулы, упрощая по формулам сокращенного умножения. Зато вспомнил далекие школьные годы). Передо мной, например, стояла задача реализовать фильтр с перестраиваемыми характеристики, поэтому все коэффициенты рассчитывались на ПК и передавались в FPGA в виде 32-х разрядных чисел, преобразованные перед этим в формат с плавающей запятой.
Итак, имея коэффициенты цифровой передаточной функции, подставим их в разностное уравнение БИХ-фильтра:
на основе которого уже не сложно написать реализацию на Verilog.
**Текст модуля**````
module LP_FILTER
(
mhz_clk,RESET,
D0,D1,D2,C0,C1,
X,Y,
COUNT
);
// low pass filter INPUT32 OUTPUT32
/*
y(i) = D2 * x(i) + D1 * x(i-1) + D0 * x(i-2) + C1 * y(i-1) + C0 * y(i-2)
A(z) = (D0+D1*z+D2*z*z)/(C0+C1*z+z*z) <==> A(P) = (d0+d1*P+d2*P*P)/(c0+c1*P+c2*P*P)
A(P) = 1/(1+1.4*P+P*P) LPF
D0 = ( d0 - d1*l + d2*l*l)/(c0 + c1*l + c2*l*l)
D1 = (2*d0 - 2*d2*l*l)/(c0 + c1*l + c2*l*l)
D2 = ( d0 + d1*l + d2*l*l)/(c0 + c1*l + c2*l*l)
C0 = -( c0 - c1*l + c2*l*l)/(c0 + c1*l + c2*l*l)
C1 = -(2*c0 - 2*c2*l*l)/(c0 + c1*l + c2*l*l)
l = ctg ( 3.14 * f_filt / f_samp )
*/
input mhz_clk;
input RESET;
input [17:0] X;
input [31:0] D0;
input [31:0] D1;
input [31:0] D2;
input [31:0] C0;
input [31:0] C1;
output [17:0] Y;
output [5:0] COUNT;
// adc-filter counter
reg [5:0] COUNT;
always @( posedge mhz_clk,negedge RESET )
if (~RESET) COUNT[5:0] = 0; //49 count
else if (COUNT[5:0] == 6'h31) COUNT[5:0] = 0;
else COUNT[5:0] = COUNT[5:0] + 6'b1;
// input - COUNT[4:0] = 24:49
// output - COUNT[4:0] = 6
reg [31:0] c0_y2;
reg [31:0] c1_y1;
reg [31:0] d0_x2;
reg [31:0] d1_x1;
reg [31:0] d2_x0;
reg [31:0] y0;
reg [31:0] y1;
reg [31:0] y2;
reg [31:0] x0;
reg [31:0] x1;
reg [31:0] x2;
// y(i) = D2 * x(i) + D1 * x(i-1) + D0 * x(i-2) + C1 * y(i-1) + C0 * y(i-2)
reg [31:0] mul_a;
reg [31:0] mul_b;
always @(*)
if ( ( COUNT[5:0] >= 0 ) & ( COUNT[5:0] <= 4 ) | ( COUNT[5:0] == 49 ) ) mul_a[31:0] = x0[31:0];
else if ( ( COUNT[5:0] >= 5 ) & ( COUNT[5:0] <= 10 ) ) mul_a[31:0] = x1[31:0];
else if ( ( COUNT[5:0] >= 11 ) & ( COUNT[5:0] <= 16 ) ) mul_a[31:0] = x2[31:0];
else if ( ( COUNT[5:0] >= 17 ) & ( COUNT[5:0] <= 22 ) ) mul_a[31:0] = y1[31:0];
else mul_a[31:0] = y2[31:0];
always @(*)
if ( ( COUNT[5:0] >= 0 ) & ( COUNT[5:0] <= 4 ) | ( COUNT[5:0] == 49 ) ) mul_b[31:0] = D2[31:0];
else if ( ( COUNT[5:0] >= 5 ) & ( COUNT[5:0] <= 10 ) ) mul_b[31:0] = D1[31:0];
else if ( ( COUNT[5:0] >= 11 ) & ( COUNT[5:0] <= 16 ) ) mul_b[31:0] = D0[31:0];
else if ( ( COUNT[5:0] >= 17 ) & ( COUNT[5:0] <= 22 ) ) mul_b[31:0] = C1[31:0];
else mul_b[31:0] = C0[31:0];
wire [31:0] mul_out;
mul_float32 ( 1, mhz_clk, mul_a[31:0], mul_b[31:0], mul_out[31:0] );
reg [31:0] outmul;
always @(*) outmul[31:0]=mul_out[31:0];
always @( posedge mhz_clk,negedge RESET )
if (~RESET) d2_x0[31:0] = 32'h0;
else if ( COUNT[5:0] == 4 ) d2_x0[31:0] = mul_out[31:0];
always @( posedge mhz_clk,negedge RESET )
if (~RESET) d1_x1[31:0] = 32'h0;
else if ( COUNT[5:0] == 10 ) d1_x1[31:0] = mul_out[31:0];
always @( posedge mhz_clk,negedge RESET )
if (~RESET) d0_x2[31:0] = 32'h0;
else if ( COUNT[5:0] == 16 ) d0_x2[31:0] = mul_out[31:0];
always @( posedge mhz_clk,negedge RESET )
if (~RESET) c1_y1[31:0] = 32'h0;
else if ( COUNT[5:0] == 22 ) c1_y1[31:0] = mul_out[31:0];
always @( posedge mhz_clk,negedge RESET )
if (~RESET) c0_y2[31:0] = 32'h0;
else if ( COUNT[5:0] == 28 ) c0_y2[31:0] = mul_out[31:0];
// y(i) = D2 * x(i) + D1 * x(i-1) + D0 * x(i-2) + C1 * y(i-1) + C0 * y(i-2)
reg [31:0] sum_a;
reg [31:0] sum_b;
always @(*)
if ( ( COUNT[5:0] >= 0 ) & ( COUNT[5:0] <= 18 ) | ( COUNT[5:0] == 49 ) ) sum_a[31:0] = d2_x0[31:0];
else if ( ( COUNT[5:0] >= 19 ) & ( COUNT[5:0] <= 26 ) ) sum_a[31:0] = d0_x2[31:0];
else if ( ( COUNT[5:0] >= 27 ) & ( COUNT[5:0] <= 34 ) ) sum_a[31:0] = c1_y1[31:0];
else sum_a[31:0] = c0_y2[31:0];
always @(*)
if ( ( COUNT[5:0] >= 0 ) & ( COUNT[5:0] <= 18 ) | ( COUNT[5:0] == 49 ) ) sum_b[31:0] = d1_x1[31:0];
else sum_b[31:0] = y0[31:0];
wire [31:0] sum_out;
sum_float32 ( 1, mhz_clk, sum_a[31:0], sum_b[31:0], sum_out[31:0] );
reg [31:0] outsum;
always @(*) outsum[31:0]=sum_out[31:0];
always @( posedge mhz_clk,negedge RESET )
if (~RESET) y0[31:0] = 32'h0;
else if ( ( COUNT[5:0] == 18 ) | ( COUNT[5:0] == 26 ) | ( COUNT[5:0] == 34 ) | ( COUNT[5:0] == 42 ) ) y0[31:0] = sum_out[31:0];
reg [17:0] int_to_float_in;
always @(*) begin int_to_float_in[17:0] = X[17:0];end
wire [31:0] int_to_float_out;
int18_to_float32 ( 1, mhz_clk, int_to_float_in[17:0], int_to_float_out[31:0] );
always @( posedge mhz_clk,negedge RESET )
if (~RESET) x0[31:0] = 32'h0;
else if ( COUNT[5:0] == 49 ) x0[31:0] = int_to_float_out[31:0];
always @( posedge mhz_clk,negedge RESET )
if (~RESET) x1[31:0] = 32'h0;
else if ( COUNT[5:0] == 49 ) x1[31:0] = x0[31:0];
always @( posedge mhz_clk,negedge RESET )
if (~RESET) x2[31:0] = 32'h0;
else if ( COUNT[5:0] == 49 ) x2[31:0] = x1[31:0];
always @( posedge mhz_clk,negedge RESET )
if (~RESET) y1[31:0] = 32'h0;
else if ( COUNT[5:0] == 49 ) y1[31:0] = sum_out[31:0];
always @( posedge mhz_clk,negedge RESET )
if (~RESET) y2[31:0] = 32'h0;
else if ( COUNT[5:0] == 49 ) y2[31:0] = y1[31:0];
wire [17:0] float_to_int_out;
wire nan;
wire overflow;
wire underflow;
float32_to_int18 ( 1, mhz_clk, y0[31:0], nan, overflow, float_to_int_out[17:0], underflow );
reg [17:0] Y;
always @( posedge mhz_clk ) if ( COUNT[4:0] == 6 ) Y[17:0] = float_to_int_out[17:0];
endmodule
````
Программа представляет собой законченный модуль, готовый к включению в существующий проект. Входные данные передаются в него в виде 18-ти разрядных целых чисел. (Возможно кому-то покажется странным такая разрядность, поясню сразу, что на разработанной плате используется 18-ти разрядная АЦП AD7643). Далее они преобразовываются в 32-х разрядный формат с плавающей точкой. Это выполняется по-средствам стандартной альтеровской мегафункции *int18\_to\_float32*. Сложение и умножение реализовано так же стандартными функциями *sum\_float32* и *mul\_float32* соответственно. После выполнения необходимых вычислений результат конвертируется в целое 18-ти разрядной число функцией *float32\_to\_int18*. С помощью предварительно рассчитанных коэффициентов можно превратить этот модуль как в фильтр нижних частот, верхних частот либо полосовой.
[Архив проекта в Quartus II 9.1](http://ifolder.ru/31013637)
Помимо уже упомянутых в тексте книг и данных из Википедии при написании топика использовалось *справочное руководство Полупроводниковая схемотехника. Титце У., Шенк К.* и [Структуры цифровых фильтров и их характеристики](http://www.dsplib.ru/content/filters/ch10/ch10.html)
Прошу прощения за некоторую сумбурность изложения, т.к. литературный талант никогда не являлся моей отличительной чертой, и спасибо за внимание. | https://habr.com/ru/post/145703/ | null | ru | null |
# Работа с данными в мобильных приложениях. Реализуем offline хранилище и синхронизацию данных используя Microsoft Azure и SQLite
Сейчас на рынке есть огромное количество приложений, которые не приспособлены для работы offline, что создает неудобства для пользователей.
Некоторое время назад, для разработчиков на C# стал доступен новый [Microsoft Azure Mobile Services SQLiteStore SDK 1.0 alpha](http://www.nuget.org/packages/WindowsAzure.MobileServices.SQLiteStore/1.0.0-alpha), который предоставляет API для создания приложения, работающих в условиях отсутствия интернета и берущий на себя все заботы о синхронизации данных между локальной базой данных и базой данных Azure. В качестве локальной базы данных создается и используется SQLite.
Итак, у нас есть следующие популярные способы организации offline хранилища:
* Сериализация в XML, JSON или другой NoSQL.
* [SQLite](http://www.sqlite.org/) или другие сторонние БД.
Механизмы синхронизации:
* Каждый раз обновляется локальная копия базы полностью.
* Только изменения передаются по сети.
Средства синхронизации:
* [Sync Framework Toolkit](http://code.msdn.microsoft.com/wpapps/Sync-Framework-Toolkit-4dc10f0e)
* [Azure SQL Data Sync](http://msdn.microsoft.com/en-us/library/hh456371.aspx)
* Разработка собственной логики и библиотек для синхронизации.
* [Microsoft Azure Mobile Services SQLiteStore SDK 1.0 alpha](http://www.nuget.org/packages/WindowsAzure.MobileServices.SQLiteStore/1.0.0-alpha) (**! Новое**)
#### Azure Mobile Services SDK для синхронизации
Функциональность нового [Microsoft Azure Mobile Services SQLiteStore SDK 1.0 alpha](http://www.nuget.org/packages/WindowsAzure.MobileServices.SQLiteStore/1.0.0-alpha) для синхронизации данных не идентична Sync Framework или Azure Data Sync.
С точки зрения клиентской стороны, пока есть возможность работать только с [SQLite](http://www.sqlite.org/), но создатели обещают, что возможности будут развиваться и другие клиентские БД добавятся позже.
Серверная сторона поддерживает следующие базы данных: SQL Database, MongoDB и Azure Table Storage.
[SDK](http://www.nuget.org/packages/WindowsAzure.MobileServices.SQLiteStore/1.0.0-alpha) поддерживает следующие операции: **Push** (отправка на сервер), **Pull** (загрузка с сервера), **Purge** (очистка локального хранилища).
Сегодня мы остановимся на том, как создать бэкенд для вашего приложения используя [Microsoft Azure Mobile Services SQLiteStore SDK 1.0 alpha](http://www.nuget.org/packages/WindowsAzure.MobileServices.SQLiteStore/1.0.0-alpha).
Для работы нам понадобится:
* [Подписка Azure](http://azure.microsoft.com/) — на сайте можно оформить trial на месяц
* [Windows 8.1](http://windows.microsoft.com/en-us/windows/buy)
* [Visual Studio 2013 Update 2](http://www.microsoft.com/en-us/download/details.aspx?id=42666)
Наша задача будет состоять из следующих пунктов:
* Создание мобильного сервиса и мобильной БД в Microsoft Azure;
* Создание проекта приложения. Мы будем делать универсальное приложение в Visual Studio.
* Создание локальной БД приложения.
* Реализации синхронизации данных.
Давайте приступим…
#### Настройка Azure Mobile Services
1. Чтобы создать Azure Mobile Service для вашего проекта, необходимо открыть [Microsoft Azure Portal](http://manage.windowsazure.com/) и перейти в меню **Mobile Services** – **New**
Создавая облачный сервис, вы можете выбрать на каком языке вы будете писать код сервиса. На С# или JavaScript.
2. Когда мобильный сервис создастся, на главной странице сервиса, вы сможете найти инструкции, как использовать его в приложениях для многих популярных платформ и фреймфорков, таких как Windows, Windows Phone, IOS, Android, Xamarin.
3. Вы можете скачать шаблон проекта облачного сервиса, доработать его код, например, поправив модель данных как на скриншоте ниже.
4. Затем, опубликовать в облаке из Visual Studio.
Как разработать и опубликовать облачный сервис достаточно подробно написано [тут](http://azure.microsoft.com/en-us/documentation/articles/mobile-services-windows-store-get-started/).
#### Создаем проект приложения
1. Я буду использовать проект универсального приложения для Windows и Windows Phone.
2. После создания проекта, подключим необходимые библиотеки. Так как у нас проект и для Windows и для Windows Phone, то установить **WindowsAzure.MobileServices** надо для обоих проектов.
3. В общем проекте (**Shared**), открываем **App.xaml.cs** и добавляем туда объявление мобильного сервиса:
```
public static MobileServiceClient MobileService = new MobileServiceClient("https://demo-backend.azure-mobile.net/", "ZDgibxPOCWSwOvbYJvAAipjAybMIJO51");
```
4. Теперь мы можем работать с данными через облачный сервис и сохранять данныe в БД.
#### Создание локальной базы данных и синхронизация
Теперь нам надо создать локальное хранилище данных SQLite.
1. Установим [SQLite для Windows 8.1](http://visualstudiogallery.msdn.microsoft.com/1d04f82f-2fe9-4727-a2f9-a2db127ddc9a) и [SQLite для Windows Phone 8.1](http://visualstudiogallery.msdn.microsoft.com/5d97faf6-39e3-4048-a0bc-adde2af75d1b)
2. Добавим SQLite в качестве используемой библиотеки для наших приложений Windows и Windows Phone.
3. Установим и добавим в **References** пакет **WindowsAzure.MobileServices.SQLiteStore**
4. Откроем **Shared** проект и создадим там новый пустой класс с моделью данных. В моем случае, он получился вот такой:
5. Создадим вспомогательный класс, который будет создавать нам локальную базу данных, уметь наполнять её данными и отправлять данные в облачный сервис.
**MobileServicesSync.cs**
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.WindowsAzure.MobileServices.Sync;
using Microsoft.WindowsAzure.MobileServices.SQLiteStore;
using System.Threading;
namespace DemoApp
{
public static class MobileServicesSync
{
public static async void InitSQLiteStore()
{
if (!App.MobileService.SyncContext.IsInitialized)
{
var store = new MobileServiceSQLiteStore("DemoAppSync.db");
store.DefineTable();
await App.MobileService.SyncContext.InitializeAsync(store, new MobileServiceSyncHandler());
}
}
public static async void InsertItem(MyAppItem item)
{
IMobileServiceSyncTable table = App.MobileService.GetSyncTable();
await table.InsertAsync(item);
}
public static async void Push()
{
string errorString = null;
try
{
CancellationToken token = new CancellationToken();
await App.MobileService.SyncContext.PushAsync(token);
}
catch (MobileServicePushFailedException ex)
{
errorString = "Push failed because of sync errors: " + ex.PushResult.Errors.Count() + ", message: " + ex.Message;
}
catch (Exception ex)
{
errorString = "Push failed: " + ex.Message;
}
}
}
}
```
#### Интерфейс приложения
1. Откроем **MainPage.xaml** и добавим туда кнопки для заполнения таблицы данными и синхронизации.
**MainPage.xaml**
```
```
2. Добавим в **MainPage.xaml.cs** код для обработки событий.
**MainPage.xaml.cs**
```
public MainPage()
{
this.InitializeComponent();
MobileServicesSync.InitSQLiteStore();
}
private void addBtn_Click(object sender, RoutedEventArgs e)
{
MobileServicesSync.InsertItem(new MyAppItem { Text="Ура!" });
}
private void syncBtn_Click(object sender, RoutedEventArgs e)
{
MobileServicesSync.Push();
}
```
#### Запуск и проверка
1. Запустим приложение и посмотрим как оно работает.
2. Как только мы запустили приложение, у нас уже создалась локальная база SQLite. Мы можем найти её в папке приложения и посмотреть. Для этого я буду использовать [SQLite Browser](http://sqlitebrowser.org/).
Моя БД лежит тут: *C:\Users\[username]\AppData\Local\Packages\[app id]\LocalState*
Как видите, сейчас она пустая.
3. Добавим в неё элемент, нажав на кнопку **Add Item** нашего приложения.
4. Данные в базе обновятся и туда добавится запись, но наша облачная БД всё еще пуста.
5. Теперь нажмем на кнопку **Sync** в приложении для синхронизации баз данных и смотрим результат.
Синхронизация отработала и в облачной базе появились данные из локальной базы приложения.
**Примечание: для тех, у кого не заработало**Может так оказаться, что создание локальной БД упадет с ошибкой. Тогда найдите и добавьте в **References** сборку **SQLitePCL.Ext.dll**. Сама она почему-то не всегда устанавливается NuGet’ом.
#### Заключение
Новый Microsoft Azure Mobile Services и его [SDK](http://www.nuget.org/packages/WindowsAzure.MobileServices.SQLiteStore/1.0.0-alpha) имеет много новых полезных возможностей для разработчиков приложений. Одна из них – это поддержка offline работы и синхронизации данных для приложений. Следуя этой инструкции, вы можете настроить синхронизацию данных для вашего Phone или Windows приложения не тратя много времени на сложные алгоритмы и написание библиотек.
#### Полезные ссылки
* ##### [Blog: Deep dive on the offline support in the Azure Mobile Service managed client SDK](http://blogs.msdn.com/b/carlosfigueira/archive/2014/04/07/deep-dive-on-the-offline-support-in-the-azure-mobile-service-managed-client-sdk.aspx)
* ##### [Tutorial: Get started with offline data](http://azure.microsoft.com/en-us/documentation/articles/Mobile-services-windows-store-dotnet-get-started-offline-data/)
* ##### [Tutorial: Handle conflicts with offline data in Mobile Services](http://azure.microsoft.com/en-us/documentation/articles/Mobile-services-windows-store-dotnet-handling-conflicts-offline-data/)
* ##### [Попробовать Azure](http://aka.ms/azure_trial_free_rus) бесплатно на 30 дней!
* ##### [Загрузить](http://aka.ms/getvsrus) бесплатную или пробную Visual Studio
* ##### Пройти обучающие курсы на [виртуальной академии Microsoft](http://aka.ms/gomvarus) (MVA)
+ [Разработка приложений на платформе Microsoft](http://www.microsoftvirtualacademy.com/training-courses/app-development-on-microsoft-platform-rus)
+ [Кросс-платформенная разработка приложений для Windows Phone и Windows 8](http://www.microsoftvirtualacademy.com/training-courses/cross-platforming-dev-for-windows-phone-windows-8-rus)
+ [Разработка приложений с общим кодом для платформ Windows 8 и Windows Phone](http://www.microsoftvirtualacademy.com/training-courses/build-for-windows-8-windows-phone)
+ [Сложные приёмы разработки приложений для Windows Phone 8](http://www.microsoftvirtualacademy.com/training-courses/windows-phone-8-for-begginers)
+ [Расширенные возможности разработки для Windows Phone 8](http://www.microsoftvirtualacademy.com/training-courses/advanced-possibilities-appdev-windows-phone-8-rus)
+ или [курсы по разработке в облаке Azure](http://www.microsoftvirtualacademy.com/product-training/product-windows-azure-ru)
+ или многие другие [бесплатные курсы MVA](http://aka.ms/gomvarus)!
* ##### [Стать разработчиком](http://aka.ms/wpstartrus) приложений Windows Phone | https://habr.com/ru/post/229041/ | null | ru | null |
# Одна маленькая оптимизация
Совсем недавно со мной поделились историей одной оптимизации (привет [stanislaw](http://habrahabr.ru/users/stanislaw/)), которая показалась мне довольно забавной.
Проект игровой и с постоянно растущей базой пользователей, но так как расширятся в ширь не хотелось — возникла задача оптимизировать существующий код в узких местах. После недолгого профайлинга, буквально сразу, удалось найти одно такое узкое место, которое на первый взгляд не вызвало бы ни у кого подозрений:
```
for (A a : arrayListA) {
// do something
for (B b : arrayListB) {
// do something
for (C c : arrayListC) {
// do something
}
}
}
```
Доступа к коду у меня нету, поэтому я передаю лишь суть повествования. Есть некий метод просчета ситуации на карте, в котором происходит много итераций по разного рода циклам. Причём, граф объектов уже создан и изменяется лишь его состояние. То есть новых объектов фактически не создается… Но тем не менее профайлер показывал приблизительно такую картину (картинка из предыдущего топика):
И при частых вызовах метода сборка занимала довольно большую часть времени работы метода.
Проблема оказалась в for циклах. Как известно, компилятор преобразовывает for цикл для коллекций в следующий код:
```
for (Iteratori = arrayListA.iterator(); i.hasNext();) {
a = i.next();
}
//смотрим во внутрь метода iterator() ArrayList
public Iterator iterator() {
return new Itr();
}
//и сам класс итератора. поля которые потребляют память
private class Itr implements Iterator {
int cursor = 0;
int lastRet = -1;
int expectedModCount = modCount;
}
```
Все бы хорошо, но если у вас несколько вложенных циклов, при чем короткие циклы на самом нижнем уровне вложения, то получается, что просто один лишь проход по циклам создаст тысячи объектов, а если метод постоянно вызывается, то еще и постоянные срабатывания сборщика.
Например, для первого примера — в случае если arrayListA.size() == 1000, arrayListB.size() == 100, arrayListC.size() == 10 за один проход по циклам будет создано около 100 тыс. объектов итераторов…
Решение тут довольно очевидно — получать доступ по индексу:
```
for (int i = 0; i < arrayListA.size(); i++) {
A a = arrayListA.get(i);
}
```
Такое вот маленькое изменение кода в данном конкретном случае позволило увеличить скорость работы горячего метода в 2 раза.
Стоит отметить, что такого рода оптимизация возможна в основном в случае ArrayList.
Будьте внимательны и с прошедшим Вас Новым годом! | https://habr.com/ru/post/164177/ | null | ru | null |
# Flask-DJ: Django (mvc) структура для проекта на flask
Всем привет!
Когда я впервые столкнулся с Flask, у меня сразу возник вопрос по построению архитектуры проекта.
Прочитав пару статей на Хабре (<https://habr.com/ru/post/275099/> и <https://habr.com/ru/post/421887/>), я вспомнил свой опыт создания проектов на Django, и решил сделать инструмент, благодаря которому не придется задумываться об архитектуре, но при этом можно будет использовать все возможности Flask.
Установка
---------
```
$ pip install Flask-DJ
```
Создание проекта
----------------
Создать проект можно либо с помощью консоли (для шаблонов и статических файлов используются флаги -t -st)
```
$ flask-dj startproject app
```
Либо можно создать файл setup.py
(для шаблонов и статических файлов используются флаги
need\_templates=True, need\_static=True).
```
from flask_dj import startproject
from os import getcwd
your_project_name = 'app'
project_dir = getcwd()
startproject(your_project_name, project_dir)
```
В результате должна получится следующая структура
(static и templates появятся при указании соответствующих флагов)
```
app/
app/
__init__.py
config.py
urls.py
manage.py
```
Создание приложения
-------------------
Приложением в данном случае называется модуль (элемент приложения).
Для создания необходимо прописать следующую команду (вместо index поставить имя вашего приложения).
```
$ python manage.py startapp index
```
После выполнения у проекта будет следующая структура:
```
app/
app/
__init__.py
config.py
urls.py
index/
forms.py
models.py
urls.py
views.py
manage.py
```
Создаем принимающую (view) функцию
----------------------------------
Все гайды принято начинать с Hello world, мы не будем исключением:
```
# index/views.py
def index():
return "Hello world"
```
Создаем URL для нашей функции
-----------------------------
Создаем относительный путь внутри index:
```
# index/urls.py
from utils.urls import relative_path
from .views import index
urlpatterns = [
relative_path("", index),
]
```
Добавляем наше приложение к глобальному пути:
```
# app/urls.py
from utils.urls import add_relative_path, include
urlpatterns = [
add_relative_path("/", include("index.urls")),
]
```
Запускаем сервер
----------------
```
$ python manage.py runserver
```
Если все шаги сделаны верно, то мы увидим следующее
P.S.
----
Надеюсь данная статья была для вас полезной.
Если вас заинтересовала данная библиотека, то вот ссылки на нее:
* <https://github.com/AlexandrovRoman/Flask-DJ>
* <https://flask-dj.readthedocs.io/en/latest/>
* <https://pypi.org/project/Flask-DJ/>
Upd1 Спасибо [buriy](https://habr.com/ru/users/buriy/) за полезные замечания | https://habr.com/ru/post/491852/ | null | ru | null |
# MVCC-5. Внутристраничная очистка и HOT
Напомню, что мы рассмотрели вопросы, связанные с [изоляцией](https://habr.com/ru/company/postgrespro/blog/442804/), сделали отступление про [организацию данных на низком уровне](https://habr.com/ru/company/postgrespro/blog/444536/), а затем подробно поговорили [о версиях строк](https://habr.com/ru/company/postgrespro/blog/445820/) и о том, как из версий получаются [снимки данных](https://habr.com/ru/company/postgrespro/blog/446652/).
Сегодня займемся двумя довольно тесно связанными вопросами: *внутристраничной очисткой* и *HOT-обновлениями*. Оба механизма можно отнести к разряду оптимизаций; они важны, но в пользовательской документации практически не освещены.
Внутристраничная очистка при обычных обновлениях
================================================
При обращении к странице — как при обновлении, так и при чтении — может происходить быстрая внутристраничная очистка, если PostgreSQL поймет, что место на странице заканчивается. Это происходит в двух случаях.
1. Ранее выполненное на этой странице обновление (UPDATE) не обнаружило достаточно места, чтобы разместить новую версию строки на той же странице. Такая ситуация запоминается в заголовке страницы, и в следующий раз страница очищается.
2. Страница заполнена больше, чем на fillfactor. При этом очистка происходит сразу, не откладывая на следующий раз.
Fillfactor — параметр хранения, который можно определить для таблицы (и для индекса). PostgreSQL вставляет новую строку (INSERT) на страницу, только если эта страница заполнена менее, чем на fillfactor процентов. Остальное место резервируется для новых версий строк, которые получаются в результате обновлений (UPDATE). Значение по умолчанию для таблиц равно 100, то есть место не резервируется (а значение для индексов — 90).
Внутристраничная очистка убирает версии строк, не видимые ни в одном снимке (находящиеся за «горизонтом событий» базы данных, об этом мы говорили [в прошлый раз](https://habr.com/ru/company/postgrespro/blog/446652/)), но работает строго в пределах одной табличной страницы. Указатели на вычищенные версии строк не освобождаются, так как на них могут вести ссылки из индексов, а индекс — это уже другая страница. Внутристраничная очистка никогда не выходит за одну табличную страницу, зато выполняется очень быстро.
Из этих же соображений не обновляется карта свободного пространства; также это приберегает освобожденное место для обновлений, а не для вставок. Не обновляется и карта видимости.
Тот факт, что страница может очищаться при чтении, означает, что запрос на чтение (SELECT) может вызвать изменение страниц. Это еще один такой случай, в дополнение к рассмотренному ранее отложенному изменению битов-подсказок.
Посмотрим, как это работает, на примере. Создадим таблицу и индексы по обоим столбцам.
```
=> CREATE TABLE hot(id integer, s char(2000)) WITH (fillfactor = 75);
=> CREATE INDEX hot_id ON hot(id);
=> CREATE INDEX hot_s ON hot(s);
```
Если в столбце s хранить только латинские буквы, то каждая версия строки будет занимать 2004 байта плюс 24 байта заголовка. Параметр хранения fillfactor установим в 75% — места будет хватать на три строки.
Для удобства пересоздадим уже знакомую функцию, дополнив вывод двумя полями:
```
=> CREATE FUNCTION heap_page(relname text, pageno integer)
RETURNS TABLE(ctid tid, state text, xmin text, xmax text, hhu text, hot text, t_ctid tid)
AS $$
SELECT (pageno,lp)::text::tid AS ctid,
CASE lp_flags
WHEN 0 THEN 'unused'
WHEN 1 THEN 'normal'
WHEN 2 THEN 'redirect to '||lp_off
WHEN 3 THEN 'dead'
END AS state,
t_xmin || CASE
WHEN (t_infomask & 256) > 0 THEN ' (c)'
WHEN (t_infomask & 512) > 0 THEN ' (a)'
ELSE ''
END AS xmin,
t_xmax || CASE
WHEN (t_infomask & 1024) > 0 THEN ' (c)'
WHEN (t_infomask & 2048) > 0 THEN ' (a)'
ELSE ''
END AS xmax,
CASE WHEN (t_infomask2 & 16384) > 0 THEN 't' END AS hhu,
CASE WHEN (t_infomask2 & 32768) > 0 THEN 't' END AS hot,
t_ctid
FROM heap_page_items(get_raw_page(relname,pageno))
ORDER BY lp;
$$ LANGUAGE SQL;
```
И еще создадим функцию, чтобы заглядывать внутрь индексной страницы:
```
=> CREATE FUNCTION index_page(relname text, pageno integer)
RETURNS TABLE(itemoffset smallint, ctid tid)
AS $$
SELECT itemoffset,
ctid
FROM bt_page_items(relname,pageno);
$$ LANGUAGE SQL;
```
Проверим, как работает внутристраничная очистка. Для этого вставим одну строку и несколько раз изменим ее:
```
=> INSERT INTO hot VALUES (1, 'A');
=> UPDATE hot SET s = 'B';
=> UPDATE hot SET s = 'C';
=> UPDATE hot SET s = 'D';
```
В странице сейчас четыре версии строки:
```
=> SELECT * FROM heap_page('hot',0);
```
```
ctid | state | xmin | xmax | hhu | hot | t_ctid
-------+--------+----------+----------+-----+-----+--------
(0,1) | normal | 3979 (c) | 3980 (c) | | | (0,2)
(0,2) | normal | 3980 (c) | 3981 (c) | | | (0,3)
(0,3) | normal | 3981 (c) | 3982 | | | (0,4)
(0,4) | normal | 3982 | 0 (a) | | | (0,4)
(4 rows)
```
Как и ожидалось, мы только что превысили порог fillfactor. На это указывает разница между значениями pagesize и upper: она превышает порог в 75% от размера страницы, что составляет 6144 байтов.
```
=> SELECT lower, upper, pagesize FROM page_header(get_raw_page('hot',0));
```
```
lower | upper | pagesize
-------+-------+----------
40 | 64 | 8192
(1 row)
```
Итак, при следующем обращении к странице должна произойти внутристраничная очистка. Проверим это.
```
=> UPDATE hot SET s = 'E';
=> SELECT * FROM heap_page('hot',0);
```
```
ctid | state | xmin | xmax | hhu | hot | t_ctid
-------+--------+----------+-------+-----+-----+--------
(0,1) | dead | | | | |
(0,2) | dead | | | | |
(0,3) | dead | | | | |
(0,4) | normal | 3982 (c) | 3983 | | | (0,5)
(0,5) | normal | 3983 | 0 (a) | | | (0,5)
(5 rows)
```
Все неактуальные версии строк (0,1), (0,2) и (0,3) очищены; после этого на освободившееся место добавлена новая версия строки (0,5).
Оставшиеся после очистки версии строк физически сдвигаются в сторону старших адресов страницы так, чтобы все свободное место было представлено одним непрерывным фрагментом. Соответствующим образом изменяются и значения указателей. Благодаря этому не возникает проблем с фрагментацией свободного места в странице.
Указатели на удаленные версии строк освободить нельзя, поскольку на них существует ссылки из индексной страницы. Посмотрим в первую страницу индекса hot\_s (потому что нулевая занята метаинформацией):
```
=> SELECT * FROM index_page('hot_s',1);
```
```
itemoffset | ctid
------------+-------
1 | (0,1)
2 | (0,2)
3 | (0,3)
4 | (0,4)
5 | (0,5)
(5 rows)
```
Ту же картину мы увидим и в другом индексе:
```
=> SELECT * FROM index_page('hot_id',1);
```
```
itemoffset | ctid
------------+-------
1 | (0,5)
2 | (0,4)
3 | (0,3)
4 | (0,2)
5 | (0,1)
(5 rows)
```
Можно обратить внимание, что указатели на табличные строки идут здесь “задом наперед”, но это не имеет значения, поскольку во всех версиях строк находится одно и то же значение id = 1. А вот в предыдущем индексе указатели упорядочены по значениям s, и это существенно.
При индексном доступе PostgreSQL может получить (0,1), (0,2) или (0,3) в качестве идентификатора версии строки. Тогда он попробует получить соответствующую строку из табличной станицы, но благодаря статусу dead указателя обнаружит, что такая версия уже не существует и проигнорирует ее. (На самом деле, в первый раз обнаружив отсутствие версии табличной строки, PostgreSQL изменит и статус указателя в индексной странице, чтобы повторно не обращаться к табличной странице.)
Принципиально то, что внутристраничная очистка работает только в пределах одной табличной страницы и не очищает индексные страницы.
HOT-обновления
==============
Чем плохо держать в индексе ссылки на все версии строки?
Во-первых, при любом изменении строки приходится обновлять все индексы, созданные для таблицы: раз появилась новая версия, необходимо иметь на нее ссылки. И делать это надо в любом случае, даже если изменяются поля, не входящие в индекс. Очевидно, что это не слишком эффективно.
Во-вторых, в индексах накапливаются ссылки на исторические версии строки, которые потом приходится очищать вместе с самими версиями (как это делается, мы рассмотрим чуть позже).
Более того, есть особенность реализации B-дерева в PostgreSQL. Если на индексной странице недостаточно места для вставки новой строки, страница делится на две и все данные перераспределяются между ними. Это называется расщеплением (split) страницы. Однако при удалении строк две индексные страницы уже не «склеиваются» в одну. Из-за этого размер индекса может не уменьшиться даже при удалении существенной части данных.
Естественно, чем больше индексов создано на таблице, тем с большими сложностями приходится сталкиваться.
Однако если меняется значение столбца, который не входит ни в один индекс, то нет никакого смысла создавать дополнительную запись в B-дереве, содержащую то же самое значение ключа. Именно так работает оптимизация, называемая HOT-обновлением — Heap-Only Tuple Update.
При таком обновлении в индексной странице находится лишь одна запись, ссылающаяся на самую первую версию строки в табличной странице. А уже внутри этой табличной страницы организуется цепочка версий:
* строки, которые изменены и входят в цепочку, маркируются битом Heap Hot Updated;
* строки, на которые нет ссылок из индекса, маркируются битом Heap Only Tuple (то есть — «только табличная версия строки»);
* поддерживается обычная связь версий строк через поле ctid.
Если при сканировании индекса PostgreSQL попадает в табличную страницу и обнаруживает версию, помеченную как Heap Hot Updated, он понимает, что не надо останавливаться и проходит дальше по всей цепочке обновлений. Разумеется, для всех полученных таким образом версий строк проверяется видимость, прежде чем они будут возвращены клиенту.
Чтобы посмотреть на работу HOT-обновления, удалим один индекс и очистим таблицу.
```
=> DROP INDEX hot_s;
=> TRUNCATE TABLE hot;
```
Повторим вставку и обновление строки.
```
=> INSERT INTO hot VALUES (1, 'A');
=> UPDATE hot SET s = 'B';
```
Вот что мы видим в табличной странице:
```
=> SELECT * FROM heap_page('hot',0);
```
```
ctid | state | xmin | xmax | hhu | hot | t_ctid
-------+--------+----------+-------+-----+-----+--------
(0,1) | normal | 3986 (c) | 3987 | t | | (0,2)
(0,2) | normal | 3987 | 0 (a) | | t | (0,2)
(2 rows)
```
В странице — цепочка изменений:
* флаг Heap Hot Updated показывает, что надо идти по цепочке ctid,
* флаг Heap Only Tuple показывает, что на данную версию строки нет ссылок из индексов.
При дальнейших изменениях цепочка будет расти (в пределах страницы):
```
=> UPDATE hot SET s = 'C';
=> UPDATE hot SET s = 'D';
=> SELECT * FROM heap_page('hot',0);
```
```
ctid | state | xmin | xmax | hhu | hot | t_ctid
-------+--------+----------+----------+-----+-----+--------
(0,1) | normal | 3986 (c) | 3987 (c) | t | | (0,2)
(0,2) | normal | 3987 (c) | 3988 (c) | t | t | (0,3)
(0,3) | normal | 3988 (c) | 3989 | t | t | (0,4)
(0,4) | normal | 3989 | 0 (a) | | t | (0,4)
(4 rows)
```
При этом в индексе одна-единственная ссылка на “голову” цепочки:
```
=> SELECT * FROM index_page('hot_id',1);
```
```
itemoffset | ctid
------------+-------
1 | (0,1)
(1 row)
```
Подчеркнем, что HOT-обновления работают в случае, если обновляемые поля не входят ни в один индекс. Иначе в каком-либо индексе оказалась бы ссылка непосредственно на новую версию строки, что противоречит идее этой оптимизации.
Оптимизация действует только в пределах одной страницы, поэтому дополнительный обход цепочки не требует обращения к другим страницам и не ухудшает производительность.
Внутристраничная очистка при HOT-обновлениях
============================================
Частный, но важный случай внутристраничной очистки представляет собой очистка при HOT-обновлениях.
Как и в прошлый раз, мы уже превысили порог fillfactor, так что следующее обновление должно привести к внутристраничной очистке. Но в этот раз в странице — цепочка обновлений. «Голова» этой HOT-цепочки всегда должна оставаться на своем месте, поскольку на нее ссылается индекс, а остальные указатели могут быть освобождены: известно, что на них нет ссылок извне.
Чтобы не трогать «голову», применяется двойная адресация: указатель, на который ссылается индекс — в данном случае (0,1), — получает статус «redirect», перенаправляющий на нужную версию строки.
```
=> UPDATE hot SET s = 'E';
=> SELECT * FROM heap_page('hot',0);
```
```
ctid | state | xmin | xmax | hhu | hot | t_ctid
-------+---------------+----------+-------+-----+-----+--------
(0,1) | redirect to 4 | | | | |
(0,2) | normal | 3990 | 0 (a) | | t | (0,2)
(0,3) | unused | | | | |
(0,4) | normal | 3989 (c) | 3990 | t | t | (0,2)
(4 rows)
```
Обратите внимание, что:
* версии (0,1), (0,2) и (0,3) были очищены,
* «головной» указатель (0,1) остался, но получил статут redirect,
* новая версия строки записана на место (0,2), поскольку на эту версию гарантированно не было ссылок из индексов и указатель был освобожден (unused).
Выполним обновление еще несколько раз:
```
=> UPDATE hot SET s = 'F';
=> UPDATE hot SET s = 'G';
=> SELECT * FROM heap_page('hot',0);
```
```
ctid | state | xmin | xmax | hhu | hot | t_ctid
-------+---------------+----------+----------+-----+-----+--------
(0,1) | redirect to 4 | | | | |
(0,2) | normal | 3990 (c) | 3991 (c) | t | t | (0,3)
(0,3) | normal | 3991 (c) | 3992 | t | t | (0,5)
(0,4) | normal | 3989 (c) | 3990 (c) | t | t | (0,2)
(0,5) | normal | 3992 | 0 (a) | | t | (0,5)
(5 rows)
```
Следующее обновление снова вызывает внутристраничную очистку:
```
=> UPDATE hot SET s = 'H';
=> SELECT * FROM heap_page('hot',0);
```
```
ctid | state | xmin | xmax | hhu | hot | t_ctid
-------+---------------+----------+-------+-----+-----+--------
(0,1) | redirect to 5 | | | | |
(0,2) | normal | 3993 | 0 (a) | | t | (0,2)
(0,3) | unused | | | | |
(0,4) | unused | | | | |
(0,5) | normal | 3992 (c) | 3993 | t | t | (0,2)
(5 rows)
```
Снова часть версий очищена, а указатель на «голову» соответствующим образом сдвинут.
Вывод: при частых обновлениях столбцов, не входящих в индексы, может иметь смысл уменьшить параметр fillfactor, чтобы зарезервировать некоторое место на странице для обновлений. Конечно, надо учитывать, что чем ниже fillfactor, тем больше остается незанятого места на странице и, соответственно, физический размер таблицы увеличивается.
Разрыв HOT-цепочки
==================
Если на странице не хватит свободного места, чтобы разместить новую версию строки, цепочка прервется. На версию строки, размещенную на другой странице, придется сделать отдельную ссылку из индекса.
Чтобы получить такую ситуацию, начнем параллельную транзакцию и построим в ней снимок данных.
```
| => BEGIN ISOLATION LEVEL REPEATABLE READ;
| => SELECT count(*) FROM hot;
```
```
| count
| -------
| 1
| (1 row)
```
Снимок не даст очистить версии строк на странице. Теперь выполняем обновление в первом сеансе:
```
=> UPDATE hot SET s = 'I';
=> UPDATE hot SET s = 'J';
=> UPDATE hot SET s = 'K';
=> SELECT * FROM heap_page('hot',0);
```
```
ctid | state | xmin | xmax | hhu | hot | t_ctid
-------+---------------+----------+----------+-----+-----+--------
(0,1) | redirect to 2 | | | | |
(0,2) | normal | 3993 (c) | 3994 (c) | t | t | (0,3)
(0,3) | normal | 3994 (c) | 3995 (c) | t | t | (0,4)
(0,4) | normal | 3995 (c) | 3996 | t | t | (0,5)
(0,5) | normal | 3996 | 0 (a) | | t | (0,5)
(5 rows)
```
При следующем обновлении места на странице уже не хватит, но внутристраничная очистка не сможет ничего освободить:
```
=> UPDATE hot SET s = 'L';
```
```
| => COMMIT; -- снимок больше не нужен
```
```
=> SELECT * FROM heap_page('hot',0);
```
```
ctid | state | xmin | xmax | hhu | hot | t_ctid
-------+---------------+----------+----------+-----+-----+--------
(0,1) | redirect to 2 | | | | |
(0,2) | normal | 3993 (c) | 3994 (c) | t | t | (0,3)
(0,3) | normal | 3994 (c) | 3995 (c) | t | t | (0,4)
(0,4) | normal | 3995 (c) | 3996 (c) | t | t | (0,5)
(0,5) | normal | 3996 (c) | 3997 | | t | (1,1)
(5 rows)
```
В версии (0,5) видим ссылку на (1,1), ведущую на страницу 1.
```
=> SELECT * FROM heap_page('hot',1);
```
```
ctid | state | xmin | xmax | hhu | hot | t_ctid
-------+--------+------+-------+-----+-----+--------
(1,1) | normal | 3997 | 0 (a) | | | (1,1)
(1 row)
```
Теперь в индексе — две строки, каждая из которых указывает на начало своей HOT-цепочки:
```
=> SELECT * FROM index_page('hot_id',1);
```
```
itemoffset | ctid
------------+-------
1 | (1,1)
2 | (0,1)
(2 rows)
```
> К сожалению, сведения о внутристраничной очистке и HOT-обновлениях практически отсутствуют в документации, и правду надо искать в исходном коде. Рекомендую начать с [README.HOT](https://git.postgresql.org/gitweb/?p=postgresql.git;a=blob;f=src/backend/access/heap/README.HOT;hb=HEAD).
>
>
[Продолжение](https://habr.com/ru/company/postgrespro/blog/452320/). | https://habr.com/ru/post/449704/ | null | ru | null |
# О том как забирать обратно музыку и видео с ВК средствами браузера Chrome, используя свое расширение
Добрый день уважаемые Хабровчане. Сегодня хочу поделиться с Вами кодами на Javascript для возможности перекачивания музыки и видео с ВК своими ручками на свой персональный компьютер. Ведь нетрудно себе представить, как записал клевый клип и музыку, потом закачал их туда, но на твоем компьютере все это добро куда то пропало… Что же, не беда! Мы выкачаем то, что по праву принадлежит нам обратно. Главное, что нам это наш браузер, да сайт позволяют, осталось — пораскинуть мозгами.
Для начала нам надо распарсить аудиофайлы… Итак, возьмемся за класс «area clear\_fix» и будем пихать в массив то, что принадлежит к классу «play\_new». Сначала присвоим в массиве стили, чтобы отловить положение элементов на странице (в последующем для отображения кнопочек рядышком). Потом получим ссылки из input и имя будущего файла из тега b. Потом нужно будет присваивать новым ссылочкам, которые мы будем создавать атрибут download.
```
function audio(){
var main_div=document.getElementsByClassName("area clear_fix");
for(var i=0;i
```
Тут как бы понятно должно быть, все… ну а чтобы отрезать всякий мусор после расширения файла мы применили:
\_a\_.href = \_mp3\_.substring(0, \_mp3\_.indexOf('.mp3') + 4);
В общем уже можно это запустить таким образом через интервал, конечно же если мы находимся на том самом сайте:
```
setInterval(function(){
if(window.location.href.indexOf('vk.com')>1) {
if(document.getElementsByClassName("area clear_fix").length!=0){
audio();
}
}
},1000);
```
Хорошо. Одна функция готова. Пора поведать и о том как скачать видеофайлы…
И снова крепко хватаемся за класс «video\_box\_wrap» и если данный элемент не содержит атрибута id с downloadvideo, и если нет IFRAME, который нам может подсунуть какой-нибудь ютуб, рутуб — то разбираем его.
```
function videovk(){
if(document.getElementsByClassName("video_box_wrap")[0] && !document.getElementById('downloadvideo') && document.getElementById('video_player').tagName!='IFRAME'){
var invideo=""; var obj = new Object(); var name=new Array(); var content=new Array();
var fl=encodeURI(unescape(document.getElementsByClassName("video_box_wrap")[0].innerHTML.split(" ")[8].split('"')[1].replace(/amp;/g,"")));
var flvars=fl.split("&");
for(var c=0;c<=flvars.length-1;c++){
name[c]=flvars[c].split("=")[0];
content[c]=flvars[c].split("=")[1];
}
for(var c2=0;c2<=name.length;c2++){
obj[name[c2]]=content[c2];
}
var countvid=0;
if(obj.url240){
countvid+=1;
var invideo=invideo+vv(obj.url240,'240',countvid,obj.md_title);
}
if(obj.url360){
countvid+=1;
var invideo=invideo+vv(obj.url360,'360',countvid,obj.md_title);
}
if(obj.url480){
countvid+=1;
var invideo=invideo+vv(obj.url480,'480',countvid,obj.md_title);
}
if(obj.url720){
countvid+=1;
var invideo=invideo+vv(obj.url720,'720',countvid,obj.md_title);
}
if(obj.cache240){
countvid+=1;
invideo=invideo+vv(obj.cache240,'240',countvid,obj.md_title);
}
if(obj.cache360){
countvid+=1;
invideo=invideo+vv(obj.cache360,'360',countvid,obj.md_title);
}
if(obj.cache480){
countvid+=1;
invideo=invideo+vv(obj.cache480,'480',countvid,obj.md_title);
}
if(obj.cache720){
countvid+=1;
invideo=invideo+vv(obj.cache720,'720',countvid,obj.md_title);
}
var videodownloader=document.createElement("div");
videodownloader.style.height="auto";videodownloader.style.width="auto";
videodownloader.id="downloadvideo";videodownloader.style.paddingBottom="5px";
videodownloader.innerHTML=invideo;
document.getElementById("mv_narrow").insertBefore(videodownloader, document.getElementById("mv_narrow").firstChild);
}
}
```
… из кода понятно что мы формируем ссылки на варианты видео разного формата и добавляем самостоятельно сформированные ссылочки с id=«downloadvideo» атрибутом download сразу к идентификатору mv\_narrow.
А дальше нам нужна функция vv для создания ссылок на страничке. Чтобы распознавались русские буквы нам понадобится функция utf8\_decode, а чтобы обрезать пробелы по краям функция trim.
```
function utf8_decode(utftext) {
var string = "";
var i = 0;
var c = c1 = c2 = 0;
while ( i < utftext.length ) {
c = utftext.charCodeAt(i);
if (c < 128) {
string += String.fromCharCode(c);
i++;
}
else if((c > 191) && (c < 224)) {
c2 = utftext.charCodeAt(i+1);
string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
i += 2;
}
else {
c2 = utftext.charCodeAt(i+1);
c3 = utftext.charCodeAt(i+2);
string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
i += 3;
}
}
return string;
}
function trim(str)
{
return str.replace(/^[\s]+/,"").replace(/[\s]+$/,"");
}
function vv(a,b,c,d){
if(c%2!=0){
var p1="";
var p2="";
}
if(c%2==0 ){
var p1="";
var p2="
";
}
return p1+"["+b+" ("+a.substr(-3)+")]("+a+" "Скачать: \"+utf8_decode(trim(decodeURIComponent(d)))+\"") "+p2;
}
```
Основная часть кода готова, осталось поправить интервал:
```
setInterval(function(){
if(window.location.href.indexOf('vk.com')>1) {
if(document.getElementById('video_player') && document.getElementById("mv_narrow")){
videovk();
}
if(document.getElementsByClassName("area clear_fix").length!=0){
audio();
}
}
},1000);
```
Все. когда код готов, и теперь нам нужен манифест, вот он:
```
{
"manifest_version":2,
"name":"Downloader",
"version":"1.0",
"description":"Downloader of mp3 files from vk.com and mail.ru.",
"permissions": [
"http://vk.com/*",
"tabs"
],
"content_scripts": [ {
"js": [ "main.js" ],
"matches": [ "http://vk.com/*", "http://*.vk.com/*", "https://vk.com/*", "https://*.vk.com/*" ],
"run_at": "document_end"
} ],
"content_security_policy": "script-src 'self' 'unsafe-eval'; object-src 'self'",
"browser_action": {
"default_title":"Downloader Extension"
}
}
```
В content\_scripts мы пишем что наш код с функциями будет храниться в файле main.js, который будет подгружаться после загрузки страницы, т. е. «run\_at»: «document\_end». | https://habr.com/ru/post/215381/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.