text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Паттерн «VIP слушатель»
Признаюсь честно, описание этого паттерна мне не встречалось, соответственно его название я выдумал. Если у кого есть информация о правильном названии, буду очень рад услышать. Паттерн не привязан к языку но в данной статье я буду использовать `C#`.
Картинка для привлечения внимания:
Итак представим себе систему состоящую из сервиса, который предоставляет другим частям системы отслеживать набор объектов. Это может быть сервис симуляции предоставляющий список симулируемых объектов или любой другой похожий.
Объекты порождаемые и уничтожаемые системой:
```
public interface IObject
{
}
```
Сервис, предоставляющий доступ к объектам:
```
public delegate void ServiceChangedHandle(IService sender, IObject item, bool injected);
public interface IService
{
IEnumerable Items { get; }
event ServiceChangedHandle OnServiceChanged;
}
```
Тем системам, которым необходимо работать с объектами, подписываются на событие, чтобы отслеживать появление новых объектов и исчезновение текущих.
Типичный пример слушателя:
```
public class Listener
{
public void Initialise()
{
foreach (var item in service.Items)
RegisterItem(item);
service.OnServiceChanged += OnServiceChanged;
}
public void Shutdown()
{
service.OnServiceChanged -= OnServiceChanged;
foreach (var item in service.Items)
UnregisterItem(item);
}
private void OnServiceChanged(IService sender, IObject item, bool injected)
{
if (injected)
RegisterItem(item);
else
UnregisterItem(item);
}
private void RegisterItem(IObject item)
{
...
}
private void UnregisterItem(IObject item)
{
...
}
private IService service;
}
```
При активации слушателя он обрабатывает все объекты которые уже присутствуют в сервисе а после этого подписывается на изменения списка объектов. При завершении работы слушателя необходимо произвести обратные действия.
При многопоточном программировании все усложняется, потому что между опросом и подпиской, список объектов может изменится. Сервис должен будет предоставить объект синхронизации а слушатель заблокирует изменение списка между обходом списка и подпиской.
Сервис с поддержкой многопоточности:
```
public interface IService
{
...
// Объект для синхронизации
object SyncRoot { get; }
}
```
Слушатель с поддержкой многопоточного сервиса (Внутренняя синхронизация опущенна):
```
public class Listener
{
public void Initialise()
{
// Добавляем синхронизацию
lock (service.SyncRoot)
{
foreach (var item in service.Items)
RegisterItem(item);
service.OnServiceChanged += OnServiceChanged;
}
}
public void Shutdown()
{
// Добавляем синхронизацию
lock (service.SyncRoot)
{
service.OnServiceChanged -= OnServiceChanged;
foreach (var item in service.Items)
UnregisterItem(item);
}
}
...
}
```
Можно немного упростить систему подписки, если гарантировать что в момент подписки и отписки в сервисе нет ни одного объекта. Такую гарантию дать сложно, особенно в системах где время появления сервисов не определенно.
Но можно эмулировать эту гарантию для каждого подписчика, в этом и суть паттерна. При подписке, сервис будет принудительно посылать событие появления объекта для всех уже существующих объектов а при отписке, посылать событие исчезновения. При этом слушатель упрощается, причем для многопоточного и однопоточного варианта он будет выглядеть одинаково.
Подписчик для многопоточного и однопоточного варианта сервиса (Внутренняя синхронизация опущена):
```
public class Listener
{
public void Initialise()
{
service.OnServiceChanged += OnServiceChanged;
}
public void Shutdown()
{
service.OnServiceChanged -= OnServiceChanged;
}
...
}
```
Реализации сервиса для однопоточного варианта:
```
public class Service : IService
{
...
public event ServiceChangedHandle OnServiceChanged
{
add
{
// Эмулируем добавление объектов для подписчика
foreach (var item in items)
value(this, item, true);
// Непосредственная подписка
eventHandle += value;
}
remove
{
// Непосредственная отписка
eventHandle -= value;
// Эмулируем исчезновение объектов
foreach (var item in items)
value(this, item, false);
}
}
private ServiceChangedHandle eventHandle;
private List items = new List();
}
```
Как и у любого паттерна у этого варианта слушателя есть свои плюсы, минусы и область применения.
Плюсы:
* Подписчики упрощаются, достаточно простой подписки и отписки
* Одинаковый код как для многопоточного так и для однопоточного варианта
Минусы:
* При использовании нужно знать эту особенность у сервиса, чтобы объекты не обрабатывать два раза
Из минусов и плюсов можно выделить область применения паттерна:
* Наличие небольшого количества сервисов и большого количества подписчиков
* Внутренний продукт компании или сугубо личный, предоставлять наружу такое поведение опасно
* Строгая дисциплина проектирования и разработки. Каждый разработчик должен знать о таком поведении и знать где конкретно используется этот паттерн
**Update1**
Некоторые пояснения:
В шарпе уже реализован паттерн “Наблюдатель”, вместо наблюдателя и наблюдаемого мы имеем событие и подписчиков.
VIP не синоним слова “один” а синоним слова “особый”. В данном случае все подписчики являются особыми, потому что наблюдаемый объект для каждого отдельного наблюдателя ведет себя особо. А именно, генерит события, которые наблюдатель мог пропустить или не дождаться.
Всем спасибо за внимание! | https://habr.com/ru/post/201908/ | null | ru | null |
# Как бороться с «просвечивающим» SELECT'ом в IE
*Проблема*
Стандартный `select`, оказавшись под непрозрачным дивом остается полностью виден в IE. Из-за этой его особенности, выпадающие меню, всплывающие окошки и прочие элементы, связанные с позиционированием дивов могут выглядеть крайне неаккуратно.
*Решения*
Есть несколько способов решения этой проблемы. Перечислю их от простого к сложному:
1. прячем `select`
2. `iframe` поверх `select`'а
3. собственные `select`'ы
*Подробнее*
*1. прячем `select`*
Самое простое решение — поставить селектам (всем или пересекающимся с дивом) css свойство `visibility: hidden;`
Разумеется искать все селекты и ставить каждому из них свойство не нужно. Достаточно определить css класс:
`.noselect select { visibility: hidden; }`
и добавить этот класс к области над которыми окажется див.
Стиль `display: none;` в этом случае не подходит — может «поползти» верстка страницы.
*2. `iframe` поверх `select`'а*
Пожалуй самое интересное решение. По совершенно непонятной для меня причине селекты в ИЕ не «пробиваются» сквозь `iframe`.
Т.е. если сначала разместить iframe а поверх него div — селекты будут вести себя, как во всех порядочных браузерах.
~~К сожалению это решение не подходит для полупрозрачных дивов.~~ (UPD: спасибо [beartamer](http://beartamer.habrahabr.ru/) и [vithar](http://vithar.habrahabr.ru/))
*3. собственные `select`'ы*
Нет селектов — нет проблемы. Т.е. вместо селектов можно использовать их имитацию.
Есть готовые скрипты, которые «на лету» заменяют все селекты на их аналог основанный на всплывающих дивах. Разумеется при этом наша проблема будет решена.
Однако есть пара замечаний. Во-первых далеко не все скрипты обеспечивают полную функциональность при имитации селектов. Во-вторых селекты будут иметь нестандартный вид, а это не всегда идет на пользу.
Если вам известны другие рецепты — буду очень за них признателен.
[оригинал в ЖЖ](http://abarmotik.livejournal.com/558.html) | https://habr.com/ru/post/21913/ | null | ru | null |
# Решение проблемы хранения музыки для Интернет-радио
Добрый день, %username%!
Как-то мы с компанией друзей решили сделать интернет радио, но как оказалось, выделяемого места на VPS недостаточно для большого архива музыки, более того покупка дополнительных гигабайтов — настоящий грабеж.
Я долго искал решение, как вдруг наткнулся на прекрасную статью [ableev](https://habr.com/ru/users/ableev/) [«Яндекс.Диск как файловая система»](http://habrahabr.ru/post/142067/). Меня посетила идея, почему бы не хранить музыку на Яндекс диске? Опустим здесь проблемы лицензирования и авторских прав — это совсем другая история, меня же интересует техническая часть. Как оказалось не всегда IceCast успевает подгружать музыку с Яндекс диска, что приводит к запинаниям и прерываниям в вещании, а это совсем не хорошо. Эта проблема меня зацепила, и я нашел решение — определять что играет в текущий момент на радио и заранее подгружать следующие треки, а проигранные треки с сервера удалять. Это порождает трафик, согласен, но на текущий момент VPS с безлимитным трафиком полно, а с безлимитным местом на дисках нет.
Так как из языков я худо-бедно владею C#, пришлось прибегнуть к mono, а также написать несколько вспомогательных скриптов на Python, PHP, bash.
Вспомогательные скрипты в студию!
**id3.py** получает при вызове аргументом трек, из которого берет теги и записывает их в текстовый файл:
**id3.py**
```
#!/usr/bin/env python
class Unbuffered(object):
def __init__(self, stream):
self.stream = stream
def write(self, data):
self.stream.write(data)
self.stream.flush()
def __getattr__(self, attr):
return getattr(self.stream, attr)
import eyeD3
import sys
import argparse
def createParser ():
parser = argparse.ArgumentParser()
parser.add_argument('-f', '--file')
return parser
if __name__ == '__main__':
parser = createParser()
namespace = parser.parse_args(sys.argv[1:])
tag = eyeD3.Tag()
tag.link(namespace.file)
sys.stdout = Unbuffered(sys.stdout)
s = tag.getArtist()+" - "+tag.getTitle()
f = open('tag.txt','w')
f.write(s)
f.close()
```
**getCurrent.php** парсит страничку IceCast с информацией о текущем треке и выдает название играющего трека.
**getCurrent.php**
```
php
error_reporting(0);
header("Content-Type: text/html; charset=UTF-8");
$file_name="http://localhost:8000/status.xsl?mount=/stream";
$r=fopen($file_name,'r');
$text=fread($r,10000);
fclose($r);
$mas=explode('<tr', $text);
$name = explode(':', $mas[3]);
$q = explode ('',$name[1]);
$q2 = explode (' ',$q[1]);
$rj = $q2[1];
if($rj == "0" or $rj == ""){
echo " Nonstop";
}else
{
$fl = file\_get\_contents('http://localhost:8000/status.xsl?mount=/stream');
function antara($string, $start, $end){
$string = " ".$string;
$ini = strpos($string,$start);
if ($ini == 0) return "";
$ini += strlen($start);
$len = strpos($string,$end,$ini) - $ini;
return substr($string,$ini,$len);
}
$stream = antara($fl," Stream Title: |\n "," |");
$description = antara($fl, " Stream Description: |\n ", " |");
$listeners = antara($fl, " Current Listeners: |\n ", " |");
$max = antara($fl, " Peak Listeners: |\n ", " |");
$song = antara($fl, " Current Song: |\n ", " |");
echo $song;
?>
|
```
Маленький скрипт на bash **isOnline.sh** проверяет запущен ли скрипт радио и информацию о статусе также пишет в текстовый файл.
**isOnline.sh**
```
#!/bin/bash
rm isOnline.txt
ps ax | grep -v grep | grep radio.sh > isOnline.txt
```
Скрипт радио liquidsoap **radio.sh** — собственно само радио.
**radio.sh**
```
#!/usr/bin/liquidsoap
# создаём переменные быстрого исправления в одном месте по необходимости
# базовая информация о выводимом потоке
out = output.icecast(
# хост с icecast
host = "127.0.0.1",
# его порт
port = 8000,
# логин
user = "source",
# и пароль
password = "password",
# название
name = "Radio Name",
# жанр
genre = "Various",
# ссылка на сайт
url = "http://www.host.local"
# кодировка
encoding = "UTF-8"
)
# включаем telnet-сервер
#set("server.telnet.bind_addr","127.0.0.1")
#set("server.telnet",true)
# _____________________________________
# Описание файловой структуры нашего радиосервера.
# Переменные можно не использовать, а писать сразу полные пути к плейлистам, но при изменении названия одной из папок, придётся править довольно много строк в конфигурации. Как показала практика, такой подход удобнее.
# абсолютный путь к рабочей директории
#wd = "/home/admin/radio"
# путь к папке с аудиофайлами
#pl = "#{wd}/collection"
# техническая папка
#tech = "#{wd}/technical"
# логи
set("log.file.append",true)
set("log.file",true)
set("log.file.path","/var/data/liquidsoap.log") # путь к файлу лога
set("log.level", 3) # уровень логирования
#set("buffering.kind","disk_manyfiles")
#set("decoding.buffer_length",30.)
#set("buffering.path","/tmp/radio")
# папка с информационными вставками
#promo_dir = "#{pl}/promo"
# папка с программами
#progr_dir = "#{pl}/programs"
# папка с изменяющимся эфиром
#ef = "#{pl}/efir"
# папки соответствующих эфиров
#ni = "#{ef}/night"
# папки с музыкой
mus_ni_dir = "loc.playlist.txt"
# папки с джинглами
jin_ni_dir = "/mnt/username.yadisk/RT/jingles"
#promo
promo_dir = "/mnt/username.yadisk/RT/promo"
mus_ni = playlist (reload = 86400, "#{mus_ni_dir}", mode = "normal")
jin_ni = playlist (reload = 86400, "#{jin_ni_dir}", mode = "normal")
promo = playlist (reload = 86400, "#{promo_dir}")
ni = rotate (weights = [1, 10, 1, 5], [jin_ni, mus_ni, promo, mus_ni])
radio = switch (track_sensitive = true, [
#({ (2w16h10m - 2w16h20m) or (3w14h - 3w14h5m) or (4w16h - 4w16h5m)}, spekt), ({ (3w23h - 3w23h5m) or (4w10h - 4w10h5m)}, pozdr), ({ (2w18h - 2w18h5m) or
#(3w18h - 3w18h5m)}, xmas_trad), ({ (6w14h - 6w14h10m) or (6w18h - 6w18h10m)}, prog1), ({ (6w0h - 7w18h)}, xmas_mus_prog),
({ 1w0h - 7w23h59m }, ni)
])
radio = mksafe(radio)
radio = crossfade(start_next=2., fade_out=2., fade_in=2., radio)
out(
%mp3(bitrate = 128, id3v2 = true),
description = "Radio Name 128kbps",
mount = "stream",
mksafe(radio)
)
```
Генератор списка воспроизведения **generator.sh** создает список файлов на смонтированном диске, перемешивает список и записывает в текстовый файл. Это скрипт замечателен тем, что здесь можно добавить много дисков и собрать все в 1 плейлист.
**generator.sh**
```
#!/bin/sh
find "/mnt/username.yadisk/RT/music" -name '*.mp3' -print > "disk.playlist.txt"
shuf -n 500 "disk.playlist.txt" -o "disk.playlist.txt"
sed 's/\/mnt\/username.yadisk\/RT\/music/\/home\/admin\/rt\/tmp/g' disk.playlist.txt > loc.playlist.txt
```
Теперь осталось написать управляющий скрипт, который будет следить, не упал ли скрипт радио, запускать его в случае падения, следить за плейлистом, подгружать и удалять треки.
**radio\_control.cs**
```
using System;
using System.Collections.Generic;
using System.IO;
using System.Collections;
using System.Diagnostics;
namespace radio_control
{
class song
{
string filename;
string tagname;
string prepared;
System.Diagnostics.Process getTag;
public song()
{
getTag = new System.Diagnostics.Process();
getTag.EnableRaisingEvents = false;
getTag.StartInfo.FileName = "./id3.py";
}
public string FileName
{
get { return filename; }
set { filename = value; }
}
public string Tag
{
get { return tagname; }
set { tagname = value; }
}
public string Prepared
{
get { return prepared; }
set { prepared = value; }
}
///
/// Загружает файл во временную папку, и записывает путь к файлу в поле Prepared
///
///
public void Prepare(string tmpDir)
{
File.Copy(FileName, tmpDir+Path.GetFileName(FileName), true);
Prepared = tmpDir + Path.GetFileName(FileName);
Tag = _getTag().Replace(Environment.NewLine,"");
}
//удаляет файл из временной директории
public void Destroy()
{
File.Delete(Prepared);
}
//Получаем тэги подготовленного файла
string _getTag()
{
getTag.StartInfo.Arguments = "-f " + this.Prepared;
getTag.Start();
getTag.WaitForExit();
StreamReader str = new StreamReader("tag.txt");
string tag = str.ReadToEnd();
str.Close();
return tag;
}
}
class Program
{
static void Main(string[] args)
{
//счетчик, чтобы определить какой элемент списка подгружать
int count = 0;
string pl_file = "/home/admin/rt/disk.playlist.txt"; //расположение плейлиста
string tmpDir = "/home/admin/rt/tmp/"; //расположение директории для временных файлов
string newplTime = "23:30";
//готовим список объектов песен
List songs = new List();
//Процесс получения текущего играющего трека с icecast
System.Diagnostics.Process getCurrent = new System.Diagnostics.Process();
getCurrent.EnableRaisingEvents = false;
getCurrent.StartInfo.RedirectStandardOutput = true;
getCurrent.StartInfo.FileName = "/usr/bin/php";
getCurrent.StartInfo.UseShellExecute = false;
getCurrent.StartInfo.Arguments = "getCurrent.php";
//Процесс проверки, запущен ли скрипт радио
System.Diagnostics.Process isRadio = new System.Diagnostics.Process();
isRadio.EnableRaisingEvents = false;
getCurrent.StartInfo.UseShellExecute = false;
getCurrent.StartInfo.RedirectStandardOutput = true;
isRadio.StartInfo.FileName = "isOnline.sh";
//Процесс запуска радио
System.Diagnostics.Process radio = new System.Diagnostics.Process();
radio.EnableRaisingEvents = false;
getCurrent.StartInfo.UseShellExecute = false;
getCurrent.StartInfo.RedirectStandardOutput = true;
radio.StartInfo.FileName = "screen";
radio.StartInfo.Arguments = "-dmS radio liquidsoap --verbose radiotera.sh";
//Процесс прибития скрина radio
System.Diagnostics.Process killRadio = new System.Diagnostics.Process();
killRadio.EnableRaisingEvents = false;
getCurrent.StartInfo.UseShellExecute = false;
getCurrent.StartInfo.RedirectStandardOutput = true;
killRadio.StartInfo.FileName = "screen";
killRadio.StartInfo.Arguments = "-X -S radio quit";
//Процесс запуска генератора плейлиста
Process genPl = new Process();
genPl.EnableRaisingEvents = false;
genPl.StartInfo.UseShellExecute = false;
genPl.StartInfo.FileName = "generator.sh";
//создаем очередь из треков, очередь - это стек типа first in - first out
Queue queue = new Queue(3);
//загружаем в плейлист список файлов
string[] playlist = (System.IO.File.ReadAllLines(pl\_file));
log("Loading playlist");
//определяем ID3 теги файлов и заполняем настоящий плейлист
song sng;
foreach (string value in playlist)
{
sng = new song();
sng.FileName = value;
songs.Add(sng);
}
log("Playlist loaded.", ConsoleColor.Green);
//подготавливаем первые 3 трека и увеличиваем счетчик
songs[0].Prepare(tmpDir);
count++;
songs[1].Prepare(tmpDir);
count++;
songs[2].Prepare(tmpDir);
count++;
//добавляем их в очередь
queue.Enqueue(songs[0]);
queue.Enqueue(songs[1]);
queue.Enqueue(songs[2]);
log("First 3 tracks prepared:\n"+songs[0].Tag+"\n"+songs[1].Tag+"\n"+songs[2].Tag, ConsoleColor.Green);
//основной цикл программы
song tmp = new song();
StreamReader rdr;
string online = "";
while (true)
{
log("Check time to change playlist"); //проверяем время изменения плейлиста
if (DateTime.Now.ToString("HH:mm") == newplTime)
{
log("Its time to change playlist!", ConsoleColor.Red);
genPl.Start(); //генерируем плейлист
genPl.WaitForExit();
log("Playlist generated", ConsoleColor.Green);
log("Loading playlist");
playlist = (System.IO.File.ReadAllLines(pl\_file));
songs.Clear();
foreach (string value in playlist) //загружаем плейлист
{
sng = new song();
sng.FileName = value;
songs.Add(sng);
}
log("Playlist loaded", ConsoleColor.Green);
}
log("Check the availability of radio");
isRadio.Start();
isRadio.WaitForExit();
rdr = new StreamReader("isOnline.txt");
online=rdr.ReadToEnd();
rdr.Close();
//Включено ли радио?
if (online == "")
{
log("Radio is offline!\nClearing screen", ConsoleColor.Red);
killRadio.Start();
killRadio.WaitForExit();
log("Starting the radio");
radio.Start();
log("Waiting for 10 seconds");
System.Threading.Thread.Sleep(10000);
}
log("Get current song"); //получаем текущий трек
getCurrent.Start();
getCurrent.WaitForExit();
string curr = getCurrent.StandardOutput.ReadToEnd();
if (curr == "") continue;
//получаем первый трек очереди
tmp = new song();
tmp = (song)queue.Peek();
//проверяем, этот ли трек сейчас играет
log("Now playing: " + curr, ConsoleColor.Cyan);
log("Checking queue tag: "+tmp.Tag, ConsoleColor.Cyan);
if (tmp.Tag != curr)
{
//если играет не он, но играет джингл — ничего не делаем.
//Задавайте своим джинглам одинаковые тэги и впишите их в проверку здесь
if ((curr == "Radio TERA - Radio TERA") || (curr=="Unknown") || (curr=="NonstopS"))
{
log("Now playing radio jingle, move on to the next iteration");
continue;
}
log("The current track is different from the queue!!!\nMove the queue", ConsoleColor.Red);
//если все таки трек уже закончился, то убираем трек из очереди
queue.Dequeue();
log("Dequene track with tag "+tmp.Tag);
//удаляем трек из временной папки
log("Remove the track ended");
tmp.Destroy();
//копируем следующий трек во временную папку
log("Prepare next track");
songs[count].Prepare(tmpDir);
//добавляем его в очередь
log("Adding it to queue "+songs[count].Tag);
queue.Enqueue(songs[count]);
//увеличиваем счетчик
count++;
log("Count now: " + count.ToString());
//если счетчик превышает количество песен, значит плейлист закончился и пора играть все сначала
if (count > songs.Count - 1)
{
count = 0;
}
}
//висим 30 секунд
System.Threading.Thread.Sleep(30000);
}
}
static void log(string str)
{
Console.WriteLine(str);
}
static void log(string str, ConsoleColor frcolor)
{
Console.ForegroundColor = frcolor;
Console.WriteLine(str);
Console.ForegroundColor=ConsoleColor.White;
}
}
}
```
Я прошу прощения за свой быдло код, все это можно было написать в пределах одного скрипта, но я хотел решить задачу быстрее и использовал для разных подзадач те инструменты, которыми владел.
Для нормальной работы вам понадобятся:
* mono
* liquidsoap
* screen
* IceCast
* davfs2
* php
* eyeD3 для Python
Запускается система через radio\_control.cs. Все. Дальше он сам запустит радио, сгенерирует плейлист, подгрузит музыку и при этом будет писать в терминал, что он делает.
Радио к сожалению мы закрыли, но мне очень хотелось, чтобы мои труды не пропали напрасно, надеюсь, кому-нибудь помог. | https://habr.com/ru/post/270415/ | null | ru | null |
# OpenStack — разворачиваем «руками» Kilo
Привет всем Хабралюдям!
В прошлой [статье](http://habrahabr.ru/post/261715/), я рассказывал о том, как можно быстро развернуть тестовую среду при помощи DevStack. В этой публикации я расскажу как развернуть своё «облако» OpenStack на двух машинах (Controller, Compute) в комплектации:
* Keystone
* Glance
* Nova
* Neutron
* Cinder
* Horizon
В общем-то эта система позволит нам запускать множество виртуальных машин (сколько позволит памяти и CPU на *compute*), создавать виртуальные сети, создавать виртуальные диски и подключать их к VM, ну и конечно управлять всем этим через удобный дашборд.
Осторожно! Много «портянок» со списком команд и конфигами!
Сразу скажу:
* Теоретически, я мог забыть что-то дописать или недоправить в конфигах, забыть, что нужно перезапустить какой-то сервис или ещё что-то.
* Публикация не клонирует, но берёт свои корни из официальной документации, которая есть [здесь](http://docs.openstack.org/kilo/install-guide/install/apt/content/) (*англ.*)
* Цель написания всего этого, чтобы был какой-то более-менее читабельный ман по OpenStack на русском языке. Не претендую, что получилось это у меня, но надеюсь это побудит кого-то сделать лучше. Так же, готов принять во внимание комментарии о необходимых правках публикации, дабы она стала более удобочитабельной.
Не надо бездумно «копипастить». Это, конечно, поможет установить OpenStack-среду по данному руководству, но не научит использовать это знание в полевых условиях.
##### **Что будем использовать?**
* Controller *i3-540/8Gb/2x120Gb + 2x500Gb/2NIC*
* Compute *i7-2600/32Gb/2x500Gb/1NIC*
ОС: *Ubuntu 14.04* (Можно использовать CentOS, но руководство будет основано на Ubuntu).
Редакция OpenStack: *Kilo*
##### **Подготовка**
###### Сеть
В оригинальном руководстве используется 4 сети:
Management — 10.0.0.0/24 — VLAN 10
Tunnel — 10.0.1.0/24 — VLAN 11
Storage — 10.0.2.0/24 — VLAN 12
External — 192.168.1.0/24
External-сеть в нашем случае смотрит куда-нибудь в домашнюю сеть, но по большому счёту этот интерфейс может смотреть и во «всемирную паутину» — всё зависит от того, для чего разворачиваете облако.
Будет очень неплохо иметь работоспособный dns-server. Я использовал dnsmasq.
```
# cat /etc/hosts
10.0.0.11 controller
10.0.0.31 compute1
```
Настраиваем интерфейсы
**на контроллере:**
```
# cat /etc/network/interfaces
auto p2p1.10
iface p2p1.10 inet static
address 10.0.0.11
netmask 255.255.255.0
gateway 10.0.0.1
dns-nameservers 10.0.0.1
auto p2p1.11
iface p2p1.11 inet static
address 10.0.1.11
netmask 255.255.255.0
auto p2p1.12
iface p2p1.12 inet static
address 10.0.2.11
netmask 255.255.255.0
# Интерфейс для внешней сети
auto p3p1
iface p3p1 inet manual
up ip link set dev $IFACE up
down ip link set dev $IFACE down
```
**на вычислительном узле:**
```
# cat /etc/network/interfaces
auto p2p1.10
iface p2p1.10 inet static
address 10.0.0.31
netmask 255.255.255.0
gateway 10.0.0.1
dns-nameservers 10.0.0.1
auto p2p1.11
iface p2p1.11 inet static
address 10.0.1.31
netmask 255.255.255.0
auto p2p1.12
iface p2p1.12 inet static
address 10.0.2.31
netmask 255.255.255.0
```
Проверяем, чтобы обе машины видели друг друга и ходили в сеть.
###### NTP
На контроллере:
```
# apt-get install ntp -y
# cat /etc/ntp.conf
server ntp.oceantelecom.ru iburst
restrict -4 default kod notrap nomodify
restrict -6 default kod notrap nomodify
# service ntp stop
# ntpdate ntp.oceantelecom.ru
# service ntp start
```
На вычислительной ноде:
```
# apt-get install ntp -y
# cat /etc/ntp.conf
server controller iburst
# service ntp stop
# ntpdate controller
# service ntp start
```
###### Репозиторий Kilo
```
# apt-get install ubuntu-cloud-keyring
# echo "deb http://ubuntu-cloud.archive.canonical.com/ubuntu" "trusty-updates/kilo main" > /etc/apt/sources.list.d/cloudarchive-kilo.list
```
Kilo довольно молодой выпуск — апрель 2015 года. Больше всего в этом релизе мне понравился русский язык в интерфейсе Horizon.
Более подробно можно почитать [тут](https://wiki.openstack.org/wiki/ReleaseNotes/Kilo).
Обновляемся:
```
# apt-get update && apt-get dist-upgrade -y
```
###### SQL + RabbitMQ
В роли SQL сервера может быть MySQL, PostgreSQL, Oracle или любой другой, который поддерживается SQLAlchemy. Мы будем устанавливать MariaDB как и в официальном мануале.
```
# apt-get install mariadb-server python-mysqldb -y
# cat /etc/mysql/conf.d/mysqld_openstack.cnf
[mysqld]
bind-address = 10.0.0.11
default-storage-engine = innodb
innodb_file_per_table
collation-server = utf8_general_ci
init-connect = 'SET NAMES utf8'
character-set-server = utf8
# service mysql restart
# mysql_secure_installation
```
Если есть лишние HDD с хорошей производительностью, то файлы БД можно положить на него и это не будет лишним, если вы планируете развивать стенд вычислительными нодами.
Ну и конечно же RabbitMQ:
```
# apt-get install rabbitmq-server
# rabbitmq-plugins enable rabbitmq_management
# service rabbitmq-server restart
```
Мы устанавливаем рээбита и запускаем административную WebGUI, для удобства слежения за очередями.
Создаём пользователя и устанавливаем права ему:
```
rabbitmqctl add_user openstack RABBIT_PASS
rabbitmqctl set_permissions openstack ".*" ".*" ".*"
```
##### **Keystone**
Keystone — центр авторизации для OpenStack. Все авторизации проходят через него. Данные Keystone хранит в SQL-БД, но использует так же и memcache.
Подготовим БД:
```
# mysql -u root -p
CREATE DATABASE keystone;
GRANT ALL PRIVILEGES ON keystone.* TO 'keystone'@'localhost' IDENTIFIED BY 'KEYSTONE_DBPASS';
GRANT ALL PRIVILEGES ON keystone.* TO 'keystone'@'%' IDENTIFIED BY 'KEYSTONE_DBPASS';
```
Естественно, не забудьте подставить свой пароль, как и везде.
Отключаем автозагрузку keystone сервиса и устанавливаем все необходимые компоненты:
```
# echo "manual" > /etc/init/keystone.override
# apt-get install keystone python-openstackclient apache2 libapache2-mod-wsgi memcached python-memcache
```
В конфиге */etc/keystone/keystone.conf* прописываем следующие строки:
```
[DEFAULT]
admin_token = ADMIN_TOKEN
[database]
connection = mysql://keystone:KEYSTONE_DBPASS@controller/keystone
[memcache]
servers = localhost:11211
[token]
provider = keystone.token.providers.uuid.Provider
driver = keystone.token.persistence.backends.memcache.Token
[revoke]
driver = keystone.contrib.revoke.backends.sql.Revoke
```
*ADMIN\_TOKEN* генерим при помощи "*openssl rand -hex 16*".
Синхронизируем локальную БД с SQL сервером
```
# su -s /bin/sh -c "keystone-manage db_sync" keystone
```
Настраиваем апач:
**портянка**
```
# cat /etc/apache2/apache2.conf
...
ServerName controller
...
# cat /etc/apache2/sites-available/wsgi-keystone.conf
Listen 5000
Listen 35357
WSGIDaemonProcess keystone-public processes=5 threads=1 user=keystone display-name=%{GROUP}
WSGIProcessGroup keystone-public
WSGIScriptAlias / /var/www/cgi-bin/keystone/main
WSGIApplicationGroup %{GLOBAL}
WSGIPassAuthorization On
= 2.4>
ErrorLogFormat "%{cu}t %M"
LogLevel info
ErrorLog /var/log/apache2/keystone-error.log
CustomLog /var/log/apache2/keystone-access.log combined
WSGIDaemonProcess keystone-admin processes=5 threads=1 user=keystone display-name=%{GROUP}
WSGIProcessGroup keystone-admin
WSGIScriptAlias / /var/www/cgi-bin/keystone/admin
WSGIApplicationGroup %{GLOBAL}
WSGIPassAuthorization On
= 2.4>
ErrorLogFormat "%{cu}t %M"
LogLevel info
ErrorLog /var/log/apache2/keystone-error.log
CustomLog /var/log/apache2/keystone-access.log combined
# ln -s /etc/apache2/sites-available/wsgi-keystone.conf /etc/apache2/sites-enabled
# mkdir -p /var/www/cgi-bin/keystone
# curl http://git.openstack.org/cgit/openstack/keystone/plain/httpd/keystone.py?h=stable/kilo | tee /var/www/cgi-bin/keystone/main /var/www/cgi-bin/keystone/admin
# chown -R keystone:keystone /var/www/cgi-bin/keystone
# chmod 755 /var/www/cgi-bin/keystone/*
# service apache2 restart
# rm -f /var/lib/keystone/keystone.db
```
Мы меняем *ServerName* на имя нашего контроллера.
Рабочие скрипты мы берём с репозитория openstack.
Настроим endpoint`ы. Вообщем-то именно благодаря endpoint`ам openstack будет знать где и какой сервис работает.
Добавим переменные окружения, для того чтобы не указывать их каждый раз в параметрах keystone:
```
# export OS_TOKEN=ADMIN_TOKEN
# export OS_URL=http://controller:35357/v2.0
```
Теперь создаём сервис:
```
# openstack service create --name keystone --description "OpenStack Identity" identity
```
Ну и создаём API endpoint:
```
# openstack endpoint create --publicurl http://controller:5000/v2.0 --internalurl http://controller:5000/v2.0 --adminurl http://controller:35357/v2.0 --region RegionOne identity
```
*RegionOne* можно поменять на любое удобочитаемое имя. Я буду использовать его, чтобы не «заморачиваться».
Создаём проекты, пользователей и роли.
Будем продолжать делать по официальному ману, так что всё так же: админ и демо
```
# openstack project create --description "Admin Project" admin
# openstack user create --password-prompt admin
# openstack role create admin
# openstack role add --project admin --user admin admin
```
Пароль для админа придумайте сами. По порядку: создали проект «Admin Project», пользователя и роль admin, и соединяем проект и пользователя с ролью.
Теперь создаём проект*service*:
```
# openstack project create --description "Service Project" service
```
По аналогии с admin`ом создаём demo:
```
# openstack project create --description "Demo Project" demo
# openstack user create --password-prompt demo
# openstack role create user
# openstack role add --project demo --user demo user
```
Создадим скрипты окружения:
**скрипты**
```
# cat admin-openrc.sh
export OS_PROJECT_DOMAIN_ID=default
export OS_USER_DOMAIN_ID=default
export OS_PROJECT_NAME=admin
export OS_TENANT_NAME=admin
export OS_USERNAME=admin
export OS_PASSWORD=ADMIN_PASS
export OS_AUTH_URL=http://controller:35357/v3
export OS_IMAGE_API_VERSION=2
export OS_VOLUME_API_VERSION=2
# cat demo-openrc.sh
export OS_PROJECT_DOMAIN_ID=default
export OS_USER_DOMAIN_ID=default
export OS_PROJECT_NAME=demo
export OS_TENANT_NAME=demo
export OS_USERNAME=demo
export OS_PASSWORD=DEMO_PASS
export OS_AUTH_URL=http://controller:5000/v3
export OS_IMAGE_API_VERSION=2
export OS_VOLUME_API_VERSION=2
```
Собственно:
```
# source admin-openrc.sh
```
На этом настройка сервиса *keystone* закончена.
##### **Glance**
Glance — это инструмент OpenStack для хранения шаблонов (образов) виртуальных машин. Образы могут храниться в Swift, в собственном хранилище Glance`а, но и где-то ещё — главное чтобы этот образ можно было получить по http.
Начнём как всегда с *mysql*:
```
# mysql -u root -p
CREATE DATABASE glance;
GRANT ALL PRIVILEGES ON glance.* TO 'glance'@'localhost' IDENTIFIED BY 'GLANCE_DBPASS';
GRANT ALL PRIVILEGES ON glance.* TO 'glance'@'%' IDENTIFIED BY 'GLANCE_DBPASS';
```
Создадим в *keystone* информацию о будущем сервисе:
```
# openstack user create --password-prompt glance
# openstack role add --project service --user glance admin
# openstack service create --name glance --description "OpenStack Image service" image
# openstack endpoint create --publicurl http://controller:9292 --internalurl http://controller:9292 --adminurl http://controller:9292 --region RegionOne image
```
Мы создаём пользователя *glance* и подключаем его к роли *admin*, т.к. все сервисы будут работать именно от этой роли, мы создаём сервис *glance*, задаём endpoint.
Теперь приступим к установке:
```
# apt-get install glance python-glanceclient
```
и настройке:
**настройка**
```
# cat /etc/glance/glance-api.conf
[DEFAULT]
...
notification_driver = noop
[database]
connection = mysql://glance:GLANCE_DBPASS@controller/glance
[keystone_authtoken]
auth_uri = http://controller:5000
auth_url = http://controller:35357
auth_plugin = password
project_domain_id = default
user_domain_id = default
project_name = service
username = glance
password = GLANCE_PASS
[paste_deploy]
flavor = keystone
[glance_store]
default_store = file
filesystem_store_datadir = /var/lib/glance/images/
```
Что бы ни было в секции *[keystone\_authtoken]* — это нужно удалить. GLANCE\_PASS — пароль от пользователя glance в keystone. *filesystem\_store\_datadir* это путь к хранилищу, где будут лежать наши образы. Рекомендую подмонтировать к этой директории или рейд-массив или надёжное сетевое хранилище, чтобы случайно не потерять все наши образы из-за отказа диска.
В */etc/glance/glance-registry.conf* дублируем ту же информацию из секций *database, keystone\_authtoken, paste\_deploy, DEFAULT*.
Синхронизируем БД:
```
# su -s /bin/sh -c "glance-manage db_sync" glance
```
Перезапускаем сервисы и удаляем локальную БД:
```
# service glance-registry restart
# service glance-api restart
# rm -f /var/lib/glance/glance.sqlite
```
В официальном мануале загружается *cirros*, который в общем-то нам не нужен, так что мы загрузим образ Ubuntu:
```
# mkdir /tmp/images
# wget -P /tmp/images http://cloud-images.ubuntu.com/releases/14.04.2/release/ubuntu-14.04-server-cloudimg-amd64-disk1.img
# glance image-create --name "Ubuntu-Server-14.04.02-x86_64" --file /tmp/images/ubuntu-14.04-server-cloudimg-amd64-disk1.img --disk-format qcow2 --container-format bare --visibility public --progress
# rm -r /tmp/images
```
Можно сразу залить все нужные нам образы, но думаю дождёмся момента, когда у нас появится Dashboard.
Целом — наш сервис Glance готов.
##### **Nova**
Nova — основная часть IaaS в OpenStack. Собственно благодаря Nova создаются виртуальные машины автоматически. Nova может взаимодействовать с KVM, Xen, Hyper-V, VMware и кажется Ironic (честно говоря не совсем понимаю как это работает). Мы будем использовать KVM, для других гипервизоров конфиги будут отличаться.
###### Контроллер
Опять начинаем с БД:
```
# mysql -u root -p
CREATE DATABASE nova;
GRANT ALL PRIVILEGES ON nova.* TO 'nova'@'localhost' IDENTIFIED BY 'NOVA_DBPASS';
GRANT ALL PRIVILEGES ON nova.* TO 'nova'@'%' IDENTIFIED BY 'NOVA_DBPASS';
```
Добавляем информацию в keystone:
```
# openstack user create --password-prompt nova
# openstack role add --project service --user nova admin
# openstack service create --name nova --description "OpenStack Compute" compute
# openstack endpoint create --publicurl http://controller:8774/v2/%\(tenant_id\)s --internalurl http://controller:8774/v2/%\(tenant_id\)s --adminurl http://controller:8774/v2/%\(tenant_id\)s --region RegionOne compute
```
Устанавливаем необходимые пакеты:
```
# apt-get install nova-api nova-cert nova-conductor nova-consoleauth nova-novncproxy nova-scheduler python-novaclient
```
**/etc/nova/nova.conf**
```
[DEFAULT]
...
rpc_backend = rabbit
auth_strategy = keystone
my_ip = 10.0.0.11
vncserver_listen = 10.0.0.11
vncserver_proxyclient_address = 10.0.0.11
[database]
connection = mysql://nova:NOVA_DBPASS@controller/nova
[oslo_messaging_rabbit]
rabbit_host = controller
rabbit_userid = openstack
rabbit_password = RABBIT_PASS
[keystone_authtoken]
auth_uri = http://controller:5000
auth_url = http://controller:35357
auth_plugin = password
project_domain_id = default
user_domain_id = default
project_name = service
username = nova
password = NOVA_PASS
[glance]
host = controller
[oslo_concurrency]
lock_path = /var/lib/nova/tmp
```
Синхронизируем БД, перезапускаем сервисы и удаляем локальную БД.
```
# su -s /bin/sh -c "nova-manage db sync" nova
# service nova-api restart
# service nova-cert restart
# service nova-consoleauth restart
# service nova-scheduler restart
# service nova-conductor restart
# service nova-novncproxy restart
# rm -f /var/lib/nova/nova.sqlite
```
###### Вычислительный узел
Теперь мы наконец начнём работать с вычислительным узлом. Все описанные действия справедливы для каждого вычислительного узла в нашей системе.
```
# apt-get install nova-compute sysfsutils
```
**/etc/nova/nova.conf**
```
[DEFAULT]
...
verbose = True
rpc_backend = rabbit
auth_strategy = keystone
my_ip = 10.0.0.31 #MANAGEMENT_INTERFACE_IP_ADDRESS
vnc_enabled = True
vncserver_listen = 0.0.0.0
vncserver_proxyclient_address = 10.0.0.31 #MANAGEMENT_INTERFACE_IP_ADDRESS
novncproxy_base_url = http://controller:6080/vnc_auto.html
[oslo_messaging_rabbit]
rabbit_host = controller
rabbit_userid = openstack
rabbit_password = RABBIT_PASS
[keystone_authtoken]
auth_uri = http://controller:5000
auth_url = http://controller:35357
auth_plugin = password
project_domain_id = default
user_domain_id = default
project_name = service
username = nova
password = NOVA_PASS
[glance]
host = controller
[oslo_concurrency]
lock_path = /var/lib/nova/tmp
[libvirt]
virt_type = kvm
```
*MANAGEMENT\_INTERFACE\_IP\_ADDRESS* это адрес вычислительного узла из VLAN 10.
В *novncproxy\_base\_url* controller должен соответствовать тому адресу, через который будет возможность обратиться через Web-browser. Иначе вы не сможете воспользоваться vnc-консолью из Horizon.
Перезапускаем сервис и удаляем локальную копию БД:
```
# service nova-compute restart
# rm -f /var/lib/nova/nova.sqlite
```
Проверяем всё ли правильно работает:
```
# nova service-list
+----+------------------+------------+----------+---------+-------+----------------------------+-----------------+
| Id | Binary | Host | Zone | Status | State | Updated_at | Disabled Reason |
+----+------------------+------------+----------+---------+-------+----------------------------+-----------------+
| 1 | nova-conductor | controller | internal | enabled | up | 2014-09-16T23:54:02.000000 | - |
| 2 | nova-consoleauth | controller | internal | enabled | up | 2014-09-16T23:54:04.000000 | - |
| 3 | nova-scheduler | controller | internal | enabled | up | 2014-09-16T23:54:07.000000 | - |
| 4 | nova-cert | controller | internal | enabled | up | 2014-09-16T23:54:00.000000 | - |
| 5 | nova-compute | compute1 | nova | enabled | up | 2014-09-16T23:54:06.000000 | - |
+----+------------------+------------+----------+---------+-------+----------------------------+-----------------+
```
5ая строчка говорит о том, что мы всё правильно сделали.
Мы сделали самое главное — теперь у нас есть IaaS.
##### **Neutron**
Neutron это сервис предоставляющий сеть как услуга (NaaS). Вообще официальная документация немного другое определение даёт, но так думаю будет понятнее. Nova-networking объявлен как устаревший в новых версиях OpenStack, поэтому его мы использовать не будем. Да и функционал у neutron значительно шире.
###### Контроллер
Мы устанавливаем ядро сети на контроллере, хотя в мануале используется 3я нода. Если вычислительных нод будет достаточно много (>10) и/или сетевая нагрузка будет достаточно высокая, то лучше вынести Network-сервер на отдельную ноду.
Как всегда начнём с БД
```
# mysql -u root -p
CREATE DATABASE neutron;
GRANT ALL PRIVILEGES ON neutron.* TO 'neutron'@'localhost' IDENTIFIED BY 'NEUTRON_DBPASS';
GRANT ALL PRIVILEGES ON neutron.* TO 'neutron'@'%' IDENTIFIED BY 'NEUTRON_DBPASS';
```
Keystone:
```
# openstack user create --password-prompt neutron
# openstack role add --project service --user neutron admin
# openstack service create --name neutron --description "OpenStack Networking" network
# openstack endpoint create --publicurl http://controller:9696 --adminurl http://controller:9696 --internalurl http://controller:9696 --region RegionOne network
```
Устанавливаем необходимые компоненты:
```
# apt-get install neutron-server neutron-plugin-ml2 python-neutronclient neutron-plugin-openvswitch-agent neutron-l3-agent neutron-dhcp-agent neutron-metadata-agent
```
Так же необходимо подправить */etc/sysctl.conf*
```
# cat /etc/sysctl.conf
net.ipv4.ip_forward=1
net.ipv4.conf.all.rp_filter=0
net.ipv4.conf.default.rp_filter=0
# sysctl -p
```
**/etc/neutron/neutron.conf**
```
[DEFAULT]
...
rpc_backend = rabbit
auth_strategy = keystone
core_plugin = ml2
service_plugins = router
allow_overlapping_ips = True
notify_nova_on_port_status_changes = True
notify_nova_on_port_data_changes = True
nova_url = http://controller:8774/v2
[oslo_messaging_rabbit]
rabbit_host = controller
rabbit_userid = openstack
rabbit_password = RABBIT_PASS
[database]
connection = mysql://neutron:NEUTRON_DBPASS@controller/neutron
[keystone_authtoken]
auth_uri = http://controller:5000
auth_url = http://controller:35357
auth_plugin = password
project_domain_id = default
user_domain_id = default
project_name = service
username = neutron
password = NEUTRON_PASS
[nova]
auth_url = http://controller:35357
auth_plugin = password
project_domain_id = default
user_domain_id = default
region_name = RegionOne
project_name = service
username = nova
password = NOVA_PASS
```
Редактируя конфиг не следует ничего оттуда удалять, кроме закомментированных строк.
**/etc/neutron/plugins/ml2/ml2\_conf.ini**
```
[ml2]
type_drivers = flat,vlan,gre,vxlan
tenant_network_types = gre
mechanism_drivers = openvswitch
[ml2_type_gre]
tunnel_id_ranges = 1000:2000
[ml2_type_flat]
flat_networks = external
[securitygroup]
enable_security_group = True
enable_ipset = True
firewall_driver = neutron.agent.linux.iptables_firewall.OVSHybridIptablesFirewallDriver
[ovs]
local_ip = 10.0.1.11 #INSTANCE_TUNNELS_INTERFACE_IP_ADDRESS
bridge_mappings = external:br-ex
[agent]
tunnel_types = gre
```
**/etc/neutron/l3\_agent.ini**
```
[DEFAULT]
interface_driver = neutron.agent.linux.interface.OVSInterfaceDriver
external_network_bridge =
router_delete_namespaces = True
```
**/etc/neutron/dhcp\_agent.ini**
```
[DEFAULT]
interface_driver = neutron.agent.linux.interface.OVSInterfaceDriver
dhcp_driver = neutron.agent.linux.dhcp.Dnsmasq
dhcp_delete_namespaces = True
dnsmasq_config_file = /etc/neutron/dnsmasq-neutron.conf
```
**/etc/neutron/dnsmasq-neutron.conf**
```
dhcp-option-force=26,1454
```
В официальной документации эта настройка использовалась для сетевых устройств без поддержки jumbo frames, но в целом там можно прописать практически любые настройки для dnsmasq.
Убиваем все процессы dnsmasq
```
# pkill dnsmasq
```
**/etc/neutron/metadata\_agent.ini**
```
[DEFAULT]
auth_uri = http://controller:5000
auth_url = http://controller:35357
auth_region = RegionOne
auth_plugin = password
project_domain_id = default
user_domain_id = default
project_name = service
username = neutron
password = NEUTRON_PASS
nova_metadata_ip = controller
metadata_proxy_shared_secret = METADATA_SECRET
```
**/etc/nova/nova.conf**
```
[DEFAULT]
...
network_api_class = nova.network.neutronv2.api.API
security_group_api = neutron
linuxnet_interface_driver = nova.network.linux_net.LinuxOVSInterfaceDriver
firewall_driver = nova.virt.firewall.NoopFirewallDriver
[neutron]
url = http://controller:9696
auth_strategy = keystone
admin_auth_url = http://controller:35357/v2.0
admin_tenant_name = service
admin_username = neutron
admin_password = NEUTRON_PASS
service_metadata_proxy = True
metadata_proxy_shared_secret = METADATA_SECRET
```
*METADATA\_SECRET* это так же набор символов от 10 до 16 символов
Из *nova.conf* не удаляем ничего, только добавляем.
Синхронизируем БД и перезапускаем сервисы:
```
# su -s /bin/sh -c "neutron-db-manage --config-file /etc/neutron/neutron.conf --config-file /etc/neutron/plugins/ml2/ml2_conf.ini upgrade head" neutron
# service nova-api restart
# service neutron-server restart
# service openvswitch-switch restart
```
Создаём мост и связываем его с external-интерфейсом
```
# ovs-vsctl add-br br-ex
# ovs-vsctl add-port br-ex p3p1
```
Перезапускаем интерфейсы
```
# service neutron-plugin-openvswitch-agent restart
# service neutron-l3-agent restart
# service neutron-dhcp-agent restart
# service neutron-metadata-agent restart
```
###### Вычислительный узел
Без комментариев.
```
# cat /etc/sysctl.conf
net.ipv4.conf.all.rp_filter=0
net.ipv4.conf.default.rp_filter=0
net.bridge.bridge-nf-call-iptables=1
net.bridge.bridge-nf-call-ip6tables=1
# sysctl -p
```
```
# apt-get install neutron-plugin-ml2 neutron-plugin-openvswitch-agent
```
**/etc/neutron/neutron.conf**
```
[DEFAULT]
...
rpc_backend = rabbit
auth_strategy = keystone
core_plugin = ml2
service_plugins = router
allow_overlapping_ips = True
[oslo_messaging_rabbit]
rabbit_host = controller
rabbit_userid = openstack
rabbit_password = RABBIT_PASS
[keystone_authtoken]
auth_uri = http://controller:5000
auth_url = http://controller:35357
auth_plugin = password
project_domain_id = default
user_domain_id = default
project_name = service
username = neutron
password = NEUTRON_PASS
```
**/etc/neutron/plugins/ml2/ml2\_conf.ini**
```
[ml2]
type_drivers = flat,vlan,gre,vxlan
tenant_network_types = gre
mechanism_drivers = openvswitch
[ml2_type_gre]
tunnel_id_ranges = 1000:2000
[ml2_type_flat]
flat_networks = external
[securitygroup]
enable_security_group = True
enable_ipset = True
firewall_driver = neutron.agent.linux.iptables_firewall.OVSHybridIptablesFirewallDriver
[ovs]
local_ip = 10.0.1.31 #INSTANCE_TUNNELS_INTERFACE_IP_ADDRESS
bridge_mappings = external:br-ex
[agent]
tunnel_types = gre
```
Перезапускаем openvswitch
```
# service openvswitch-switch restart
```
Добавляем строчки в */etc/nova/nova.conf*
```
[DEFAULT]
...
network_api_class = nova.network.neutronv2.api.API
security_group_api = neutron
linuxnet_interface_driver = nova.network.linux_net.LinuxOVSInterfaceDriver
firewall_driver = nova.virt.firewall.NoopFirewallDriver
[neutron]
url = http://controller:9696
auth_strategy = keystone
admin_auth_url = http://controller:35357/v2.0
admin_tenant_name = service
admin_username = neutron
admin_password = NEUTRON_PASS
```
Перезапускаем сервисы:
```
# service nova-compute restart
# service neutron-plugin-openvswitch-agent restart
```
Если я ничего не забыл упомянуть, то должно получиться так:
```
# neutron agent-list
+--------------------------------------+--------------------+----------+-------+----------------+---------------------------+
| id | agent_type | host | alive | admin_state_up | binary |
+--------------------------------------+--------------------+----------+-------+----------------+---------------------------+
| 30275801-e17a-41e4-8f53-9db63544f689 | Metadata agent | network | :-) | True | neutron-metadata-agent |
| 4bd8c50e-7bad-4f3b-955d-67658a491a15 | Open vSwitch agent | network | :-) | True | neutron-openvswitch-agent |
| 756e5bba-b70f-4715-b80e-e37f59803d20 | L3 agent | network | :-) | True | neutron-l3-agent |
| 9c45473c-6d6d-4f94-8df1-ebd0b6838d5f | DHCP agent | network | :-) | True | neutron-dhcp-agent |
| a5a49051-05eb-4b4f-bfc7-d36235fe9131 | Open vSwitch agent | compute1 | :-) | True | neutron-openvswitch-agent |
+--------------------------------------+--------------------+----------+-------+----------------+---------------------------+
```
###### Сети
Сейчас мы сделаем начальную заготовку наших сетей. Мы создадим одну внешнюю сеть и одну внутреннюю.
Создаём виртуальную сеть:
```
# neutron net-create ext-net --router:external --provider:physical_network external --provider:network_type flat
```
Настраиваем нашу внешнюю подсеть:
```
# neutron subnet-create ext-net 192.168.1.0/24 --name ext-subnet \
--allocation-pool start=192.168.1.100,end=192.168.1.200 \
--disable-dhcp --gateway 192.168.1.1
```
Наша внешняя сеть 192.168.1.0/24 и маршрутизатор выпускающий в интернет 192.168.1.1. Внешние адреса для нашего облака будут выдаваться из диапазона 192.168.1.101-200.
Далее мы будем создавать внутреннюю сеть для проекта *demo*, поэтому следует загрузить переменные для demo-юзера:
```
# source demo-openrc.sh
```
Теперь создаём виртуальную внутреннюю сеть:
```
# neutron net-create demo-net
# neutron subnet-create demo-net 172.16.1.0/24 --name demo-subnet --gateway 172.16.1.1
```
Понятно, что наша виртуальная сеть будет 172.16.1.0/24 и все инстансы из неё будут получать в качестве маршрутизатора 172.16.1.1.
Вопрос: что это за маршрутизатор?
Ответ: это виртуальный маршрутизатор.
«Фишка» в том, что в Neutron можно строить виртуальные сети с достаточно большим количеством подсетей, а значит для них необходим виртуальный маршрутизатор. Каждый виртуальный маршрутизатор можно добавлять порты в любую из доступных виртуальных и внешних сетей. И это действительно «сильно»! Мы назначаем маршрутизаторам только только доступ к сетям, а всеми правилами firewall мы управляем из групп безопасности. Более того! Мы можем создать виртуальную машину с программным маршрутизатором, настроить интерфейсы во все необходимые сети и управлять доступом через него (я пробовал использовать Mikrotik).
В общем, Neutron даёт простор фантазии.
Создаём виртуальный маршрутизатор, назначаем ему интерфейс в demo-subnet и присоединяем его к внешней сети:
```
# neutron router-create demo-router
# neutron router-interface-add demo-router demo-subnet
# neutron router-gateway-set demo-router ext-net
```
Теперь из внешней сети должен пинговаться наш виртуальный маршрутизатор:
```
# ping 192.168.1.100
PING 192.168.1.100 (192.168.1.100) 56(84) bytes of data.
64 bytes from 192.168.1.100: icmp_req=1 ttl=64 time=0.619 ms
64 bytes from 192.168.1.100: icmp_req=2 ttl=64 time=0.189 ms
64 bytes from 192.168.1.100: icmp_req=3 ttl=64 time=0.165 ms
64 bytes from 192.168.1.100: icmp_req=4 ttl=64 time=0.216 ms
...
```
В целом, у нас уже есть работоспособное облако с сетью.
##### **Cinder** (Блочное хранилище)
Cinder — сервис предоставляющий возможность управлять блочными устройствами (виртуальными дисками), присоединять их к виртуальным инстансам. Виртуальные диски могут быть и загрузочными. Это может быть очень удобно для переноса VM на другой вычислительный инстанс.
БД:
```
# mysql -u root -p
CREATE DATABASE cinder;
GRANT ALL PRIVILEGES ON cinder.* TO 'cinder'@'localhost' IDENTIFIED BY 'CINDER_DBPASS';
GRANT ALL PRIVILEGES ON cinder.* TO 'cinder'@'%' IDENTIFIED BY 'CINDER_DBPASS';
```
Keystone:
```
# openstack user create --password-prompt cinder
# openstack role add --project service --user cinder admin
# openstack service create --name cinder --description "OpenStack Block Storage" volume
# openstack service create --name cinderv2 --description "OpenStack Block Storage" volumev2
# openstack endpoint create --publicurl http://controller:8776/v2/%\(tenant_id\)s --internalurl http://controller:8776/v2/%\(tenant_id\)s --adminurl http://controller:8776/v2/%\(tenant_id\)s --region RegionOne volume
# openstack endpoint create --publicurl http://controller:8776/v2/%\(tenant_id\)s --internalurl http://controller:8776/v2/%\(tenant_id\)s --adminurl http://controller:8776/v2/%\(tenant_id\)s --region RegionOne volumev2
```
Установка необходимых пакетов:
```
# apt-get install cinder-api cinder-scheduler python-cinderclient
```
Поправим конфиг:
**/etc/cinder/cinder.conf**
```
[DEFAULT]
...
rpc_backend = rabbit
auth_strategy = keystone
my_ip = 10.0.0.11
[oslo_messaging_rabbit]
rabbit_host = controller
rabbit_userid = openstack
rabbit_password = RABBIT_PASS
[database]
connection = mysql://cinder:CINDER_DBPASS@controller/cinder
[keystone_authtoken]
auth_uri = http://controller:5000
auth_url = http://controller:35357
auth_plugin = password
project_domain_id = default
user_domain_id = default
project_name = service
username = cinder
password = CINDER_PASS
[oslo_concurrency]
lock_path = /var/lock/cinder
```
Далее синхронизируем БД и перезапускаем сервисы:
```
# su -s /bin/sh -c "cinder-manage db sync" cinder
# service cinder-scheduler restart
# service cinder-api restart
```
Т.к. наш контроллер будет так же и хранилищем, то следующие действия так же проводим на нём.
Устанавливаем необходимые пакеты:
```
# apt-get install qemu lvm2
```
Помните я упоминал в конфигурации про два 500Гб диска? Мы из них сделаем RAID 1 (уж это описывать я не буду). Чисто технически, мы могли бы просто создать lvm-раздел из двух физических дисков, но такой вариант плох тем, что у нас не HA-проект и падение одного из дисков может быть критичным. Разбирать как создать RAID-массив я не буду, это легко гуглится. Будем считать, что наш рейд называется */dev/md1*:
```
# pvcreate /dev/md1
# vgcreate cinder-volumes /dev/md1
```
Мы создали физическое LVM-устройство и создали lvm-группу *cinder-volumes*.
Далее правим */etc/lvm/lvm.conf*.
Находим (или добавляем) туда такую строку:
```
devices {
...
filter = [ "a/md1/", "r/.*/"]
```
Будем считать, что кроме как на рейд-разделе у нас ничего связанного с lvm нет. Если рабочий раздел так же развёрнут на lvm, то следует его добавить. Например, если наша система развёрнута на */dev/md0* и поверх неё развёрнут lvm, то наш конфиг будет выглядеть так:
```
devices {
...
filter = [ "a/md0/", "a/md1/", "r/.*/"]
```
В целом, думаю для тех, кто сталкивался с lvm это не должно быть сложно.
Устанавливаем необходимые пакеты:
```
# apt-get install cinder-volume python-mysqldb
```
добавляем в конфиг:
**/etc/cinder/cinder.conf**
```
[DEFAULT]
...
enabled_backends = lvm
glance_host = controller
[lvm]
volume_driver = cinder.volume.drivers.lvm.LVMVolumeDriver
volume_group = cinder-volumes
iscsi_protocol = iscsi
iscsi_helper = tgtadm
```
И перезапускаем сервисы:
```
# service tgt restart
# service cinder-scheduler restart
# service cinder-api restart
# service cinder-volume restart
```
##### **Horizon** (dashboard)
Horizon — дашбоард для OpenStack, написан на Python 2.7, движком является Django. Из него ведётся полное управление всей средой OpenStack: управление пользователями/проектами/ролями, управление образами, виртуальными дисками, инстансами, сетями и т.д.
###### Установка
```
# apt-get install openstack-dashboard
```
Установку можно производить на отдельном сервере с доступом к Controller-ноде, но мы установим на контроллере.
Поправим конфиг */etc/openstack-dashboard/local\_settings.py*:
```
...
OPENSTACK_HOST = "controller"
...
ALLOWED_HOSTS = '*'
...
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
'LOCATION': '127.0.0.1:11211',
}
}
...
OPENSTACK_KEYSTONE_DEFAULT_ROLE = "user"
...
TIME_ZONE = "Asia/Vladivostok"
...
```
*TIME\_ZONE* — ваш часовой пояс может быть (и скорее всего будет) другой. [Тут](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones) найдёте свой.
Перезапускаем Апач:
```
# service apache2 reload
```
Теперь можно заходить на *[controller/horizon](http://controller/horizon)*. В предыдущей моей публикации можно посмотреть скрины дашборда. В ubuntu дополнительно устанавливается пакет *openstack-dashboard-ubuntu-theme*, который добавляет некоторые ссылки с намёком на Juju. Если захочется вернуть оригинальную версию, то можно просто удалить пакет.
Так же можно в профиле пользователя выбрать язык интерфейса *Русский*, то изрядно облегчит работу Developer`ам.
Готово!
Публикация получилась весьма громоздкая, но не хотелось разделять.
Надеюсь статья поможет кому-либо.
В следующей публикации (если мою карму не закидают «помидорами») буду описывать примитивную установку Chef-сервера и простого рецепта. | https://habr.com/ru/post/262049/ | null | ru | null |
# Как ManyChat на PHP8 переезжал
Привет, меня зовут Максим, я бэкенд-разработчик в ManyChat.
Эта статья — о нашем переходе на PHP8. Однажды мы решили немного поисследовать — посмотреть, чего нам будет стоить возможный переход на новую версию, и запланировать эти работы на следующий год, сразу на 8.1. Перспектива переезда тогда вызывала у нас чувства примерно как на КДПВ: от мыслей обо всех тестах и внешних зависимостях было немного неуютно.
Мультсериал «Рик и Морти», 4 сезон, 6 серияОднако в процессе исследования выяснилось, что нельзя просто так взять и остановиться. Одно за другим, и вот мы уже полностью на PHP8.
Эта статья — о шагах, из которых складывался переезд, и проблемах, которые мы встретили в процессе. Надеюсь, статья будет полезна для тех, кому ещё только предстоить перейти на PHP8 — поможет подготовиться хотя бы морально. Для всех остальных (кто уже на PHP8 или не собирается) — давайте сверимся по ощущениям.
Немного контекста. ManyChat — это платформа для автоматизации маркетинга. Мы помогаем бизнесам расти через построение осмысленных коммуникаций со своими клиентами в мессенджерах, без необходимости иметь на своей стороне программистскую экспертизу для решения таких задач.
Технически это миллиарды внутренних событий, путешествующих по архитектуре из десятков внутренних сервисов, очередей, баз данных и вороха внешних API.
Бэкенд мы пишем на PHP. Этот язык с нами с самого начала — тут оказалось всё необходимое для нас по мере того, как ManyChat переставал быть стартапом и становился большой и сложной технологической историей.
Присмотреться поближе к PHP8 хотелось давно. Нам нравилась идеология синтаксического сахара и новых штук для облегчения жизни разработчикам, нравились рассказы о новой версии на конференциях.
У нас было 13к тестов, тысячи очередей, полста их обработчиков десятки серверов, и внешних зависимостей, Composer, Xdebug и куча dev окружений. Единственное, что меня беспокоило это PHPUnit 10, я знал, что рано или поздно придется переходить на эту фигню.
Переходить на новую версию пока что страшно — ок, давайте пока не переходить, а просто исследуем. Запустим тесты; обновим Composer; посмотрим, что там с Xdebug; проверим внешние зависимости; потестируем на Dev-окружении.
Так мы и поступили.
Чиним тесты
-----------
Первым шагом мы запустили тесты на PHP8 — проверить, сколько успешно выполнится, а сколько попадает. Для этого пришлось обновить Codeception и PHPUnit до последних на тот момент версий, так как только они поддерживали PHP8.
Красненьким светились ~40% тестов. В большинстве случаев проблема была в самом тесте.
В версии PHPUnit 9 метод at() стал deprecated из-за его неоднозначного поведения; а в PHPUnit 10 был удалён совсем.
Было:
```
$mock->expects($this->at(0))
->method('post')
->with(
'/me/messages',
$params0
)
->willReturn($responseStub0));
$mock->expects($this->at(1))
->method('post')
->with(
'/me/messages',
$params1
)
->willReturn($responseStub1);
```
Стало:
```
$mock->expects($this->exactly(2))
->method('post')
->withConsecutive(
[
'/me/messages',
$params0
],
[
'/me/messages',
$params1
]
)
->willReturnOnConsecutiveCalls(
$responseStub0,
$responseStub1
);
```
[Вот тут](https://github.com/sebastianbergmann/phpunit/issues/4297) можно подробнее почитать обсуждения по теме.
Увы, такие тесты у нас присутствовали в большом количестве и переписывать их было весьма больно. Где-то на сотом тесте автор сдался и сделал хак — замьютил депрекейт:
```
/**
* overloads \\PHPUnit\\Framework\\TestCase::at to suppress specific deprecation warning
* @deprecated
*/
public static function at(int $index): InvokedAtIndexMatcher
{
return new InvokedAtIndexMatcher($index);
}
```
Решение проблемы было делегировано будущему себе, переходящему на PHPUnit 10.
Некоторые тесты падали из-за формата текста ошибок — мы были завязаны на один, а в PHP8 он стал немного другим. Мы планировали плавный переход с возможностью одновременной сборки кода на 7.4 и 8 версии, поэтому в тестах сделали так:
```
if (8 === PHP_MAJOR_VERSION) {
$this->expectExceptionMessage('Undefined variable $undefinedValue');
} else {
$this->expectExceptionMessage('Undefined variable: undefinedValue');
}
```
Функция $this->assertContains() в новом PHPUnit стала вести себя по-другому. Пришлось переделать её вызов:
`static::assertContains(‘onboarding_state’, $actualResponse);`
заменяется на
`static::assertArrayHasKey(‘onboarding_state’, $actualResponse);`
`$this->assertContains($expectedData, $actualData['mainmenu']);`
заменяется на
`$this->assertArraySubset($expectedData, $actualData['mainmenu']);`
Итого, чтобы разобраться с тестами, мы сделали следующее:
* обновились до последних версий Codeception и PHPUnit;
* замьютили `at()`;
* стали обрабатывать два формата текста ошибок (для PHP7 и PHP8);
* переделали вызов `$this->assertContains()` на более правильные методы.
Обновляем Composer
------------------
Раз обновляемся, давайте заодно перейдём на Composer версии 2. Помимо всего прочего, он быстрее.
В целом обновление прошло незаметно, за исключением одной библиотеки — SDK для работы с одним SMS-провайдером. По неведомым причинам этот SDK требовал какой-то ненужный для его работы пакет, который в свою очередь требовал Composer версии 1. Мы решили сделать -ignore-platform-req=composer-plugin-api и не обращать на это внимания до лучших времен (когда SDK провайдера обновится).
Обновляем Xdebug
----------------
Xdebug 2 не поддерживает PHP8, поэтому на Dev-окружениях пришлось переезжать на [Xdebug 3](https://xdebug.org/docs/upgrade_guide).
[Изменений](https://xdebug.org/updates#x_3_0_0) много, из заметного — новый Xdebug стал пошустрее.
Переход на версию 3 был достаточно простым. Самое сложное — всем разработчикам в настройках PhpStorm поменять конфиги подключения к дебагеру и использовать другие параметры в консоли.
Было:
```
php7 \
-dxdebug.remote_enable=1 \
-dxdebug.remote_mode=req \
-dxdebug.remote_port=NNNN \
-dxdebug.remote_host=127.0.0.1 \
-dxdebug.start_with_request=1 \
-dxdebug.remote_autostart=1
```
Стало:
```
php8 \
-dxdebug.mode=debug \
-dxdebug.client_port=NNNN \
-dxdebug.client_host=127.0.0.1 \
-dxdebug.start_with_request=1
```
Проверяем библиотеки из vendor
------------------------------
В процессе устранения проблем в упавших тестах выяснилось, что некоторые внешние библиотеки, которые мы использовали, были не полностью готовы к PHP8. Например, Hoa — [некоторые](https://github.com/hoaproject/Stream/pull/30/files) pull requests о совместимости висят до сих пор.
К счастью, 99% нашего кода было уже переписано на [Symfony Expression Language](https://symfony.com/doc/current/components/expression_language.html) довольно давно ([вот тут](https://www.facebook.com/watch/?v=459702051355807) можно посмотреть доклад с подробностями).
Однако в тёмном углу оставались тесты, проверяющие, что Hoa === Symfony expression с точки зрения пользователя, и что одни и те же формулы считаются одинаково. Переход на PHP8 был отличным поводом переписать эти тесты и выбросить Hoa из зависимостей require-dev.
Для некоторых библиотек проблема совместимости с PHP 8 была в каком-нибудь одном простом методе – в этих случаях мы переписывали нужную функциональность руками и выкидывали всю зависимость. В основном это касалось библиотек, которые редко мейнтейнятся или заброшены, так что переход на PHP8 стал отличным поводом избавиться от ненужного.
На удивление, для библиотек, которые активно используются – нам не пришлось сделать ни одного PR, достаточно было обновить версию библиотеки. Были библиотеки, которые в require указывали PHP7 и ещё не обновились, но нужная нам функциональность работала с PHP8. Для таких зависимостей достаточно было в Composer-сборках добавить ключ `-ignore-platform-req=php`.
В случае зависимостей, для которых неизвестно, когда они начнут поддерживать PHP8, мы выбрали следующую стратегию:
* Убедиться, что библиотека работает корректно с новой версией PHP; при использовании пакетного Composer-менеджера добавить флаг `--ignore-platform-reqs`.
* Сделать свой PR (issue) в нужную библиотеку и ждать, пока вмёрджат; или сделать временный форк (нам не пришлось так делать).
* В composer.json добавить `post-install-cmd`, который пропатчит нужный файл прямо в директории vendor. Для случаев, когда изменение совсем маленькое и не хочется возиться с форком. (одна старая не поддерживаемая мейнтейнером библиотека, которую обязательно заменим)
### Делаем пробный выход в свет на Dev-окружениях
Composer собирается, тесты зелёные.
Следующим шагом было ручное тестирование основной функциональности на окружении разработчика под PHP8. Удивительно, но всё работало (возможно, именно в этом и есть смысл тестов).
Решаемся: новый Composer, обновлённые библиотеки, фиксы тестов – мёрджим в master. Там в основном фиксы тестов и мелкие фиксы кода из разряда `$array['item'] ?? null` вместо `$array['item']` – поэтому мёрджить не страшно. К тому же тесты прогоняются одинаково успешно и PHP7.4 и PHP8 интерпретаторами.
Дальше мы перевели PHP-FPM нашего Develop-окружения на PHP8.
Про наше develop окружениеРазработку фич мы ведём в ветках от develop — в окружениях разработчиков; по окончании разработки мёрджим фичи обратно в develop. Перед релизом develop мёрджится в master. При этом Develop-окружение смотрит на одноименную ветку. На Develop-окружении проводятся финальные ручные командные тесты и запускаются некоторые интеграционные тесты для фронтенда.
В нашем случае PHP-FPM работает только для взаимодействия с веб-приложением, основная подкапотная бизнес-логика крутится в PHP CLI. Поэтому следующим этапом было перевести CLI-команды на PHP8. Мы хотели сделать возможность плавной раскатки на продакшене — поэтому менеджер процессов доработали так, чтобы PHP8 можно было запускать только часть команд.
Мы погоняли PHP-код в таком "предпродакшене" ещё неделю, отловили по логам несколько ошибок в корнер-кейсах, не покрытых тестами, пофиксили их.
Для закрепления результата сделали так, чтобы бинарник по умолчанию был от PHP8; /usr/bin/php – симлинк на /usr/bin/php8. Чтобы убедиться, что нигде случайно PHP7.4 не остался.
Всё, мы были готовы ехать в продакшен.
Раз-раз и в продакшен
---------------------
Мы подняли отдельный сервер PHP-FPM с PHP8. Прописали в Nginx перенаправление трафика только со своих адресов, чтобы если что-то сломается, пользователи не заметили бы проблем.
В течении недели плавно поднимали nginx upstream weight, перенаправляли всё больше уже пользовательского трафика на новый сервер, отслеживали и чинили в коде редкие ошибки, чаще всего обращение к несуществующему элементу массива. Как перестали появляться ошибки, перевели на PHP8 все "фронтовые" сервера (те, где PHP-FPM, с которым взаимодействует веб приложение на ReactJS и мобильные iOS/Android приложения).
Дальше пришло время "бэкенд" серверов с их PHP CLI. На этих серверах у нас крутятся консольные команды, разгребающие Redis-очереди (подробнее об этом [тут](https://habr.com/ru/company/manychat/blog/507136/)).
В этот момент стало по-настоящему тревожно: основная нагрузка на продакшен у нас именно на бэкенд-серверах; цена ошибки там выше, чем для фронтового приложения.
Мультсериал «Рик и Морти», 3 сезон, 5 серияКоманды обработки очередей мы переключили на PHP8 в ручном режиме: останавливаешь процессинг очереди на PHP7, запускаешь на PHP8, ждёшь, переходишь к следующей очереди.
У нас был предусмотрен механизм, чтобы максимально быстро откатиться назад в случае чего, но он не понадобился. Воистину, “зонт возьмешь – дождя не будет”.
Мелкие ошибки прилетали ещё примерно месяц. Это были редкие корнер-кейсы, не покрытые тестами и не случающиеся в happy path, но присутствующие в редко используемой функциональности. Примерно 99% этих ошибок – E\_WARNING на том, что такого-то элемента нет в массиве (в PHP7 это был незаметный E\_NOTICE).
Что может пойти не так: JIT и производительность
------------------------------------------------
Автор так сильно переживал за код и бизнес-логику (и хотел поскорее написать эту статью), что совершенно не подумал про JIT и производительность. Новый PHP8 по материалам статей/докладов, чуть быстрее, чем PHP7; тесты выполняются за то же время. Что может пойти не так?
Как оказалось, для работы JIT его нужно специально включить; наличия дефолтного opcache.jit=tracing для этого не достаточно, нужно сделать ненулевой opcache.jit\_buffer\_size.
Автор включил JIT прямо в продакшене на одном из фронтовых серверов. Это была фатальная ошибка. Где-то треть пользователей, работавших с нашим Flow Builder – стали получать рандомные 500 ошибки; к нам в Slack посыпались алармы. Хотя вся эта ситуация длилась всего пару минут, она оставила неизгладимый след на совести и репутации автора.
Дело было в том, что opcache.jit=tracing в нашем коде вызывал segfault. Несколько похожих тикетов с ошибками уже тогда можно было найти на [bugs.php.net](https://bugs.php.net/search.php?search_for=segfault&boolean=0&limit=30&order_by=&direction=DESC&cmd=display&status=All&bug_type=All&project=All&php_os=&phpver=8.0&cve_id=&assign=&author_email=&bug_age=0&bug_updated=0&commented_by=) (к слову, в 8.1 это исправлено). Опытным путём мы выяснили, что opcache.jit=function в нашем коде не вызывает segfault но и не даёт прироста производительности.
Увы, от JIT нам тогда пришлось отказаться до лучших времен (до выхода PHP8.1).
Хотя вроде бы в 8.0.12 довольно много исправлений для segfault (<https://github.com/php/php-src/blob/PHP-8.0.12/NEWS>) Так что может и попробуем JIT ещё раз при следующем апдейте.
Проблемы на этом не закончились. Прогон тестов показывал, что тесты на PHP8 и PHP7.4 исполняются за одинаковое время. А на синтетических тестах (вроде множества Мандельброта) с включенным JIT мы вообще наблюдали космический прирост. Однако в продакшене мы видели, что PHP8 стабильно на 10-15% больше потребляет CPU, чем PHP7.4.
Заглянули в [flamegraph phpspy](https://github.com/adsr/phpspy), но ничего там не нашли.
Тогда мы пошли сравнивать опкоды PHP7.4 и PHP8:
`/usr/bin/phpdbg7.4 -p* path-to-prod-file.php > opcodes7`
`/usr/bin/phpdbg8.0 -p* path-to-prod-file.php > opcodes8`
`diff -y opcodes7 opcodes8`
Обнаружили пару занятных фактов.
Во-первых, в PHP8 есть оптимизация, которая `$var === null` превращает в такой же опкод, что и `\is_null($var).`
У нас в команде даже случался на этот счёт локальный холивар – мол, в PHP7 is\_null чуть-чуть быстрее и даже PHPStorm подсказывает такую замену при определенных настройках. В PHP8 это одно и то же с точки зрения опкодов.
`L18 IS_NOT_IDENTICAL ~0 null ~1 /vendor/composer/autoload_real.php - php7`
`L18 TYPE_CHECK<1020> ~0 /vendor/composer/autoload_real.php - php8`
Для сравнения с true/false применили тот же подход:
`L7 IS_IDENTICAL @0 false ~1 /vendor/myclabs/deep-copy/src/DeepCopy/deep_copy.php - php7`
`L7 TYPE_CHECK<4> @0 /vendor/myclabs/deep-copy/src/DeepCopy/deep_copy.php - php8`
Во-вторых, в `phpdbg8` в отличие от `phpdbg7` нет вывода новых opcodes, объявленных в `register_shutdown_function()` после `exit(0).` Однако в обычном php (не dbg) код этой shutdown функции выполняется. Честно, мы до конца не разобрались, почему так – рассказывайте в комментариях, если знаете!
Никакая из этих двух находок не объясняла прирост нагрузки в 10-15%.
G1 (красный) – сервер с php7-cli
G1 (фиолетовый) – сервер с php8-cli
зелёный цвет – свободная память (метрика приходит с активного в данный момент сервера)
На помощь пришёл старый добрый `/usr/bin/strace` – показал какое-то невероятное количество ECHO в Redis-соединениях. Подробности мы нашли [тут](https://github.com/phpredis/phpredis/issues/1742).
Оказывается, вместе с PHP7.4 мы использовали расширение php-redis версии 5.1.1, а в новой сборке PHP8 была версия 5.3.4. Тем временем в версии 5.2.1 появилась постоянная проверка живучести персистентного соединения. В версии 5.2.2 она стала опциональной через php.ini и `redis.pconnect.echo_check_liveness`, но по умолчанию была включена. Мы очень активно используем Redis, так что такая постоянная проверка через ECHO в итоге дала тот самый рост нагрузки в 10-15%.
Внимательный читатель может спросить о php8+JIT на графике. Там выяснилось, что JIT в CLI работает немного не так, как от него ожидаешь.
Когда в php.ini включен `opcache.enable_cli` и `opcache.file_cache`, а в файловом кэше лежат опкоды, которые туда заранее сложили при прогреве кэша – в этом случае JIT не срабатывает (подтягиваются опкоды из файла и код работает на них).
Если же в файловом кэше нет предварительно прогретого opcache, то опкоды не пишутся обратно в файловый opcache, но зато работает JIT.
Эти выводы основаны не на глубинном знании о том, как работает opcache и JIT, но на эмпирических наблюдениях за `strace` и выводом интерпретатора при включенном [opcache.jit\_debug](https://wiki.php.net/rfc/jit).
С помощью `strace` мы увидели, что opcache читается из файла, если он там есть, но обратно не пишется, если его там нет. Инсайты от jit\_debug: если opcache прочитан из файла, то JIT-компиляции не произошло (дебаг пустой); если же opcache из файла не прочитан, то есть сгенерированный jit\_debug.
В нашем случае получилось, что время, выигрываемое с помощью JIT – “проигрывалось” обратно из-за потерь на интерпретации php-файла в opcodes; при этом затраты по памяти выходили даже больше.
Ваш путь к PHP8
---------------
Переезд на PHP8 занял у нас пару месяцев в фоновом режиме. История с JIT и производительностью под конец добавила драмы и потрепала нервы, но в целом весь процесс перехода на новую версию прошёл довольно гладко.
В начале было страшно переезжать, но ни 13К тестов, ни внешние библиотеки не создали особых проблем. Используешь Redis — посмотри новые настройки; с JIT — будь аккуратнее. Ничего такого.
Надеемся, ваш переезд на PHP8 будет простым и недолгим. А если вы уже переехали, поделитесь впечатлениями — будем рады послушать! | https://habr.com/ru/post/586008/ | null | ru | null |
# Учимся писать модуль ядра (Netfilter) или Прозрачный прокси для HTTPS
Эта статья нацелена на читателей, которые начинают или только хотят начать заниматься программированием модулей ядра Linux и сетевых приложений. А также может помочь разобраться с прозрачным проксированием HTTPS трафика.
Небольшое оглавление, чтобы Вы могли оценить, стоит ли читать дальше:
1. Как работает прокси сервер. Постановка задачи.
2. Клиент – серверное приложение с использованием неблокирующих сокетов.
3. Написание модуля ядра с использованием библиотеки Netfilter.
4. Взаимодействие с модулем ядра из пользовательского пространства (Netlink)
P.S. Для тех, кому только хочется посмотреть на прозрачный прокси-сервер для HTTP и HTTPS, достаточно [настроить прозрачный прокси-сервер для HTTP](http://www.google.ru/#q=настроить+прозрачный+прокси+Squid), например, Squid с transparent портом 3128, и [скачать архив с исходниками Shifter](http://shifter-proxy.googlecode.com/files/Shifter.tar.gz). Скомпилировать (make) и, после удачной компиляции, выполнить ./Start с правами root. При необходимости можно поправить настройки в shifter.h до компиляции.
#### Постановка задачи
Как и все начинающие в области IT захотелось покопаться немножко в ядре. Тут и область для экспериментов появилась сама собой. Если заглянуть в гугл, то можно заметить, что, если с прозрачным прокси-сервером для HTTP проблем ни у кого не возникает, то в случае с HTTPS некоторые уверены в том, что прозрачного прокси для протокола HTTPS нет. И его никогда не будет. Все это и послужило появлению этой статьи.
Для начала рассмотрим некоторые аспекты работы прокси-сервера, которые нам понадобятся. Когда браузер напрямую обращается к HTTP серверу, то он создает следующий типовой запрос:
```
GET / HTTP/1.1
Host: www.google.ru
…
```
Когда в настройках браузера указываем прокси сервер, то браузер начинает соединяться с прокси-сервером, и отсылает ему запрос с полным адресом:
```
GET http://www.google.ru/ HTTP/1.1
Host: www.google.ru
…
```
Если прокси сервер получит запрос с неполным адресом, как в первом случае, то он может не знать, кому предназначен этот запрос и возвратит ошибку.
Скажу в двух словах про HTTPS. Браузер устанавливает tcp соединение и, используя протокол SSL: обменивается сертификатами и передает зашифрованный трафик HTTP. Так как протокол SSL как раз направлен на то, чтобы никто не смог посередине прочитать передаваемые данные, то прокси-сервер не может, как в случае HTTP, выяснить с кем следует установить соединение. Для передачи данных по HTTPS через прокси-сервер браузер должен сообщить прокси-серверу с кем он хочет соединиться, используя HTTP метод CONNECT:
```
CONNECT mail.google.com:443 HTTP/1.1
Host: mail.google.com
…
```
На что прокси-сервер должен ответить, что соединение успешно установлено:
```
HTTP/1.0 200 Connection established
```
В результате браузер получает как бы прямое tcp соединение через прокси-сервер, в котором он может передавать абсолютно любые данные. А прокси-сервер занимается только точной перекладкой данных из tcp соединения, установленного с браузером, в tcp соединение, установленное с указанным хостом в методе CONNECT, и, соответственно, обратной перекладкой.
Когда используется прозрачное проксирование, т.е. браузер даже не подозревает о существование прокси-сервера, то соответственно браузер и не будет так красиво подготавливать свои данные. И прокси-серверу придется самому подумать об этом.
Схематично взглянем на прозрачный прокси для HTTP:
Здесь конечно есть неточности, например, прокси, получая пакет на свой порт 3128, не передает его дальше гуглу, а создает новое соединение с гуглом, но, в общем, схема взаимодействий примерно такова. В данной схеме видно, что NAT начинает направлять пакеты прокси-серверу, которые предназначены не для него, и ему требуется узнать кому их все-таки отсылать. В случае с HTTP трафиком некоторые прокси-сервера неправомерно начинают пользоваться информацией из поля HOST заголовка HTTP запроса, нарушая спецификацию. Чаще всего конечно в HOST содержится именно то имя хоста, которому и адресован запрос, но, в общем случае, HOST может содержать что угодно. Для HTTPS такое решение и вовсе не подходит. Чтобы узнать, кому адресован пакет, сразу напрашивается решение, в котором прокси-сервер заглянул бы в NAT и посмотрел, кому все-таки были предназначены данные и тогда проблем бы ни каких не было. Вот собственно, чем и займемся.
В сам iptables, к сожалению, не полезем, но все равно будут хорошо понятны основные принципы его работы. Схематично это будет выглядеть следующим образом:
Для намеченных целей, будет достаточно написать крохотный модуль ядра (Module Shifter) и реализовать небольшую программную прослойку (Shifter) в пользовательском пространстве для взаимодействия с нашим модулем, которая и будет подготавливать данные для прокси-сервера.
#### Клиент – серверное приложение (Shifter)
Напишем маленькое клиент-серверное приложение, которое я назвал Shifter. Shifter будет висеть на своем порту и, когда кто-нибудь установит tcp соединение с ним, то он создаст tcp соединение с прокси-сервером и пошлет ему метод CONNECT (HTTP), а далее будет заниматься только точной передачей данных между этими двумя соединениями. В случае если клиент или прокси закроет соединение с ним, то он закроет эту пару сокетов.
Для отправки метода CONNECT нужен ip адрес удаленного узла, с которым на самом деле хотел установить соединение клиент. Чтобы получить эту информацию Shifter будет связываться с модулем ядра (Module Shifter) используя библиотеку Netlink. Об этом будет рассказано в последней части этой статьи.
Данным приложением мы подготовим прокси-сервер к приему данных (HTTPS) от клиента, который ничего не знает о прокси-сервере. Так как имеется много ресурсов, где подробно написано про сокеты, здесь лишь приведу ссылку на [часть исходного кода Shifter'а с подробными комментариями](http://paste.ubuntu.com/818687/).
#### Kernel module Shifter
Для того чтобы узнать, что такое модуль ядра можно прочитать, например, [Работаем с модулями ядра в Linux](http://habrahabr.ru/blogs/nix/117654/). Приступим к написанию модуля. Для начала нужно выполнить инициализацию модуля, которая будет происходить один раз, когда модуль будет подгружаться в ядро. А также следует выполнить корректное завершение работы модуля, чтобы не оставлять всякие ненужные следы прошлого присутствия, когда модуль выгрузят из ядра. Для этих целей в библиотеке *:* есть два макроса **module\_init** и **module\_exit**, которые в качестве параметра принимают имя функции для этих целей. Также имеются макросы **MODULE\_AUTHOR**, **MODULE\_DESCRIPTION**, **MODULE\_LICENSE**, чтобы увековечить свое имя :) Еще есть очень полезная функция вывода **int printk(const char \*fmt, ...)** в библиотеке *:*. Она мало чем отличается от обычного *printf(..)*. Так как модуль находится в ядре, а не запущен в консоли, то сообщения соответственно выводятся в логи (для просмотра можно использовать команду **dmesg**). Сообщения можно выводить различных типов:
```
#define KERN_EMERG "<0>" /* system is unusable */
#define KERN_ALERT "<1>" /* action must be taken immediately */
#define KERN_CRIT "<2>" /* critical conditions */
#define KERN_ERR "<3>" /* error conditions */
#define KERN_WARNING "<4>" /* warning conditions */
#define KERN_NOTICE "<5>" /* normal but significant condition */
#define KERN_INFO "<6>" /* informational */
#define KERN_DEBUG "<7>" /* debug-level messages */
#define KERN_DEFAULT "" /\* Use the default kernel loglevel \*/
```
Теперь у нас имеется вся информация, чтобы написать каркас своего первого модуля:
```
#include
#include
MODULE\_AUTHOR("Denis Dolgikh ");
MODULE\_DESCRIPTION("Module for the demonstration");
MODULE\_LICENSE("GPL");
int Init(void)
{
printk(KERN\_INFO "Init my module\n");
printk("Hello, World!\n");
return 0;
}
void Exit(void)
{
printk(KERN\_INFO "Exit my module\n");
}
module\_init(Init);
module\_exit(Exit);
```
Расскажу еще немного о том, как это все скомпилировать и запустить. Скажу сразу, что у меня установлена Ubuntu 11.10 (x86) Kernel 3.0.
В системе имеется каталог */lib/modules/[версия ядра]/* в нем находятся модули для соответствующей версии ядра. Также там имеется **build** – это символическая ссылка на заголовки библиотек ядра (kernel-headers), которые находятся в каталоге */usr/src/linux-headers-[версия ядра]/*. Если у вас еще нет kernel-headers, то их нужно скачать (*sudo apt-get install linux-headers-[версия ядра]*). Чтобы узнать версию текущего ядра, в котором Вы работаете, можно выполнить команду *uname –r*. Если будете использовать библиотеку с версией отличной от версии текущего ядра, то такой скомпилированный модуль может замечательно работать, а может в лучшем случае не запуститься. Это все зависит от того, какие произошли изменения в ядре, и какие Вы используете в модуле функции.
Для компиляции модуля напишем **Makefile**. Создадим две цели: *all* (сборка модуля) и *clean* (очистка проекта), для их написания воспользуемся уже написанными для нас целями: *modules* и *clean* в *Makefile* из *kernel-headers*.
```
# Добавляем модуль к списку модулей для компилирования
# module_test.o – означает, что модуль нужно собрать автоматически из module_test.с
obj-m += module_test.o
# Подключаем Makefile из kernel-headers с помошью -С,
# который лежит в каталоге /lib/modules/[версия ядра]/build
# используем из него цель modules для сборки модулей в списке obj-m
# M=$(PWD) передаем текущий каталог, где лежат исходники нашего модуля
all:
make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
clean:
make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
```
Теперь можем легко скомпилировать модуль с помощью команды **make** и очистить проект *make clean*. В результате получим готовый модуль *module\_test.ko*, который можно сразу загрузить в ядро, используя команду **insmod ./module\_test.ko**. Есть еще один вариант загрузки модуля в ядро — командой **modprobe module\_test**. Для этого нужно положить модуль *module\_test.ko* в каталог */lib/modules/[текущая версия ядра]/[любой каталог]/* и не забыть выполнить **depmod**, т.к. эта команда создает список зависимостей модулей в */lib/modules/*. Даже если у модуля нет зависимостей, *modprobe* не увидит добавленный модуль без *depmod*. Основные различия между *insmod* и *modprobe* в следующем: *modprobe* при загрузке модуля автоматически загружает все модули, от которых он зависит, зато *insmod* может подгружать модуль из любого каталога. Удалить модуль из ядра: **rmmod module\_test**. Посмотреть информацию о модуле: **modinfo module\_test** или *modinfo ./module\_test.ko*.
##### Библиотека Netfilter
И так вернемся к прокси для HTTPS. Наша задача — сделать так, чтобы модуль просматривал сетевые пакеты до того, как их обработает DNAT (iptables). Для этого нам поможет *библиотека Netfilter.* (Для более детального понимания рекомендую дополнительно прочитать о Netfilter в других источниках, хотя бы [в Википедии](http://ru.wikipedia.org/wiki/Netfilter)) Рассмотрим, как выглядит путь сетевого пакета в ядре:
Более подробно можно [посмотреть вот здесь](http://open-source.arkoon.net/kernel/kernel_net.png).
Netfilter предоставляет 5 hook функций, которые дают доступ к сетевому пакету в 5 различных местах:1. **NF\_INET\_PRE\_ROUTING** – функция ловит абсолютно все входные пакеты, до этого пакеты уже прошли простые проверки (пакеты не потеряны, IP checksum в порядке и т.д.);
Далее пакет проходит через маршрутизацию, которая решает, предназначен ли пакет для другого интерфейса или локального процесса. Маршрутизация может отбрасывать пакет, если он не поддается маршрутизации.
2. **NF\_INET\_LOCAL\_IN** – вызывается, если пакет предназначен для локального процесса, перед передачей пакета ему;
3. **NF\_INET\_FORWARD** – когда пакет маршрутизируется с одного интерфейса на другой;
4. **NF\_INET\_LOCAL\_OUT** – ловушка для пакетов которые создают локальные процессы;
5. **NF\_INET\_POST\_ROUTING** – заключительная точка прежде, чем послать пакет драйверу сетевой карты.
Модуль ядра может зарегистрировать свою функцию в любом из этих 5 мест. При регистрации модуль должен указать приоритет своей функции в этом месте. В библиотеке можно найти приоритет для различных стандартных задач:
```
enum nf_ip_hook_priorities {
NF_IP_PRI_FIRST = INT_MIN,
NF_IP_PRI_CONNTRACK_DEFRAG = -400,
NF_IP_PRI_RAW = -300,
NF_IP_PRI_SELINUX_FIRST = -225,
NF_IP_PRI_CONNTRACK = -200,
NF_IP_PRI_MANGLE = -150,
NF_IP_PRI_NAT_DST = -100,
NF_IP_PRI_FILTER = 0,
NF_IP_PRI_SECURITY = 50,
NF_IP_PRI_NAT_SRC = 100,
NF_IP_PRI_SELINUX_LAST = 225,
NF_IP_PRI_CONNTRACK_CONFIRM = INT_MAX,
NF_IP_PRI_LAST = INT_MAX,
};
```
Из списка видно, что DNAT имеет приоритет -100, поэтому для нашей цели подойдет любой приоритет < -100. Если же приоритет у функции будет > -100, то она будет получать пакеты с уже измененным IP адресом назначения (получателя).
Каждая зарегистрированная функция в любой из 5 точек должна возвращать одно из следующих значений, которое определяет дальнейшую судьбу переданного ей пакета:
```
#define NF_DROP 0 /* discarded the packet */
#define NF_ACCEPT 1 /* the packet passes, continue iterations */
#define NF_STOLEN 2 /* gone away */
#define NF_QUEUE 3 /* inject the packet into a different queue (the target queue number is in the high 16 bits of the verdict) */
#define NF_REPEAT 4 /* iterate the same cycle once more */
#define NF_STOP 5 /* accept, but don't continue iterations */
```
В моем вольном переводе это будет звучать так:* **NF\_DROP** – удалить этот пакет
* **NF\_ACCEPT** – пакет проходит дальше, продолжаются итерации
* **NF\_STOLEN** – бросить этот пакет (ядро его больше не будет обрабатывать, модуль должен сам освободить память выделенную под этот пакет)
* **NF\_QUEUE** – поставить пакет в очередь (обычно для обработки пакета в пользовательском пространстве)
* **NF\_REPEAT** – повторить итерацию (повторный вызов функции с этим же пакетом)
* **NF\_STOP** – пропускать пакет дальше, но итерации не продолжать
В данном случае под итерацией понимается переход пакета от функции к функции, т.к. в одной точке может быть зарегистрировано много функций, которые в свою очередь могут быть разделены по приоритетам.
С теорией разобрались, теперь продолжим писать модуль. При загрузке модуля в ядро нужно зарегистрировать функцию, назовем ее *Hook\_Func*, которая будет просматривать все входящие пакеты, а при завершении эту функцию надо разрегистрировать, иначе ядро будет пытаться вызывать несуществующую функцию.
```
#include
#include
#include
#include
/\* Структура для регистрации функции перехватчика входящих ip пакетов \*/
struct nf\_hook\_ops bundle;
int Init(void)
{
printk(KERN\_INFO "Start module Shifter\n");
/\* Заполняем структуру для регистрации hook функции \*/
/\* Указываем имя функции, которая будет обрабатывать пакеты \*/
bundle.hook = Hook\_Func;
/\* Устанавливаем указатель на модуль, создавший hook \*/
bundle.owner = THIS\_MODULE;
/\* Указываем семейство протоколов \*/
bundle.pf = PF\_INET;
/\* Указываем, в каком месте будет срабатывать функция \*/
bundle.hooknum = NF\_INET\_PRE\_ROUTING;
/\* Выставляем самый высокий приоритет для функции \*/
bundle.priority = NF\_IP\_PRI\_FIRST;
/\* Регистрируем \*/
nf\_register\_hook(&bundle);
return 0;
}
void Exit(void)
{
/\* Удаляем из цепочки hook функцию \*/
nf\_unregister\_hook(&bundle);
printk(KERN\_INFO "End module Shifter\n");
}
module\_init(Init);
module\_exit(Exit);
```
Теперь все что нам осталось — это написать саму функцию *Hook\_Func*. Она должна иметь следующий прототип:
```
unsigned int Hook_Func(uint hooknum,
struct sk_buff *skb,
const struct net_device *in,
const struct net_device *out,
int (*okfn)(struct sk_buff *) )
{
/* Получаем очень надежный firewall */
/* который будет удалять (блокировать) абсолютно все входящие пакеты :) */
return NF_DROP;
}
```
Рассмотрим ее параметры:* **uint hooknum** содержит одно из следующих значений: *{NF\_INET\_PRE\_ROUTING = 0, NF\_INET\_LOCAL\_IN = 1, NF\_INET\_FORWARD = 2, NF\_INET\_LOCAL\_OUT = 3, NF\_INET\_POST\_ROUTING = 4}*. Этот параметр нужен, чтобы узнать из какого места вызвали функцию, т.к. можно зарегистрировать одну и ту же функцию в нескольких местах.
* **struct sk\_buff \*skb** указатель на структуру пакета.
* **const struct net\_device \*in** информация о входном интерфейсе. Если это исходящий пакет, тогда параметр равен NULL.
* **const struct net\_device \*out** информация о выходном интерфейсе. Если это входящий пакет, тогда параметр равен NULL.
* **int (\*okfn)(struct sk\_buff \*)** — callback функция, которая вызывается с пакетом, когда все итерации вернут положительный ответ.
Теперь подробнее об указателе на пакет *struct sk\_buff \*skb*.
> [sk\_buff](http://www.hackzona.ru/hz.php?name=News&file=article&sid=3605) – это буфер для работы с пакетами. Как только приходит пакет или появляется необходимость его отправить, создается sk\_buff, куда и помещается пакет, а также сопутствующая информация, откуда, куда, для чего… На протяжении всего путешествия пакета в сетевом стеке используется sk\_buff. Как только пакет отправлен, или данные переданы пользователю, структура уничтожается, тем самым освобождая память.
[Cтруктура sk\_buff описывается в](http://paste.ubuntu.com/842915/) , там же описаны еще различные функции для приятной работы с ней.
При работе с tcp можно воспользоваться еще двумя структурами — это [struct iphdr и struct tcphdr](http://paste.ubuntu.com/825024/).
Как видно из названия, эти структуры предназначены для работы с [IP заголовком](http://ru.wikipedia.org/wiki/IP) и, соответственно, с [TCP заголовком](http://ru.wikipedia.org/wiki/TCP). Чтобы получить указатели на эти структуры из *skb\_buff* можно воспользоваться двумя функциями:
```
static inline unsigned char *skb_network_header(const struct sk_buff *skb);
static inline unsigned char *skb_transport_header(const struct sk_buff *skb);
```
В этом месте я хотел бы обратиться к читателю. Мне осталось не совсем понятным, кто именно должен устанавливать указатель *transport\_header* в структуре *sk\_buff*, т.к. в точках *NF\_INET\_PRE\_ROUTING* и *NF\_INET\_LOCAL\_IN* (с любыми приоритетами) мне не удалось с помощью *skb\_transport\_header* получить структуру на tcp заголовок, хотя в остальных точках это работало прекрасно. Пришлось вручную указывать смещение для *transport\_header* от указателя *sk\_buff->data*, воспользовавшись *void skb\_set\_transport\_header(skb, offset)*.
Упомянутый указатель **sk\_buff->data** — это указатель на содержимое пакета, т.е. указывает на область памяти после Ethernet протокола, например, сразу на структуру IP заголовка, а после нее может следовать структура TCP заголовка или Ваш собственный протокол.
Так как везде используются указатели на данные в самом пакете, то можно не только читать различные поля, но и изменять их. Однако нужно помнить, что при изменении, например, IP адреса отправителя или получателя следует еще пересчитать контрольную сумму в заголовке IP пакета.
И так, наша функция будет сохранять IP адрес назначения только тогда, когда она увидит IP-TCP пакет, идущий на порт 443 (HTTPS) и содержащий флаг *SYN*, который говорит, что клиент хочет установить TCP соединение для протокола HTTPS. И удалять, когда появляются пакеты содержащие флаги *FIN* или *RST*, которые сообщают что tcp соединение разорвано и больше этот IP адрес нам не нужен.
```
#include
#include
#include
#define uchar unsigned char
#define ushort unsigned short
#define uint unsigned int
/\* Hook\_Func - функция, которая будет просматривать все входящие пакеты \*/
/\* Запоминает IP адрес получателя, если пакет: \*/
/\* - является tcp пакетом \*/
/\* - идет на 443 порт (HTTPS) \*/
/\* - содержит флаг SYN (установка tcp соединения) \*/
uint Hook\_Func(uint hooknum,
struct sk\_buff \*skb,
const struct net\_device \*in,
const struct net\_device \*out,
int (\*okfn)(struct sk\_buff \*) )
{
/\* Указатель на структуру заголовка протокола ip в пакете \*/
struct iphdr \*ip;
/\* Указатель на структуру заголовка протокола tcp в пакете \*/
struct tcphdr \*tcp;
/\* Проверяем что это IP пакет \*/
if (skb->protocol == htons(ETH\_P\_IP))
{
/\* Сохраняем указатель на структуру заголовка IP \*/
ip = (struct iphdr \*)skb\_network\_header(skb);
/\* Проверяем что это IP версии 4 и внутри TCP пакет \*/
if (ip->version == 4 && ip->protocol == IPPROTO\_TCP)
{
/\* Задаем смещение в байтах для указателя на TCP заголовок \*/
/\* ip->ihl - длина IP заголовка в 32-битных словах \*/
skb\_set\_transport\_header(skb, ip->ihl \* 4);
/\* Сохраняем указатель на структуру заголовка TCP \*/
tcp = (struct tcphdr \*)skb\_transport\_header(skb);
/\* Если пакет идет на 443 порт (HTTPS) \*/
if (tcp->dest == htons(443))
{
/\* Если выставлен флаг SYN, то сохраняем IP адрес назначения \*/
if (tcp->syn)
AddTable((uint)ip->saddr, (ushort)tcp->source, (uint)ip->daddr);
/\* Если имеется флаг FIN или RST, то можно удалить IP адрес назначения \*/
if (tcp->fin || tcp->rst)
DelTable((uint)ip->saddr, (ushort)tcp->source, (uint)ip->daddr);
}
}
}
/\* Пропускаем дальше все пакеты \*/
return NF\_ACCEPT;
}
```
Здесь есть две функции **AddTable** и **DelTable**, которые должны сохранять и удалять IP адрес получателя из памяти, для каждого IP и порта отправителя. Это нужно для того, чтобы клиент-сервер Shifter смог связаться с модулем Shifter и воспользовавшись функцией **ReadTable**, узнать по IP и порту клиента с каким IP адресом на самом деле хотел он связаться. Я не стал сильно раздумывать над типом данных для сохранения IP и воспользовался обычным статическим массивом с использованием элементарной хэш-функции. Хэш-функция (**KeyHash**) получает на входе ip и порт отправителя и возвращает индекс массива, где хранится ip адрес назначения. Она написана с учетом того, что клиент находится за натом и имеет подсеть с маской 255.255.255.0, поэтому я использую только последний байт ip отправителя, и еще этот байт накладывается 3 битами на два байта порта. В результате мне удалось сжать массив до размера 0x1FFFFF (~8 Мб). Конечно, нужно учитывать, что теперь после загрузки в ядро этот модуль будет занимать не меньше 8 Мб памяти, а это может оказаться слишком много для каких-нибудь встраиваемых систем. И еще не забываем про коллизию :) Но для моего демонстрационного примера все это окупается простотой и, вдобавок, *DelTable* вообще осталась пустой.
```
/* Статический массив для хранения IP адреса получателя */
#define MaxTable 0x1FFFFF
uint Table[MaxTable];
/* KeyHash - возвращает индекс в массиве */
/* который соответсвует заданным IP и Порту отправителя */
uint KeyHash(uint src_IP, ushort src_Port)
{
return (uint)(((src_IP & 0xFF000000) >> 11) ^ (uint)src_Port) % MaxTable;
}
/* AddTable - добавляет IP адрес получателя в таблицу */
/* который будет соответствовать заданным IP и Порту отправителя */
void AddTable(uint src_IP, ushort src_Port, uint dst_IP)
{
Table[KeyHash(src_IP, src_Port)] = dst_IP;
}
void DelTable(uint src_IP, ushort src_Port, uint dst_IP)
{
/* Если вы используете динамически выделяемую память для хранения IP получателя */
/* то здесь можно ее удалять */
}
/* ReadTable - возвращает IP адрес получателя */
/* который соответствует заданным IP и Порту отправителя */
uint ReadTable(uint src_IP, ushort src_Port)
{
return Table[KeyHash(src_IP, src_Port)];
}
```
На этом эта длинная часть статьи закончена и осталось только связать клиент-сервер Shifter c модулем ядра Shifter.
#### Взаимодействие с модулем ядра из пользовательского пространства (Netlink)
Теперь наша цель создать по одному сокету в Shifter и в модуле Shifter и соединить их между собой. Протокол обмена между модулем и сервером Shifter будет простым. Shifter будет отсылать 4 байта IP клиента и 2 байта Порт клиента, а модуль будет отвечать 4 байтами IP назначением, взятым из своей таблицы. Для этого воспользуемся библиотекой Netlink.
Хочу обратить внимание, что заголовок для пользовательских приложений */usr/include/linux/netlink.h* и для модулей ядра */usr/src/linux-headers-[версия ядра]/include/linux/netlink.h* имеет множество различий.
##### Netlink in user space
Что касается netlink со стороны пользовательского пространства в сети много информации, например вот:
[RFC 3549 — Linux Netlink как протокол для служб IP](http://rfc2.ru/3549.rfc)
[Работа с NetLink в Linux. Часть 1](http://www.programmersclub.ru/%D0%A0%D0%B0%D0%B1%D0%BE%D1%82%D0%B0-%D1%81-netlink-%D0%B2-linux-%D0%A7%D0%B0%D1%81%D1%82%D1%8C-1/)
[Простой монитор сетевых интерфейсов Linux, с помощью netlink](http://habrahabr.ru/blogs/nix/121254/)
Поэтому здесь я расскажу только то, что нам понадобится, чтобы обеспечить обмен информацией между модулем ядра и программами пользовательского пространства.
Netlink сокет создается привычной функцией: **int socket(PF\_NETLINK, socket\_type, netlink\_family);**
Где в качестве **socket\_type** могут использоваться как *SOCK\_RAW*, так и *SOCK\_DGRAM*; несмотря на это, протокол netlink не проводит границы между датаграммными и raw-сокетами. А **netlink\_family** выбирает модуль ядра или группу netlink для связи. В можно [посмотреть полный список семейств](http://paste.ubuntu.com/840198/).
Сообщения netlink представляют собой поток байтов с одним или несколькими заголовками **nlmsghdr** (netlink message header). Для доступа к байтовым потокам следует использовать только макросы *NLMSG\_\**. Хочу еще обратить внимание, что протокол netlink не обеспечивает гарантированной доставки сообщений. При нехватке памяти или возникновении иных ошибок протокол может отбрасывать пакеты.
Рассмотрим [структуры sockaddr\_nl, nlmsghdr (), iovec и msghdr ()](http://paste.ubuntu.com/836140/), с которыми будем работать:
**struct sockaddr\_nl** — описывает адреса netlink для пользовательских программ и модулей ядра. Структура используется для описания отправителя или получателя данных.
```
struct sockaddr_nl
{
sa_family_t nl_family; /* семейство протоколов AF_NETLINK */
unsigned short nl_pad; /* заполнение нулями */
__u32 nl_pid; /* содержит идентификатор процесса или 0, если сообщение адресовано ядру, либо отправитель является ядром */
__u32 nl_groups; /* netlink имеет 32 multicast-группы. nl_groups содержит битовую маску групп, которым следует слышать сообщение по умолчанию установлено нулевое значение, которое отключает групповую передачу сообщений */
};
```
**struct nlmsghdr** – заголовок сообщения netlink и сразу за структурой в памяти расположены отправляемые/принимаемые данные, для доступа к ним используйте *NLMSG\_DATA(struct nlmsghdr \*)* макрос.
```
struct nlmsghdr
{
__u32 nlmsg_len; /* размер сообщения с учетом заголовка */
__u16 nlmsg_type; /* тип сообщения (содержимое) */
__u16 nlmsg_flags; /* стандартные и дополнительные флаги */
__u32 nlmsg_seq; /* порядковый номер (сообщение может быть разбито на несколько структур) */
__u32 nlmsg_pid; /* идентификатор процесса (PID), открывшего сокет */
};
```
**struct iovec** — находится в *msghdr*, в ней будет содержаться указатель на структуру *nlmsghdr*.
```
struct iovec
{
void * iov_base; /* указатель на данные (указатель на nlmsghdr) */
size_t iov_len; /* длина (размер) данных */
};
```
**struct msghdr** – содержит указатель на адрес (*sockaddr\_nl*) и данные (*iovec*)
```
struct msghdr
{
void * msg_name; /* адрес отправителя или получателя */
socklen_t msg_namelen; /* длина адреса */
struct iovec * msg_iov; /* указатель на данные */
size_t msg_iovlen; /* длинна данных */
void * msg_control; /* буфер для разнообразных вспомогательных данных */
size_t msg_controllen; /* длина буфера вспомогательных данных */
int msg_flags; /* флаги принятого сообщения */
};
```
Рассмотрим некоторые макросы Netlink:
```
int NLMSG_ALIGN(size_t len);
```
Округляет размер сообщения netlink до ближайшего большего значения, выровненного по границе.
```
int NLMSG_LENGTH(size_t len);
```
Принимает в качестве параметра размер поля данных и возвращает выровненное по границе значение размера для записи в поле nlmsg\_len заголовка nlmsghdr.
```
int NLMSG_SPACE(size_t len);
```
Возвращает размер памяти (в байтах), который займет структура nlmsghdr плюс данные указанной длины len (в байтах) в пакете netlink.
```
void *NLMSG_DATA(struct nlmsghdr *nlh);
```
Возвращает указатель на данные, связанные с переданным заголовком nlmsghdr.
```
struct nlmsghdr *NLMSG_NEXT(struct nlmsghdr *nlh, int len);
```
Возвращает следующую часть сообщения, состоящего из множества частей. Макрос принимает следующий заголовок nlmsghdr в сообщении, состоящем из множества частей. Вызывающее приложение должно проверить наличие в текущем заголовке nlmsghdr флага NLMSG\_DONE – функция не возвращает значение NULL при завершении обработки сообщения. Второй параметр задает размер оставшейся части буфера сообщения. Макрос уменьшает это значение на размер заголовка сообщения.
```
int NLMSG_OK(struct nlmsghdr *nlh, int len);
```
Возвращает значение TRUE (1), если сообщение не было усечено и его разборка прошла успешно.
```
int NLMSG_PAYLOAD(struct nlmsghdr *nlh, int len);
```
Возвращает размер данных, связанных с заголовком nlmsghdr.
[Часть исходного кода сервера Shifter с Netlink.](http://paste.ubuntu.com/842612/)
##### Netlink Kernel Space
При использовании библиотеки netlink в модулях ядра есть некоторые отличия, например, структура [nlmsghdr из](http://paste.ubuntu.com/836140/) остается той же, но уже заворачивается в хорошо знакомую нам структуру [sk\_buff](http://paste.ubuntu.com/842915/). И вместо привычных функций для работы с сокетами будем использовать новый набор функций. Рассмотрим некоторые из них.
В модуле сокет представляется не типом *int*, а **структурой sock** из . [struct sock](http://paste.ubuntu.com/841349/) – очень большая я не буду ее описывать, к тому же ее описание и не понадобиться.
Для создания netlink сокета в имеется функция **netlink\_kernel\_create**. Она не только создает netlink сокет, но и регистрирует функцию, которая будет вызываться всякий раз, когда поступят данные.
```
struct sock *netlink_kernel_create(
struct net *net,
int unit,
unsigned int groups,
void (*input)(struct sk_buff *skb),
struct mutex *cb_mutex,
struct module *module);
```
Чтобы закрыть netlink сокет и удалить «регистрацию функции» воспользуйтесь:
```
void netlink_kernel_release(struct sock *sk);
```
Еще нам понадобятся [функции из](http://paste.ubuntu.com/841454/) , там вы можете найти функции с изумительным описанием.
Я просто сделаю перевод некоторых нужных функций:
```
/**
* nlmsg_new – выделяет память для нового netlink сообщения
* @payload: размер данных сообщения
* @flags: тип памяти для выделения
*
* Используйте NLMSG_DEFAULT_SIZE, если размер данных не известен
*/
static inline struct sk_buff *nlmsg_new(size_t payload, gfp_t flags)
{
return alloc_skb(nlmsg_total_size(payload), flags);
}
/**
* nlmsg_put - Добавляет новое сообщение NetLink в skb пакет
* @skb: буфер сетевого пакета для netlink сообщения
* @pid: идентификатор процесса
* @seq: порядковый номер сообщения
* @type: тип сообщения
* @payload: длина передаваемых данных (полезных данных)
* @flags: флаги сообщений
*
* Возвращает NULL, если для skb пакета выделено меньше памяти,
* чем необходимо для размещения заголовка и данных netlink сообщения,
* иначе указатель на netlink сообщение
*/
static inline struct nlmsghdr *nlmsg_put(struct sk_buff *skb, u32 pid, u32 seq,
int type, int payload, int flags)
/**
* nlmsg_unicast – передает индивидуальное netlink сообщение
* @sk: netlink сокет
* @skb: сетевой пакет с netlink сообщением
* @pid: netlink идентификатор сокета назначения
*/
static inline int nlmsg_unicast(struct sock *sk, struct sk_buff *skb, u32 pid)
/**
* nlmsg_data – возвращает указатель на полезные данные
* @nlh: заголовок netlink сообщение
*/
static inline void *nlmsg_data(const struct nlmsghdr *nlh)
{
return (unsigned char *) nlh + NLMSG_HDRLEN;
}
```
[Осталось дописать Module Shifter.](http://paste.ubuntu.com/842613/)
#### Заключение
В заключение скажу, чтобы перенаправить пакеты на прокси-сервер, достаточно на шлюзе добавить правило в iptables:
```
# для таблицы nat добавить правило (-A) в точку PREROUTING
# для протокола tcp и порта назначения 443 сделать редирект на 443 порт
iptables -t nat -A PREROUTING -p tcp --dport 443 -j REDIRECT --to-port 443
```
[Скачать архив с исходниками Shifter](http://shifter-proxy.googlecode.com/files/Shifter.tar.gz)
##### Конец.
#### Используемая и полезная литература
[NetFilter.org](http://www.netfilter.org)
[Linux, Kernel, Firewall](http://www.hackzona.ru/hz.php?name=News&file=article&sid=3605)
[Kernel Korner — Why and How to Use Netlink Socket](http://www.linuxjournal.com/node/7356/print)
[RFC 3549 — Linux Netlink как протокол для служб IP](http://rfc2.ru/3549.rfc)
[Работа с NetLink в Linux. Часть 1](http://www.programmersclub.ru/%D0%A0%D0%B0%D0%B1%D0%BE%D1%82%D0%B0-%D1%81-netlink-%D0%B2-linux-%D0%A7%D0%B0%D1%81%D1%82%D1%8C-1/)
[Протокол netlink в Linux](http://www.protocols.ru/modules.php?name=News&file=article&sid=67) | https://habr.com/ru/post/138328/ | null | ru | null |
# Yet another kaspersky crackme
Сей раз ЛК выпустила на свет шесть крякми, два из которых были написаны на ~~человеческом языке~~ С. Приступим к анализу. [Линк](https://events.kaspersky.com/crackme/tasks), [архив](https://web.archive.org/web/20171126124003/https://events.kaspersky.com/crackme/tasks), [семпл из статьи](https://filebin.ca/3l0Xv6SrFmSl).
**SHADOW**
В описании к заданию написано:
> «Ollydbg не спасет Вас, исследователи! Игра будет вестись в темных уголках ядра операционной системы. Хватит ли Вам смелости узнать потаенные места виртуальной реальности? Shadow ждет вас, найдите его!»
Намек ясен. Делаем пару прогонов анализаторами нашего образца:
**Убрано под спойлер**
Оке, все чисто. Cмотрим импорт:
**Убрано под спойлер**
На данном этапе, не копая дизасм листинг (он кст небольшой, см смещение 00402310), можно понять логику работы приложения:
1. Подгружается драйвер (CreateService)
2. Ему передаются некие параметры (DeviceIoControl)
3. Драйвер что-то делает
4. ???
Очевидно, нам необходимо выцепить драйвер. Загружаем r3 отладчик архетипа «Оля», ставим бряк на CreateServiceA, DeviceIoControl и клацаем F9 (антиотладка отсутствует). Сразу же срабатывает точка останова на CreateServiceA, вот так выглядит стек:
**Убрано под спойлер**
Замечаем путь к нашему драйверу, копируем его куда-нибудь. Клацаем F9, ловим еще одну остановку на этой же функции:
**Убрано под спойлер**
Вам может показаться, что это один и тот же драйвер, однако присмотритесь внимательнее: названия чуть-чуть отличаются. Его тоже сохраним. Клацаем F9, перед нами появляется консолька с просьбой ввести некие данные:
**Убрано под спойлер**
Вводим рандом, отправляем. Сразу же срабатывает бряк на DeviceIoControl:
**Убрано под спойлер**
Здесь мы можем лицезреть нашу связку меил : сериал, которая передается третьим и пятым параметром соответственно. Четвертый и шестой аргумент — размер буферов (с учетом нуля). Трассируем в отладчике до ret, затем еще до одного. В результате увидим такую картину:
**Убрано под спойлер**
Иными словами, если DeviceIoControl вернул ненулевое значение — крякми решен. Что ж, перейдем к изучению первого драйвера. DriverEntry:
**Убрано под спойлер**
Обработчик DeviceIoControl:
**Убрано под спойлер**
Заветная Validate:
**Убрано под спойлер**
Обратить эту функцию не составит труда. Однако давайте вспомним, что у нас существует и второй драйвер, про который мы пока ничего не знаем. Его DriverEntry:
**Убрано под спойлер**
Интересное кино! Выглядит как самый настоящий драйвер-фильтр. Глянем обработчик:
**Убрано под спойлер**
Что мы здесь видим:
1. Функция ValidateStr отвечает за дополнительную валидацию наших первичных данных: допускаются только символы A..Z + a..z + 0..9 + '.' + '@'. Я бы оторвал руки человеку, который добавил такую проверку — лично мой меил не проходит ее, в нем содержится символ '-'
2. Функция ModifyMail изменяет наш меил следующим образом:
**Убрано под спойлер**
3. IofCallDriver передает управление основному драйверу с уже измененными данными
Таким образом, учтя все проверки, можно набросать что-то типа этого:
**Убрано под спойлер**
```
#include "main.h"
char mail[257];
char hashes[32][33];
void main()
{
for (;;)
{
printf_s("Enter your name (1 chars min and 256 chars max, only A..Z + a..z + '.' + '@'):\n");
fgets(mail, 257, stdin);
int ln = strlen(mail) - 1;
if (mail[ln] == '\n')
mail[ln] = '\x00';
else ln++;
if (ln < 1)
continue;
for (int i = 0; i < ln; i++)
{
if ((mail[i] < '0' || mail[i] > '9') && mail[i] != '.' && mail[i] != '@')
{
if (i & 1)
mail[i] &= 0xDF;
else
mail[i] |= 0x20;
}
} //change chars case
GetMD5(mail, ln, mail);
for (int i = 0; i < 32; i++)
{
if (mail[i] < '0' || mail[i] > '9')
{
mail[i] &= 0xDF;
GetMD5(mail, 32, hashes[i]);
mail[i] |= 0x20;
}
else
GetMD5(mail, 32, hashes[i]);
}
for (int i = 0; i < 32; i++)
mail[i] = hashes[i][i];
printf("%s\n", mail);
}
}
```
Функция GetMD5 самая стандартная, взятая [отсюда](http://www.sources.ru/builder/faq/118.html). Компилируем, запускаем:
**Убрано под спойлер**
Solved. На этом прощаюсь. | https://habr.com/ru/post/343342/ | null | ru | null |
# Вышла Opera 9.2
Вышла финальная версия [Opera 9.20](http://www.opera.com/download/).
Основные нововведения:
* появилась панель *Быстрого набора* (Speed Dial), которая появляется при открытии новой вкладки и [показывает](http://www.opera.com/img/products/desktop/screenshots/speeddial.jpg) до 9 миниатюр наиболее часто используемых сайтов. Также предусмотрены горячие клавиши `Ctrl+1..9` (для Mac OS `⌘+1..9`).
* представлены *Инструменты разработчика* ([Developer tools](http://dev.opera.com/tools/)):
+ *Консоль разработчика*, включающая такие инструменты, как Инспектор DOM, Инспектор JavaScript, Редактор CSS, Инспектор заголовков HTML.
[Установить](http://opera:/button/Go%20to%20page,%22javascript%3A(function()%7Bvar%20ele%3Ddocument.documentElement.appendChild(document.createElementNS('http://www.w3.org/1999/xhtml','script'%2C'script'))%3Bele.src%3D'http%3A%2F%2Fdevfiles.myopera.com%2Ftools%2Fdeveloper%2F8679%2FdevConsole.js'%3Bele.parentNode.removeChild(ele)%3B%3B%7D)()%22,,,%22Panel%20Bookmarks%22)
+ *Консоль DOM*, предлагающая расширенные возможности по работе с DOM.
[Установить](http://opera:/button/Go%20to%20page,%22javascript%3A(function()%7Bvar%20ele%3Ddocument.getElementsByTagName('head')%5B0%5D.appendChild(document.createElement('script'))%3Bele.type%3D'text%2Fjavascript'%3Bele.src%3D'http%3A%2F%2Fdevfiles.myopera.com%2Farticles%2F59%2FdomConsole_2.js'%3Bele.parentNode.removeChild(ele)%3BdomConsole_2.open()%3B%7D)()%3B%22%2C%20%2C%20%22DOM%20Console%22%2C%20%22Panel%20Bookmarks%22)
+ *Редактор CSS*, позволяющий налету изменять, добавлять и удалять стили и сразу же применять их к странице.
[Установить](http://opera:/button/Go%20to%20page,%22javascript%3A(function()%7Bvar%20ele%3Ddocument.getElementsByTagName('head')%5B0%5D.appendChild(document.createElement('script'))%3Bele.type%3D'text%2Fjavascript'%3Bele.src%3D'http%3A%2F%2Fdevfiles.myopera.com%2Farticles%2F59%2FstyleSheets.js'%3Bele.parentNode.removeChild(ele)%3BcssConsole.open()%3B%7D)()%3B%22%2C%20%2C%20%22CSS%20Editor%22%2C%20%22Bookmark%20Unvisited%22)
+ *Снимок DOM* (DOM Snapshot), позволяющий просмотреть исходный код страницы, обработанный парсером.
[Установить](http://opera:/button/Go%20to%20page,%22javascript%3A(function()%7Bvar%20ele%3Ddocument.getElementsByTagName('head')%5B0%5D.appendChild(document.createElement('script'))%3Bele.type%3D'text%2Fjavascript'%3Bele.src%3D'http%3A%2F%2Fdevfiles.myopera.com%2Farticles%2F59%2FliveSource.js'%3Bele.parentNode.removeChild(ele)%3BliveSource.open()%3B%7D)()%3B%22%2C%20%2C%20%22DOM%20Snapshot%22%2C%20%22Select%20author%20mode%22)
* добавлен ряд исправлений безопасности, обработки CSS, фреймов, JavaScript
* кроме того, теперь корректно работает Flickr Organizr и отображается полноэкранное видео на YouTube | https://habr.com/ru/post/6689/ | null | ru | null |
# Maven vs Gradle различия использования в Java-проектах
В данной статье разберемся в практических различиях инструментов для сборки Maven и Gradle. Ведь современным разработчикам катастрофически не хватает времени на погружение во все технологии. Иногда нет времени, что бы прочитать несколько сотен страниц документации по каждому инструменту. Например, на первой работе меня постоянно преследовал стресс из-за того, что я не знаю почти все, что касается настройки и запуска проекта. Так получилось, что с проекта уходил последний java-разработчик. Я должен был принять проект и вести его вместе с другим фронтенд-разработчиком. Я потратил кучу времени на локальный запуск проекта. Но когда все получилось, я закрыл много задач по проекту и получил бесценный опыт. В этой статье я попытаюсь резюмировать свой опыт, который поможет разобраться в сборке многомодульных проектов.
Сначала рассмотрим Maven и его неочевидные настройки, а потом перейдем к Gradle. Для меня Maven оказался проще по сравнению с Gradle, потому что все настройки собраны в одном файле pom.xml. В официальной документации говорится "как только вы ознакомитесь с одним проектом Maven, вы поймете, как строятся все проекты Maven". Это действительно так, но есть пару нюансов. Как правило, приходится вести несколько проектов и все проекты будут хранить зависимости в виде jar-файлов в одном репозитории. Это приводит к тому, что зависимости с более высокой версией будут удалять старые jar-файлы. Это приводит к ошибкам во время сборки проекта.
В таких случаях необходимо настроить отдельный локальный репозиторий для каждого проекта. В настройках Intellij Idea есть вкладка `"Build, Execution, Deployment"`, далее `"Build Tools"` и в ней `Maven`. Для каждого отдельного проекта нужно определить расположение репозитория и файла settings.xml, в котором содержаться пользовательские настройки.
Допустим, у вас несколько проектов с условными названиями - project1, project2, etc. В папке .m2 создаем отдельные директории с такими же названиями, создаем внутри создаем еще одну папку repository и файл settings.xml. В моем случае файл settings создал тимлид, но если нужно создать пользовательские настройки с нуля, то проще всего скопировать глобальные настройки Maven в качестве основы и подредактировать, как будет показано ниже.
Глобальные настройки можно найти в папке conf в директории установки Мавен, если он у вас установлен. Если нет, тогда Вы можете скачать бинарный файл с сайта <https://maven.apache.org/download.cgi>. Итак, копируем файл settings.xml в папку project1 и начинаем его править.
Для начала можно удалить все комментарии для удобочитаемости. Таким образом, первые строки объявляют версию XML и пространство имен:
```
xml version="1.0" encoding="UTF-8"?
```
Это магическая магия для тех, кто не знаком с языком XML, которая является стандартным заголовком в xml-файлах. Если не вдаваться в подробности, то внутри заголовка лежат ссылки на другие xml-файлы, в которых перечисляются так называемые "элементы" (именованные переменные), их значение и тип (напр. name="offline" type="xs:boolean"), минимальное и максимальное количество элементов (minOccurs="0" означает, что этот элемент можно не указывать, minOccurs="1" означает, что элемент нужно указать минимум 1 раз) и пр.
Далее внутри тегов и нужно указать путь до папки repository (например, C:\Users\username.m2\project1\repository). Сохраняем и закрываем файл settings.xml. Смотрим в папке `/.m2` вместо одной директории repository должны лежать отдельные папки на каждый проект.
Далее возвращаемся в IDE, поочередно открываем проекты project1, project2 etc. и указываем путь до репозитория и файла настроек во вкладке Maven ("Build, Execution, Deployment" -> "Build Tools").
После этого, запускаем задачи Maven `clean` и `install`, либо нажимаем кнопку `Reload All Maven Project` в боковой вкладке Maven. Среда разработки закачивает в новый репозиторий все зависимости и плагины. Теперь если зайти в папку .m2/project1/repository, то можно увидеть новые папки с jar-файлами.
Когда вы закончили с настройкой репозитория, можно перейти к настройке микросервисов. В моем случае это был проект с 15 микросервисами и 14 библиотеками, т.е. это были 29 отдельных проектов со своими pom.xml файлами. И даже если вы знакомы с Maven по учебным проектам, то не сразу можно догадаться, как настроить несколько Maven-проектов, что бы они работали вместе и открывались как один проект.
Сначала нужно найти основной проект (в моем случае это был пустой проект с файлами pom.xml и README.md, без без src). Открываем его в среде разработки Idea, раскрываем вкладу Maven и нажимаем кнопку "Add Maven Project".
Далее поочередно добавляем проекты просто выбирая соответствующие файлы pom.xml в каждом отдельном проекте. На этом настройка Maven проекта завершена.
*Прим. Также я столкнулся с двумя сложностями - настройкой БД (Postgres, Liquibase) и Spring Cloud (Eureka, настройка Feign-сервисов, Kafka/Zookeeper). Эти этапы я пропущу, потому что их нужно описать в отдельной статье.*
Теперь перейдем к Gradle. Когда я получил проект с gradle, то долго не мог понять, кто является главным среди всех этих gradle-файлов, то есть где аналог pom.xml в gradle-проектах. На самом деле все оказалось просто - это файл build.gradle. И что бы понять, как работает gradle, я предлагаю создать два пустых проекта - один Maven-проект и один Gradle-проект, а также выполнить пару команд, что бы получить визуальное представление о работе обоих систем сборки.
Итак, создаем две пустые директории. В первой создадим pom.xml со следующими полями:
```
4.0.0
com.example
example
1.0-SNAPSHOT
11
${java-version}
${java-version}
junit
junit
4.13.2
test
```
Далее заходим в терминал по адресу этой папки и вводим команду `mvn clean install`. В директории появилась папка target с jar-файлом проекта. Теперь если открыть проект в Intellij Idea, то во вкладке External Libraries можно увидеть, что подтянулась зависимость - JUnit.
Сделаем такую же операцию с Gradle. Создаем в новой папке файл build.gradle со следующим содержанием:
```
plugins {
id 'java'
}
repositories {
mavenCentral()
}
dependencies {
testImplementation group: 'junit', name: 'junit', version: '4.13.2'
}
```
Заходим в терминал по адресу этой папки и вводим команду `gradle wrapper`. В директории появилась две папки - .gradle и gradle (в первой хранится кэш проекта, во втором тонкий jar для gradle, который позволяет запускать gradle-команды на машинах, где не установлен Gradle) и два исполняемых файла - gradlew (для unix-систем) и gradlew.bat (для windows). Аналогично предыдущему примеру в IDE можно увидеть, что в External Libraries уже загрузилась зависимость JUnit.
Если у вас все получилось, то эти два шаблона можно использовать для разработки новых проектов, добавляя зависимости Spring Boot.
Еще одна сложность, с которой я столкнулся в в gradle-проекте, заключается в том, что нужно потратить некоторое время на изучение Groovy (я выбрал Groovy, а не Kotlin). С помощью Groovy можно написать задачи (`task`), т.е. такой скрипт по сборке проекта. Или можно использовать плагины, которые импортируют в проект готовые задачи. Например, `apply plugin 'java'` позволяет использовать такие команды как `gradle compileJava, jar, javadoc` etc.
Список плагинов и импортируемых задач можно посмотреть [на официальном сайте Gradle](https://docs.gradle.org/current/userguide/plugin_reference.html). Но если у вас есть действующий проект и вас просто нужно узнать какие задачи можно выполнить, то воспользуйтесь командой `gradle tasks` для вывода на экран всех доступных задач с их описанием.
P.S. Переходя с удаленки в офис и обратно, я сталкивался с такой проблемой, что мои записи с готовыми командами и шпаргалками не оказывались под рукой. Есть разные пути решения этой проблемы. Я решил создать [Телеграм-канал](https://t.me/JavaDevMQ), на котором я буду публиковать свои заметки и шпаргалки по веб-разработке, а также статьи о реальном практическом опыте на коммерческих проектах. | https://habr.com/ru/post/649987/ | null | ru | null |
# Решаем проблему с кешированием динамического JavaScript кода на фронтенд WordPress
В процессе разработки анти-спам плагина [CleanTalk](https://cleantalk.org) для WordPress мы стокнулись с проблемой кеширования динамического JavaScript кода на фронтенде сайтов. А именно, если разместить JavaScript содержащий какие либо куски кода динамически подставляемые из бекенд сайта, то при наличии на сайте любого плагина кеширования страниц, JavaScript код становится не возможно использовать по назначению.
Рассмотрим пример
-----------------
В бэкенд у нас есть шаблон JavaScript кода,
```
php
$html = '
<script type="text/javascript"
function ctSetCookie(c_name, value, def_value) {
document.cookie = c_name + "=" + escape(value.replace(/^def_value$/, value)) + "; path=/";
}
ctSetCookie("%s", "%s", "%s");
';
$ct_checkjs_key = rand(0,100); // Значение переменной динамическое
$field_name = 'ct_checkjs'; // Значение статическое
$ct_checkjs_def = 0; // Значение статическое
$html = sprintf($html, $field_name, $ct_checkjs_key, $ct_checkjs_def);
?>
```
Пример вывода на фронтенд,
```
function ctSetCookie(c\_name, value, def\_value) {
document.cookie = c\_name + "=" + escape(value.replace(/^def\_value$/, value)) + "; path=/";
}
ctSetCookie("ct\_checkjs", "455", "0");
```
Соответственно в кеш попадает JavaScript код в котором параметр value функции ctSetCookie неизменен на всех страницах сайта и одинаков для всех посетителей, что приводит к невозможности использования JavaScript персонально для каждого посетителя. Рассмотрим варианты решения.
Используем встроенные средства отключения кеширования
-----------------------------------------------------
Если плагин кеширования контента на WordPress более-менее популярен, то у него обазятельно есть средства для исключения списка страниц из кеша. К примеру для WP Super cache можно указать в коде вашего плагина строчку,
```
define( "DONOTCACHEPAGE", true );
```
Этого будет достаточно чтобы страницы с вашим динамическим кодом не попадали в кеш. Минусы такого подхода,
* Необходимо интегрировать и тестировать ваш плагин с популярными плагинами кеширования.
* Все равно будут случаи когда ваш код некорректно отрабатывают, по причине того, что на том или ином сайте установле редко используемый плагин кеширования.
* Ну и самое главное, такой подход сводит практически к 0 применение плагинов кеширования, если ваш JavaScript код размещается на всех страницах сайта, либо на наиболее нагруженных страницах.
Посмотрим на другой вариант решения.
AJAX вызов в бэкенд
-------------------
Суть этого подхода в том, что на фронтенде размещаем только статичный JavaScript код, а все что требуется использовать динамически получаем из бекэнд сайта через AJAX вызов. Пример кода на фротенд,
```
//
// Делаем вызов к admin-ajax.php
//
function sendRequest(url,callback,postData) {
var req = createXMLHTTPObject();
if (!req) return;
var method = "GET";
req.open(method,url,true);
if (postData)
req.setRequestHeader('Content-type','application/x-www-form-urlencoded');
req.onreadystatechange = function () {
if (req.readyState != 4) return;
if (req.status != 200 && req.status != 304) {
return;
}
callback(req);
};
if (req.readyState == 4) return;
req.send(postData);
return null;
}
var XMLHttpFactories = [
function () {return new XMLHttpRequest()},
function () {return new ActiveXObject("Msxml2.XMLHTTP")},
function () {return new ActiveXObject("Msxml3.XMLHTTP")},
function () {return new ActiveXObject("Microsoft.XMLHTTP")}
];
function createXMLHTTPObject() {
var xmlhttp = false;
for (var i=0;i
```
Прошу обратить внимание на конструкцию,
```
ct_ajaxurl+'?'+Math.random()
```
Такой прием используется для исключения кеширования в том числе и AJAX вызов.
Двигаемся к последнему листингу, посмотрим на бэкенд,
```
add_action( 'wp_ajax_nopriv_ct_get_cookie', 'ct_get_cookie',1 );
/**
* Возвращает новую куку
*/
function ct_get_cookie()
{
global $ct_checkjs_def;
$ct_checkjs_key = ct_get_checkjs_value(true);
print $ct_checkjs_key;
die();
}
```
Минус у такого подхода только в одном — ваш плагин делает на 1 вызов в бэкенд WordPress больше. С учетом того, что хостинг может быть не самым быстрым, либо на WordPress может быть установлено не один десяток плагинов, такой вызов приведет к увеличению времени ответа сайта.
Успехов в разработке под WordPress! | https://habr.com/ru/post/281955/ | null | ru | null |
# Игровой сервер на Scala + Akka
Когда-то давно я уже поднимал тему применения Scala в игровом сервере. Тогда это был совсем простой пример использующий только Scala. С тех времен много воды утекло. Scala и Akka развиваются, но статей по ним что-то не прибавляется. А тема очень интересна. В общем хочется продолжить цикл статей про сервер на Scala. В этой статье будет описана общая архитектура решения. А так же что дает использование Scala и Akka. Примеры кода.
Так в чем же суть? Что такого особенного в использовании этой связки?
#### Дискляймер.
Тек кто шарит в теме, могут найти неточности и упрощения в описании. Так и было задумано. Я хотел показать общие моменты для тех, кто не знает что это и как это можно использовать. Но тем не менее, всем добро пожаловать в каменты. Надеюсь на конструктивное обсуждение и жаркие холивары) Ибо частенько, в холиварах, всплывают моменты о которых обычно не задумываешься, но которые играют существенную роль.
#### Что такое Akka, и почему это хорошо
Если не вдаваться в подробности, то разработка на акторах исходит из философии, что все круг акторы. Так же как и ООП исходит из философии, что все круг объекты. Принципиальные отличия же состоят в том, что акторы выполняются параллельно. В то время как ООП код выполняется последовательно и для параллельного исполнения надо делать дополнительные и далеко не всегда простые действия. А так же акторы взаимодействуют между собой не через вызовы методов у объектов, как в ООП, а через отправку сообщений. В акторе есть очередь этих сообщений (mailbox). Сообщения обрабатываются строго по очереди.
Акторы в Akka, описываются как легковесные потоки (green threads). Создание такого актора почти ничего не стоит, их можно создать миллионы. Создатели декларируют, что на 1Gb памяти можно создать порядка 2.5млн акторов. И на одной машине можно достичь скорости обмена порядка 50млн сообщ/сек.
Ну и что с того? Спросите вы. В чем профит от всего этого?
А профит в общем-то очевидный. Код получается слабосвязанным, актору не нужна прямая ссылка другой актор, чтобы отправить ему сообщение. В модели акторов, отсутствует разделяемое состояние. Сообщения приходящие в акторы, обрабатываются последовательно. Получается, что актор не зависит ни от кого. Данные в нем не надо синхронизировать с другими акторами, а код, в отдельно взятом акторе, выполняется «в одном потоке». Ну а как известно, писать однопоточный код гораздо проще чем многопоточный. Но так как у нас акторы выполняются параллельно, то в итоге вся система работает параллельно, равномерно утилизируя все доступное железо. В целом надежность системы получается выше.
Есть мнение (и я его разделяю), что вот как раз акторы и есть самая правильная реализация ООП. Ибо в жизни, например, если мне надо взять молоток, а я до него дотянуться не могу, то я не управляю непосредственно рукой соседа который мне подает молоток. Я говорю ему (по сути посылаю устное сообщение) «подай молоток». Он его принимает, обрабатывает и подает молоток.
Конечно это очень простое описание сложной системы. У Akka очень много возможностей. Те же очереди в акторе могут быть реализованы разными способами. Например иметь ограничение по размеру, или сохраняться в БД, или иметь определенную сортировку. Да и никто собственно не мешает реализовать свою очередь с шахматами и поэтессами. Что еще особенного? Акторы могут исполняться на разных механизмах JVM. Например на пуле потоков или на Fork Join пуле (по умолчанию используется именно он). Можно управлять потоками, выделяя для какого-то актора отдельный поток или даже пул потоков. Акторы могут работать как в пределах одной машины так и по сети. Есть кластер «из коробки».
Чтобы послать актору сообщение, надо знать его адрес или иметь ссылку в виде ActorRef. Адресная система имеет древовидную систему. Например «akka://sessions/id12345». Это адрес актора отвечающего за обработку сообщений в сессии игрока id12345.
Ему можно послать сообщение:
```
context.actorSelection(«akka://sessions/id12345») ! Msg
```
Или послать сообщение всем подключенным игрокам
```
context.actorSelection(«akka://sessions/*») ! Msg
```
В общем чтобы было понятнее, приведу простой пример. Сразу скажу, пример высосан из пальца, просто чтобы показать варианты. Допустим надо игрокам рассылать периодически сообщения на почту. Что может быть проще? Делаем класс какой нибудь, в нем метод принимающий адрес и сообщение. Все в общем-то банально. Но тут игра стала популярной и количество писем стало расти. Распишу как это может выглядеть в Akka.
Вы создаете актор, который принимает сообщение в виде класса с 2 полями (в Scala это будет простой case class):
```
Email(String address, String msg)
```
В обработчике описываете отправку сообщения
```
def receive = {
case evt: Email(address, msg) ⇒ sendEmail(address, msg)
}
```
Все в общем-то. Теперь этот актор будет получать свой кусочек ресурсов железа и отправлять почту.
Тут приходит толпа народа, и система стала тормозить с отправкой почты. Заходим в конфиг и выделяем этому актору отдельный поток, чтобы он меньше зависел от другой нагрузки.
Толпа еще растет. Заходим в конфиг и выделяем актору пул потоков.
Толпа еще растет. Переносим актор на отдельный комп, он начинает потреблять все железо этого компа.
Толпа еще растет. Выделяем несколько машин, создаем кластер и теперь у нас отправкой почты занимается целый кластер.
При всем при этом, код нашего актора не меняется, мы все это настраиваем через конфиг.
Все приложение даже не в курсе, что актор куда-то переехал и по сути является уже кластером, ему также на адрес «/mailSender» отправляют сообщения.
Каждый может представить, сколько телодвижений надо будет сделать, чтобы реализовать такую систему в классическом варианте на ООП и потоках. Понятно, что пример притянут за уши и трещит по швам. Но если не занудствовать, то вполне можно представить какой-то свой личный опыт в таком ракурсе.
##### Но где-же сервер ?
С акторами примерно разобрались. Попробуем с проектировать игровой сервер с применением этой модели. Так как у нас теперь все является акторами, то мы описываем через акторы в первую очередь основные элементы сервера, без учета особенностей конкретной игры.
На схеме показано как может выглядеть сервер в этом случае.
**Front Actor** – Актор отвечающий за общение с клиентами. Их подключение, отключение и контролирует сессии. Является супервизором для актора **S**
**S** – Пользовательские сессии. Собственно в данном случает, это открытые сокет соединения. Актор отвечает непосредственно за передачу и прием сообщений от клиента. И является дочерним по отношению к **FrontActor**.
**Location Actor** – Актор отвечающий за обработку какой-то области в игровом мире. Например часть карты или комнату.
Еще можно создать актор для работы с БД, но мы его пока рассматривать не будем. Работа с БД обычна и описывать там особо нечего.
Вот собственно и весь сервер. Что же мы получили?
У нас есть актор, который отвечает за сетевое взаимодействие. В Акка встроено высокоэффективное сетевое ядро, из коробки поддерживающее TCP и UDP. Поэтому для создания фронта, надо сделать очень мало телодвижений. Наш актор принимает коннект от клиента, создает для него сессию и в дальнейшем, вся отправка и прием сообщений идет через него.
Фронт актор выглядит примерно так:
```
class AkkaTCP( address: String, port: Int) extends Actor
{
val log = Logging(context.system, this)
override def preStart() {
log.info( "Starting tcp net server" )
import context.system
val opts = List(SO.KeepAlive(on = true),SO.TcpNoDelay(on = true))
IO(Tcp) ! Bind(self, new InetSocketAddress(address, port), options = opts )
}
def receive = {
case b @ Bound(localAddress) ⇒
// do some logging or setup ...
case CommandFailed(_: Bind) ⇒ context stop self
case c @ Connected(remote, local) ⇒
log.info( "New incoming tcp connection on server" )
val framer = new LengthFieldFrame( 8192, ByteOrder.BIG_ENDIAN, 4, false )
val init = TcpPipelineHandler.withLogger(log, framer >> new TcpReadWriteAdapter )
val connection = sender
val sessact = Props( new Session( idCounter, connection, init, remote, local ) )
val sess = context.actorOf( sessact , remote.toString )
val pipeline = context.actorOf(TcpPipelineHandler.props( init, connection, sess))
connection ! Register(pipeline)
}
}
```
Сессия выглядит примерно так:
```
// ----- Класс-сообщение реализующий команду отправки на клиент
case class Send( data: Array[Byte] )
// -----
class Session( val id: Long, connect: ActorRef,
init: Init[WithinActorContext, ByteString, ByteString],
remote: InetSocketAddress,
local: InetSocketAddress ) extends Actor
{
val log = Logging(context.system, this)
// ----- actor -----
override def preStart() {
// initialization code
log.info( "Session start: {}", toString )
}
override def receive = {
case init.Event(data) ⇒ receiveData(data) // Обрабатываем получение сообщения
case Send(cmd, data) ⇒ sendData(cmd, data) // Обрабатываем отправку сообщения
case _: Tcp.ConnectionClosed ⇒ Closed()
case _ => log.info( "unknown message" )
}
override def postStop() {
// clean up resources
log.info( "Session stop: {}", toString )
}
// ----- actions -----
def receiveData( data: ByteString ) {
...
// Распаковываем сообщение, отправляем по назначению
}
def sendData( cmd: Int, data: Array[Byte] ) {
val msg: ByteString = ByteString( ... ) // Упаковываем сообщение
connect ! Write( msg ) // отправляем
}
def Closed(){
context stop self
}
// ----- override -----
override def toString =
"{ Id: %d, Type:TCP, Connected: %s, IP: %s:%s }".format ( id, connected, clientIpAddress, clientPort )
}
```
В результате, нам не надо думать, сколько потоков выделить для приема отправки сообщений, как они будут синхронизироваться и т. д. Код очень простой.
Так же у нас есть актор отвечающий за локации (или комнаты).
Он более сложный, так как он будет обрабатывать команды, для расчета игровой ситуации. В самом простейшем случае это можно сделать внутри него же. Но лучше выделить отдельный актор для расчета игровой механики. Если это пошаговая игра, то дополнительно делать ничего не надо, просто получать команду и делать расчет. Если же это какая-то реалтайм игра, то в нем уже надо будет реализовывать игровой цикл, который каждые N мс будет собирать пришедшие команды, делать расчет и готовить реплики результатов для отправки их игрокам из этой локации. Под каждый такой актор можно выделить свой поток.
В реальном проекте конечно же надо будет усложнять схему. Добавлять актор супервизор, который будет рулить комнатами. Создавать их когда надо, и удалять за ненадобностью. В зависимости от сложности игровой механики, можно усложнить сам механизм расчета, например выделив под него отдельный сервер.
Вот как может выглядеть такой актор:
```
class Location( name: String ) extends Actor
{
val log = Logging(context.system, this)
// ----- actor -----
override def preStart() {
log.info( "Room start: {}", name )
}
override def receive = {
case evt: Event ⇒ handleEvent( evt )
case cmd: Command ⇒ handleCommand( cmd )
case _ => log.info( "unknown message" )
}
override def postStop() {
// clean up resources
log.info( "Room stop: {}", name )
}
// ----- handles -----
def handleEvent( evt: Event ) = {
}
def handleCommand( cmd: Command ) = {
// Пример отправки реплики отправителю команды
cmd.sender ! Send( "gamedata".getBytes )
}
}
```
Command – Это сообщение от клиента, какая-то команда. Например Выстрел, движение, активация заклинания.
Event – это внутреннее событие сервера. Например создание моба или переключение времени дня.
Если есть интерес, можно продолжить и разобрать код какого-то рабочего варианта. Или же про Akka подробнее, с примерами. | https://habr.com/ru/post/229045/ | null | ru | null |
# Part 2: Upsetting Opinions about Static Analyzers
By writing the article "Upsetting Opinions about Static Analyzers" we were supposed to get it off our chest and peacefully let it all go. However, the article unexpectedly triggered robust feedback. Unfortunately, the discussion went in the wrong direction, and now we will make a second attempt to explain our view of this situation.
Joke to the topic
-----------------
It all started with the article "[Upsetting Opinions about Static Analyzers](https://www.viva64.com/en/b/0765/)". It came into a question on some resources and that discussion reminded me of an old joke.
> Some tough Alabama loggers once got a fancy Japanese gas chainsaw.
>
> They gathered around and decided to give it a try.
>
> Started it up and shoved it a thin tree.
>
> "Whoosh," said the Japanese saw.
>
> "Oh, my ..." said the loggers.
>
> They gave it a thicker tree. "Whoooosh!", said the saw.
>
> "Ugh, damn it!" said the loggers.
>
> A thick cedar came next. "WH-WH-WH-WH-OOOOOOSH!!!" said the saw.
>
> "Wow, holy shit!!"— said the loggers.
>
> They gave it a crowbar. "BANG!" said the saw.
>
> "Oh crap, gotcha!!!"— reproachfully yelled tough Alabama loggers! And went to cut down forest with axes...
This story is just one and the same. People looked at this code:
```
if (A[0] == 0)
{
X = Y;
if (A[0] == 0)
....
}
```
And started coming up with cases when it might be justified, which means that the PVS-Studio analyzer warning was a false-positive. Some speculations about the change in memory between two checks came into play which occurs due to:
* running parallel threads;
* signal/interrupt handlers;
* the variable *X* is a reference to the element *A[0]*;
* hardware, such as performing DMA operations;
* and so on.
After heated debate on the analyzer's inability to comprehend all cases, they left to cut down forest with axes. In other words, they found an excuse why they could still avoid using a static code analyzer in their work.
Our view of this case
---------------------
This approach is counterproductive. An imperfect tool may well be useful, and its use will be economically feasible.
Yes, any static analyzer issues false-positive warnings. There's nothing we can do about it. However, this misfortune is greatly exaggerated. In practice, static analyzers can be configured and used in various ways to suppress and deal with false positives (see [1](https://www.viva64.com/en/b/0743/), [2](https://www.viva64.com/en/m/0040/), [3](https://www.viva64.com/en/b/0523/), [4](https://habr.com/en/post/440610/)). In addition, it is fitting here to recall the article "[False positives are our enemies, but may still be your friends](https://blog.sonarsource.com/false-positives-our-enemies-but-maybe-your-friends)".
On the other hand, even this is not the main thing. **Special cases of exotic code do not make sense to consider at all!** Can complex code confuse the analyzer? Yes, it can. At the same time, for one such case, there will be hundreds of useful analyzer findings. You can find and fix a lot of errors at the earliest stage. As for one or two false positives, they will be safely suppressed and will not bother you any longer.
PVS-Studio is right once again
------------------------------
This is where the article could end. Nevertheless, some may consider the previous section to be not rational considerations, but attempts to hide the weaknesses and shortcomings of the PVS-Studio tool. So, we'll have to continue.
Let's take look at the actual compiled [code](https://godbolt.org/z/q1fq14) with variable declarations:
```
void SetSynchronizeVar(int *);
int foo()
{
int flag = 0;
SetSynchronizeVar(&flag);
int X, Y = 1;
if (flag == 0)
{
X = Y;
if (flag == 0)
return 1;
}
return 2;
}
```
The PVS-Studio analyzer reasonably issues a warning: V547 Expression 'flag == 0' is always true.
It is perfectly right. If someone starts ranting that a variable can change in another thread, in a signal handler, and so on, they just don't understand the C and C++ language. You just mustn't write code in such a way.
The compiler has the right to throw out the second check for optimization purposes and will be absolutely right. From the language point of view, the variable can't change. Its background change is nothing more than undefined behavior.
For the check to remain in place, the variable must be declared as *volatile*:
```
void SetSynchronizeVar(volatile int *);
int foo()
{
volatile int flag = 0;
SetSynchronizeVar(&flag);
....
}
```
The PVS-Studio analyzer knows about this and no longer issues a warning for such [code](https://godbolt.org/z/bb3srf).
Here we go back to what was discussed in the [first article](https://www.viva64.com/en/b/0765/). There is no problem. Whereas what we have here is criticism or misunderstanding as to why the analyzer has the right to issue a warning.
Note for the most meticulous readers
------------------------------------
Some readers may return to the synthetic example from the first article:
```
char get();
int foo(char *p, bool arg)
{
if (p[1] == 1)
{
if (arg)
p[0] = get();
if (p[1] == 1) // Warning
return 1;
}
// ....
return 3;
}
```
And add *volatile*:
```
char get();
int foo(volatile char *p, bool arg)
{
if (p[1] == 1)
{
if (arg)
p[0] = get();
if (p[1] == 1) // Warning :-(
return 1;
}
// ....
return 3;
}
```
After that, it is fair to note that the analyzer still issues the warning V547 Expression 'p[1] == 1' is always true.
Hooray, finally the analyzer is obviously wrong :). This is a false positive!
As you see, we do not hide any shortcomings. When analyzing the data flow for array elements, this unfortunate *volatile* was lost. This flaw has already been found and fixed. The edit will be available in the next analyzer version. There will be no false positive.
Why wasn't this bug detected earlier? Because in fact, this is again contrived code that is not found in real projects. Truth be told, we haven't seen such code yet, although we have checked a lot of [open projects](https://www.viva64.com/en/inspections/).
Why is the code unrealistic? First, in practice, there will be some sort of synchronization or delay function between the two checks. Second, no one in their right mind creates arrays consisting of volatile elements unless absolutely necessary. Working with such an array is a huge drop in performance.
Let's recap. You can easily create examples where the analyzer makes mistakes. But from a practical point of view, the identified flaws practically do not affect the quality of code analysis and the number of real errors detected. After all, the code of real applications is just code that is understandable to both the analyzer and the person, and is not a quiz or a puzzle. If the code is a puzzle, then there are other things to worry about :).
Thanks for your attention.
[](https://viva64.com/en/pvs-studio-download/?utm_source=habr&utm_medium=banner&utm_campaign=0767_Sadness_2)
Additional links
----------------
* [How to introduce a static code analyzer in a legacy project and not to discourage the team](https://www.viva64.com/en/b/0743/).
* [Additional diagnostics configuration](https://www.viva64.com/en/m/0040/).
* [Characteristics of PVS-Studio Analyzer by the Example of EFL Core Libraries, 10-15% of False Positives](https://www.viva64.com/en/b/0523/).
* [Introduce Static Analysis in the Process, Don't Just Search for Bugs with It](https://habr.com/en/post/440610/). | https://habr.com/ru/post/523692/ | null | en | null |
# .NET в unmanaged окружении: вызов управляемого кода из неуправляемого
Как вы, наверное, помните из моей [предыдущей статьи](http://habrahabr.ru/blogs/net/58031/), взаимодействие unmanaged и managed кода представляет определенную проблему, даже для опытных разработчиков. Причина этого — необходимость понимать, какие процессы происходят при пересечении данными границы CLR.
К сожалению, нередко проблема наладить взаимодействие встает у тех разработчиков, которые слабо знакомы с подноготной технологии COM и возможностями .NET для обеспечения взаимодействия. Это нормально — нельзя знать все на свете. Потому я не буду здесь объяснять всю суть проблемы маршаллинга данных из unmanaged в managed и обратно, а просто дам несколько рабочих рецептов, которые помогут вам тогда, когда нужно срочно и завтра, и вы с тоской смотрите на английское издание книги Inside OLE и понимаете, что разобраться в этом за день нет никакой возможности.
Однако, для тех, кто неплохо в этом разбирается, в конце статьи есть небольшой бонус — способ организации out-process COM на .NET. Честно говоря, я добросовестно считал, что сделать out-process COM с помощью .NET невозможно, однако буквально вчера выяснилось, что все-таки нет, можно. В связи с этим, рассказывать про архитектуру .NET Pipe RPC я скорее всего не буду — она достаточно сложна, однако все предоставляемые ей возможности с легкостью заменяет out-process COM.
Вообще, существует два механизма, предлагаемых Microsoft — это dll export и COM export. Да, именно так — несмотря на то, что о возможности экспорта функций managed-кода мало кто знает, она все-таки есть. Однако, о ней я рассказывать не буду. Дело в том, что экспорт функций не поддерживается .NET на высоком уровне, то есть невозможно просто описать функцию, повесить на нее какой-нибудь атрибут типа [DllExport] и радоваться жизни — придется либо [лезть в дебри IL](http://blog.undsoft.com/programming/export-managed-to-unmanaged/), либо [использовать сторонние решения.](http://netobf.com/obf_optimization_dllexport) Оба решения удовлетворительными назвать нельзя, а потому я не буду на этом подробно останавливаться — практической пользы этот механизм не имеет вовсе.
Механизм COM export хорош тем, что его работа достаточно прозрачна для человека, который разбирается в COM, но для .NET разработчика это темный лес. То есть, для успешной работы с этим механизмом, необходимо понимать, что представляет собой технология COM, как осуществляются вызовы, как следует передавать параметры и прочее. однако, знания есть не у всех, а потому — общие рецепты. Давате попробуем создать inproc-COM сервер на C# и обратиться к нему, например, из VBA. Для этого воспользуемся Excel и его встроенным языком скриптов.
Почему я выбрал Excel? Как показывает опыт работы, VBA является достаточно капризным по отношению к утечкам памяти клиентом — в случае малейшой утечки Excel упадет либо сразу по завершению процедуры, либо по выгрузке dll (то есть где-то через минуту после завершения процедуры). Таким образом, падучесть Excel поможет нам понять, что мы делаем что-то не так.
Начнем, пожалуй. Давайте создадим новую сборку, назовем ее, как это принято, TestInprocCOM и сделаем там один CoClass, который будет реализовывать интерфейсы, через которые мы будем его дергать из VBA.
Но для начала, определимся с тем, что же нам нужно от взаимодействия. Как показывает опыт работы, чаще всего требуется передавать
1. строки
2. массивы
3. структуры
4. другие объекты
Венцом нашей сегодняшней работы будете передача массива структур, в которых лежат строки. Этого хватит для 99% реальных приложений. Для оставшегося 1% информация будет слишком спецефична для широкой аудитории Хабра, а потому я не буду заострять на этом внимания.
Прошу прощения за слишком длинное вступление. Также вынужден извиниться за слишком подробное объяснение многих, на первый взгляд тривиальных вещей — я не знал, каков уровень тех людей, которые будут читать эту статью и хотел сделать ее понятной абсолютно всем.
Итак, приступим.
Реализация inproc COM.
======================
Для начала, определим интерфейс, который будет отвечать за вызовы. Комментарии относительно того, для чего нужна та или иная строка я буду делать прямо в коде, чтобы не увеличивать и без того немаленькие размеры статьи.
> `// Показываем, что интерфейс экспортируется для COM
>
> [ComVisible(true)]
>
> // Определяем интерфейс как дуальный. Таким образом, мы сможем с легкостью работать с ним как с помощью
>
> // механизмов раннего связывания в VBA, так и с помощью позднего связывания. Кроме того, это упрощает работу
>
> // с объектом из C++
>
> [InterfaceType(ComInterfaceType.InterfaceIsDual)]
>
> // Определяем GUID интерфейса. Если этого не сделать - он будет меняться на каждой компиляции, что плохо.
>
> [Guid("5AC0488E-9CAC-4032-B59A-37B8B277C4EF")]
>
> public interface ITestInterface
>
> {
>
> // Для параметров функций COM-интерфейсов я всегда задаю, как именно будет маршаллиться параметр.
>
> // Это позволяет избежать ошибок, связанных с неверными предположениями относительно работы .NET
>
> // Здесь мы маршаллим строку по ссылке как BSTR.
>
> void Hello([MarshalAs(UnmanagedType.BStr)] ref string name);
>
>
>
> // Здесь аналогично, только маршаллинг задается для возвращаемого значения.
>
> [return: MarshalAs(UnmanagedType.BStr)]
>
> string Say();
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Как видите, у каждого параметра появилая атрибут MarshalAs. Именно он говорит, как надо маршаллить параметры при переходе границы CLR. Его не обязательно задавать, если маршаллинг по умолчанию совпадает с тем, какое поведение вам нужно. Однако, строки по умолчанию маршаллятся как LPTStr, а потому для строк маршаллинг в виде BSTR нужно задавать всегда.
> `// Теперь определим CoClass
>
> [ComVisible(true)]
>
> [Guid("B06CC21C-BCBB-4dde-8ED3-BFBD9A31AD6E")]
>
> // ProgId необходим для того, чтобы можно было вызвать объект по имени, а не через GUID
>
> [ProgId("TestInprocCOM.TestCoClass")]
>
> // Помечаем, что функции CoClass-а не нужно преобразовывать в собственный интерфейс и экспортировать.
>
> // Указав этот атрибут, мы полностью контролируем все интерфейсы, которые экспортируются для COM
>
> // Если указать в качестве параметра другое значение - функции, которые не являются реализациями
>
> // интерфейсов будут выделены в отдельный интерфейс и экспортрованы, что не есть хорошо ИМХО.
>
> [ClassInterface(ClassInterfaceType.None)]
>
> // Указываем default interface. Делать этого не обязательно для VBA, но в С++ немного облегчает жизнь.
>
> [ComDefaultInterface(typeof(ITestInterface))]
>
> public class TestCoClass : ITestInterface
>
> {
>
> public void Hello(ref string name)
>
> {
>
> name = "Hello, " + name;
>
> }
>
>
>
> public string Say()
>
> {
>
> return "OK";
>
> }
>
>
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Объект создан. Компилируем его, после чего регистрируем в системе с помощью команды `regasm /tlb:testinproccom.tlb testinproccom.dll /codebase.`
Все, у нас есть зарегистрированный объекь, есть библиотека типов для него (tlb-файл) и мы можем приступать к клиенту. Для этого откроем Excel, перейдем к редактору Visual Basic, подключим через Tools->References нашу библиотеку типов и напишем следующее:
> `Dim a As TestCoClass
>
> Dim s As String
>
>
>
> Sub main()
>
> Set a = New TestCoClass
>
> s = "mike"
>
> a.Hello s
>
> MsgBox s
>
> msgbox a.Say()
>
> End Sub
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Нам должно вывестись два message box — первый «Hello, mike» и второй «OK». Поздравляю, мы все правильно сделали.
Однако, одними строками сыт не будешь. Попробуем передать структуру. Для этого определим ее.
> `[ComVisible(true)]
>
> // Определяем, что все объекты структуры в памяти располагаются последовательно в том порядке, в котором
>
> // они должны маршалиться в unmanaged.
>
> [StructLayout(LayoutKind.Sequential)]
>
> [Guid("E1AB60D5-F8F5-41fe-BD0D-AE2AC94237DD")]
>
> public struct MyStruct
>
> {
>
> // Строка
>
> [MarshalAs(UnmanagedType.BStr)]
>
> public string wow;
>
> // Массив. Массив следует маршаллить в виде SafeArray, потому как так с ним можно работать из скриптовых
>
> // языков, подобных VBA или JavaScript. Конечно, в случае C++ работа с SafeArray не самая приятная
>
> // процедура, но это уже издержки производства. Второй параметр задает тип объектов в массиве - в нашем
>
> // случае это четырехбайтное знаковое целое.
>
> [MarshalAs(UnmanagedType.SafeArray, SafeArraySubType = VarEnum.VT\_I4)]
>
> public int[] gig;
>
> // Задам маршаллинг объекта в виде указателя на интерфейс IDispatch. В этом случае .NET требует
>
> // чтобы параметр был определен как object.
>
> [MarshalAs(UnmanagedType.IDispatch)]
>
> public object self;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь, расширим интерфейс. Допишем туда еще одну функцию.
> `// Структуры всегда следует передавать из функции в out или ref параметрах - в случае передачи структуры
>
> // в качестве возвращаемого значения возможно некорректное поведение при обработке строк.
>
> void GetStruct([MarshalAs(UnmanagedType.Struct)] ref MyStruct ms);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
И реализуем ее в нашем CoClass-е.
> `public void GetStruct(ref MyStruct ms)
>
> {
>
> ms.gig = new int[] { 1, 2, 3, 4, 5 };
>
> ms.self = this;
>
> ms.wow = "wow";
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Как видите, мы помещаем в self параметр this — то есть после вызова этой функции в VBA у нас в этом поле будет лежать ссылка на наш объект, с которым мы сможем работать уже методами позднего связывания (то есть чере IDispatch). Проверим работоспособность объекта — перекомпилируем, перерегистрируем, опять откроем Excel и напишем следующий код:
> `Dim a As TestCoClass
>
> Dim s As String
>
> Dim b As MyStruct
>
>
>
> Sub main()
>
> Set a = New TestCoClass
>
> s = "mike"
>
> a.Hello s
>
> MsgBox s
>
> b.wow = "baaa"
>
> a.GetStruct b
>
> MsgBox b.gig(3)
>
> MsgBox b.self.Say()
>
> MsgBox b.wow
>
> Set a = Nothing
>
> End Sub
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Если все прошло хорошо, то у нас появляются следующие message box-ы
1. Hello, mike
2. 4
3. OK
4. wow
Обратите внимание на `b.self.Say()`. Мы вызываем функцию Say нашего объекта используя позднее связывание. Этот механизм обеспечивается благодаря тому, что мы задали интерфейс как дуальный (то есть способный работать через vtable и IDispatch одновременно). А потому лучше всегда задавать интерфейсы дуальными — это не требует никакой работы, но дает множество преимуществ.
Кстати, косвенным свидетельством того, что все работает правильно, являются подсказки среды VBA.
И наконец, коронный номер. Массив структур со строками. Определим структуру.
> `[ComVisible(true)]
>
> [StructLayout(LayoutKind.Sequential)]
>
> [Guid("1D40391F-C9CF-42ed-9C9E-4991B3F22907")]
>
> public struct MyStruct2
>
> {
>
> [MarshalAs(UnmanagedType.BStr)]
>
> public string param;
>
>
>
> public MyStruct2(string par)
>
> :this()
>
> {
>
> param = par;
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Определим в интерфейсе функцию
> `// Задаем маршаллинг в виде safearray с custom-типом параметра - нашей структурой.
>
> void SetMyStruct2([MarshalAs(UnmanagedType.SafeArray, SafeArrayUserDefinedSubType = typeof(MyStruct2))] out MyStruct2[] structs);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Просто? А никто и не говорил, что будет сложно. Единственное, что требуется при задании маршаллинга — представлять, как с твоими параметрами будет работать клиент.
Теперь, реализуем функцию в CoClass.
> `public void SetMyStruct2(out MyStruct2[] structs)
>
> {
>
> structs = new MyStruct2[] { new MyStruct2("bla1"), new MyStruct2("bla2"), new MyStruct2("bla3") };
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Компиляция, регистрация, и — тестовый пример, который говорит нам о том, что все прошло гладко.
> `Dim a As TestCoClass
>
> Dim sa() As MyStruct2
>
>
>
> Sub main()
>
> Set a = New TestCoClass
>
>
>
> a.SetMyStruct2 sa
>
> For i = 0 To 2
>
> MsgBox sa(i).param
>
> Next i
>
>
>
> Set a = Nothing
>
> End Sub
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
И если все прошло нормально — то мы должны получить следующие сообщения:
1. bla1
2. bla2
3. bla3
Ура нам!
Outproc COM.
------------
Однако, архитектура inproc COM нам не всегда подходит — например, в случае, если мы хотим создать одиночку (singleton). Так как dll проецируется в поле памяти процесса, различные процессы могут поднимать один и тот же экземпляр класса, который для каждого процесса будет уникальным и ничего не будет знать о других своих экземплярах. Это не всегда то, что нам надо.
Согласно спецификациям COM, реализация outproc сервера выглядит следующим образом. Когда клиент вызывает `CoGetClassObject` с соответствующими параметрами, COM сначала просматриваем свою внутреннюю таблицу фабрик класса, ища заданный клиентом CLSID. Если фабрика класса в таблице отсутствует, то COM обращается к реестру и запускает соответствующий модуль EXE. Задача последнего — как можно быстрее зарегистрировать свои фабрики класса, чтобы их могла найти COM. Для регистрации фабрики класса EXE используеь функцию COM `CoRegisterClassObject.`
Итак, наша задача — сделать это. Для этого, создадим новый проект (console EXE application), перенесем туда код наших интерфейсов, структур и классов. Теперь, определим требуемый код регистрации в функции Main.
Согласно спецификациям COM, outproc серверы должны поддерживать саморегистрацию с ключом /register. Делается это следующим образом:
> `static private void RegisterManagedType(Type type)
>
> {
>
> String strClsId = "{" + Marshal.GenerateGuidForType(type).ToString().ToUpper(CultureInfo.InvariantCulture) + "}";
>
>
>
> // Create the HKEY\_CLASS\_ROOT\CLSID key.
>
> using (RegistryKey ClsIdRootKey = Registry.ClassesRoot.CreateSubKey("CLSID"))
>
> {
>
> // Create the HKEY\_CLASS\_ROOT\CLSID\ key.
>
> using (RegistryKey ClsIdKey = ClsIdRootKey.CreateSubKey(strClsId))
>
> {
>
> ClsIdKey.SetValue("", type.FullName);
>
>
>
> // Create the HKEY\_CLASS\_ROOT\CLSID\\LocalServer32 key.
>
> using (RegistryKey LocalServerKey = ClsIdKey.CreateSubKey("LocalServer32"))
>
> {
>
> LocalServerKey.SetValue("", (new Uri(Assembly.GetExecutingAssembly().CodeBase)).LocalPath);
>
> }
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
И наконец, функция Main.
> `[MTAThread]
>
> static void Main(string[] args)
>
> {
>
>
>
> if ((args.Length == 1) && (args[0] == "register"))
>
> {
>
> RegisterManagedType(typeof(TestCoClass));
>
>
>
> Console.WriteLine("Server registered, press any key to exit");
>
>
>
> Console.ReadKey();
>
>
>
> return;
>
> }
>
>
>
> // Но как зарегистрировать фабрики класса?
>
>
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
А теперь у нас проблема — вызвать `CoRegisterClassObject` для регистрации фабрик класса. Казалось бы, простое решение — воспользоваться platform invoke для этой функции и радоваться жизни. Однако, ничего не получится — Microfost явно запрещает p/invoke для функции регистрации фабрик класса.
Решение пришло внезапно с форумов RSDN. Оказывается, в .NET существует класс с аналогом этой функции, который служит специально для этой цели, и зовется он [`RegistrationServices`](http://msdn.microsoft.com/en-us/library/system.runtime.interopservices.registrationservices.aspx). У него есть метод `RegisterTypeForComClients` который делает ровненько то же самое, что требуется нам от метода `CoRegisterClassObject.`
> `RegistrationServices rs = new RegistrationServices();
>
>
>
> rs.RegisterTypeForComClients(
>
> typeof(TestCoClass),
>
> RegistrationClassContext.RemoteServer | RegistrationClassContext.LocalServer | RegistrationClassContext.InProcessServer,
>
> RegistrationConnectionType.MultipleUse);
>
>
>
> Console.WriteLine("Server started, press any key to exit");
>
>
>
> Console.ReadKey();
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Компилируем, регистрируем, испытываем, не забыв предварительно удалить регистрацию inproc COM dll. Ура нам! | https://habr.com/ru/post/58240/ | null | ru | null |
# Создаем slack-бот на Python в Yandex.Cloud
Мы не любим отвлекаться от текущей работы, копаться в трекере задач и почте, чтобы найти нужный тикет или письмо от клиента. Нас беспокоят пропущенные напоминания и недоступные логи. Чат-боты и боты для поддержки процессов разработки популярны у разработчиков именно потому, что избавляют нас от нелюбимой рутины. Боты помогают нам в DevOps-трансформации.
Для разработки ботов удобно использовать serverless-технологии. Одно из преимуществ при работе с приложениями облачного бота, которые тоже размещены в облаке, — моментальный доступ к ним. В [докладе](https://devopsconf.io/moscow/2021/abstracts/7515) на DevopsConf 2021 я подробно рассказал о концепции СhatOps и о том, какие из serverless-технологий стоит взять на вооружение уже сейчас. Кажется, что СhatOps и serverless созданы друг для друга.
Для меня ChatOps открыл прекрасный докладчик Джеймс Фрайман (James Fryman). Про преимущества такой организации инфраструктуры он [рассказал](https://youtu.be/IhzxnY7FIvg) в своем докладе еще в 2015 году. За последние годы актуальность ChatOps не только не пропала, но с каждым годом становится более востребованной. В России интерес стал заметен благодаря цифровой трансформации и новым игрокам на рынке IT.
ChatOps в России сегодня — это, в первую очередь, боты для Telegram и Slack (один из самых первых шагов, но не последний). Эти платформы лидируют по популярности среди платформ для ботов в России, а Slack [входит в топ-3](https://www.g2.com/categories/business-instant-messaging?utf8=%E2%9C%93&order=popular&__cf_chl_captcha_tk__=d8cd5ff30befb9ca96e252cd5032e416c490608a-1623052090-0-Af1UNTRgwpEOtq6I63FjL2E3vR4UkIsUIJtGabNW_d57TUTcoPKWrO_uU2NdOmvG-NaW9nqiwllxqb33MkRcI5TevWR9V9OHP6DBdcN9KP8Y5srBaBQ2wb39FYebjz31ecUmxQUvOiuHvJmFCjzpSi2YaUeXE0AAQD8czlJ-5TIW-um3nqgRmgD3fLxOM6ap-fJjQJQi74sTdaDpSANJJk-ia6cT5-yoEbs08oGprvcJ_0EewVcWi6YaK5q-fccZSRCPBlfLqizg_KwvSQ-AgVs0XpyfNIRE2FBlx58aE1ErE4HWdFZqPaU8FzoxbrfUK6j6dIqauq_PbgCRyZkAIIvFlTTrmiiFR883TwLsmeG5_0cHAt6GAqcV3mgGMK9i3T134I8iOT3YjPooHWmfSrhg6ZzOFpbB4jh59rNjCXxWhhnXGuzFgpjYocRiZAxNsNlOgdc4T3npccxg-_fMBIQXcuZQ3z_NUO0FZgUGF-3SVFjFR-OpHw5n0cnb-7StVQCGBUv6OaaxRouPg9luIROU3aGWccQxnvFBnpWRF-uYK5gJlfB4Ww6A36Ji6hDQ4QkT-MOGlvHBvDWenI6HqcNlIFxe-4cbQ-87ki7ul6vthrtuFGIT6kWIbljpNKF4_FEO6JY6NdVc-eSOPbMNyGDpM79ihD53ckQJXheJ077Gfy2d0bxGqR8eXgrPI_3lD8eZmtJys7y2OedW186kVCcis4DgWR-qsx401eSra7ov9A7XykcLt_iJ-QPeKpyBvw) корпоративных менеджеров в мировом рейтинге.
Давайте разберемся, как за вечер создать своего slack-бота на serverless технологиях. Типичная serverless-архитектура приложения из базового набора сервисов, размещенная рядом с существующими приложениями в облаке выглядит так как показано на рисунке ниже. Такой способ позволяет постепенно переносить необходимую функциональность в serverless экосистему и не переставать оказывать услуги пользователям.
Serverless-приложение — это совокупность сервисов и функций, размещенных в облаке. Чтобы скрыть особенности реализации можно воспользоваться сервисом API Gateway. С одной стороны, у нас появляется единая точка доступа к приложению, с другой открываются возможности модификации приложения не сказывающиеся на внешних потребителях. Это удобно при реализации slack-ботов. В нашем случае архитектура нашего приложения весьма примитивна: сервис API Gateway прикрывает несколько функций, одна из которых будет связана с Yandex Database.
Шаг 1. Регистрируем новое приложение в Slack
--------------------------------------------
Начнем создание нашего бота с регистрации нового приложения в Slack. Переходим в панель [Slack](https://api.slack.com/), при этом вы должны быть авторизованы и обладать соответствующими правами. Нажимаем кнопку **Create a Slack App**, заполняем начальную информацию о приложении. Позже её можно будет отредактировать. Задаем значение имени **ServerlessBotApp** и в выпадающем списке выбираем доступный **workspace**.
В разделе **OAuth & Permissions** переходим в пункт **Scopes** и выбираем права для нашего бота. Добавляем в **Bot Token Scopes** через кнопку **Add an OAuth Scope** значение **chat:write**. После того, как мы определили права для бота, можно переходить к установке приложения в workspace.
В разделе **OAuth Tokens for Your Workspace** нажимаем кнопку **Install to Workspace**, на открывшейся странице — кнопку **Allow**. В результате, в этой же секции мы получим **Bot User OAuth Token**. Токены любят тишину, постарайтесь не светить его, он пригодится чуть позже.
Мы создали в Slack точку доступа, к которой можно подключаться. Осталось создать точку доступа на стороне облака. Для разработки нашего приложения нам потребуется сервисный аккаунта в нашем облаке в Yandex.Cloud.
Шаг 2. Создаем сервисный аккаунт в Yandex.Cloud
-----------------------------------------------
Для оперирования ресурсами в облаке нам понадобится специальный сервисный аккаунт. Чтобы создать его, переходим [в консоль облака](https://console.cloud.yandex.ru/). В текущем облаке выберем рабочий каталог и перейдем в пункт меню **Сервисные аккаунты.** Создадим новый сервисный аккаунт **serverless-slack** для работы приложения и выдадим ему роли в текущем каталоге.
Для сервисного аккаунта задаем роль **editor**, которая позволит нам реализовать полноценно реализовать serverless-приложение. В обзоре сервисного аккаунта получаем **идентификатор**.
Шаг 3. Проверяем связь со Slack
-------------------------------
Оставаясь в консоли облака переходим в дашборд текущего каталога и выбираем сервис **API Gateway**. Нажимаем кнопку **Создать API-шлюз** используем имя **for-slack-bot**. После публикации API-шлюза в спецификации появится секция **servers** со служебным доменом — при любых модификациях оставляем это поле без изменений. Этот адрес и будет точкой входа в приложение. В спецификации будут храниться все правила вызова наших serverless-функций.
Возвращаемся в панель Slack, чтобы связать наше приложение с облаком. В меню **Basic Information** нажимаем кнопку **Add features and functionality** и в открывшемся поле выбираем значение **Event Subscribtions**. Здесь нужно проверить, готова ли точка со стороны облака принимать запросы: на post-запрос от Slack мы должны выполнять параметры атрибута [Challenge](https://api.slack.com/events/url_verification), то есть отправлять ответ в виде:
```
HTTP 200 OK
Content-type: application/x-www-form-urlencoded
challenge=3eZbrw1aBm2rZgRNFdxV2595E9CY3gmdALWMmHkvFXO7tYXAYM8P
```
В облаке создаем функцию, которая будет отвечать на Challenge. в консоли облака переходим в дашборд текущего каталога и выбираем сервис **Cloud Functions**. Нажимаем кнопку **Создать функцию** и задаем ей имя **for-slack-bot-challenge**. Выбираем среду выполнения **python3.7**. Примечательно, что каждая функция может быть реализована на своем языке программирования.
В веб-редакторе создаем файл **requirements.txt**, подключаем в нем библиотеки:
```
Slack_sdk
Slack_bot
Boto3
```
Меняем содержимое файла **index.py,** созданного по умолчанию, в консоли на содержание того же файла [в моем репозитории](https://github.com/golodnyj/webinar-serverless-slackbot/blob/master/steps/3-api-gateway/index.py). Указываем точку входа **index.handler**. Увеличиваем тайм-аут до 5 секунд. Не забываем указываем сервисный аккаунт, созданный на предыдущем шаге. После того как функция будет создана у нее появится идентификатор.
Переходим в дашборд текущего каталога и выбираем сервис **API Gateway**. Выбираем **for-slack-bot** и редактируем его. Заменяем текущую спецификацию на содержимое из файла [for-slack-bot.yml](https://github.com/golodnyj/webinar-serverless-slackbot/blob/master/steps/3-api-gateway/for-slack-bot.yml). При этом заменяем **IDYOURFUNCTIONCHALLENGE** на идентификатор созданной функции, а **IDYOURACCOUNT** — на идентификатор сервисного аккаунта, созданного ранее. Помним что секцию **servers** в спецификации ни в коем случае не меняем. После сохранения изменений в спецификации копируем значение **url** в секции **servers**
Переходим в панель Slack, выбираем наше приложение **ServerlessBotApp**. В секции **Event Subscriptions** указываем только что скопированный адрес в поле **Request URL** и дожидаемся появления **Verified**.
Шаг 4. Реализуем команду, интегрированную в Slack
-------------------------------------------------
Когда мы убедились что Slack видит наш API Gateway, настало время реализовать функциональность доступную в чате — команду. Для начала, в панели Slack получаем token и secret. В разделе **OAuth & Permissions** копируем **Bot User OAuth Token** и в дальнейшем используем в качестве значения переменной **SLACK\_BOT\_TOKEN**. А в разделе **Basic Information** в подразделе **App Credentials** копируем **Signing Secret** и в дальнейшем используем его в качестве значения переменной **SLACK\_SIGNING\_SECRET**.
Для любой функции, создаваемой далее обязательно задаем переменные **SLACK\_BOT\_TOKEN** и **SLACK\_SIGNING\_SECRET** помимо сервисного аккаунта.
В консоли облака переходим в дашборд текущего каталога и выбираем сервис **Cloud Functions**. Нажимаем кнопку Создать функцию. Задаем имя **for-slack-bot-hello-from-serverless**. Выбираем среду выполнения **python3.7**.
В веб-редакторе создаем файл **requirements.txt**, подключаем в нем библиотеки:
```
Slack_sdk
Slack_bot
Boto3
```
Меняем содержимое файла **index.py,** созданного по умолчанию, в консоли на содержание того же файла [в моем репозитории](https://github.com/golodnyj/webinar-serverless-slackbot/blob/master/steps/4-create-command/index.py). Указываем точку входа **index.handler**. Увеличиваем тайм-аут до 5 секунд. Указываем идентификатор сервисного аккаунта и переменные **SLACK\_BOT\_TOKEN**, **SLACK\_SIGNING\_SECRET** полученные ранее. Жмем кнопку — **Создать версию** и после копируем идентификатор нашей новой функции.
Функция готова и работает, опубликуем ее через сервис **API Gateway**. Выбираем **for-slack-bot** и редактируем его. Вставляем секцию **/hello-from-serverless** со всем ее содержимым из файла [for-slack-bot.yml](https://github.com/golodnyj/webinar-serverless-slackbot/blob/master/steps/4-create-command/for-slack-bot.yml) в спецификацию. Заменяем **IDYOURFUNCTIONHELLO** на идентификатор созданной функции, а **IDYOURACCOUNT** — на идентификатор сервисного аккаунта. Сохраняем изменения.
Функция опубликована и требуется создать команду в нашем Slack-приложении. В панели Slack выбираем созданное приложение **ServerlessBotApp**. В секции **Slash Commands** нажимаем кнопку **Create New Command**.
В поле Command вводим **/hello-from-serverless**. В поле **Request URL** указываем адрес **API Gateway**, дополнив его **/hello-from-serverless**. Можем, но не обязаны заполнить поле Short Description. Нажимаем Save. Следуя инструкции, переустанавливаем Slack-приложение. После этого в workspace появится возможность вызвать сконфигурированную команду.
Шаг 5. Реагируем на сообщение пользователя
------------------------------------------
Мы уже можем расширять функциональность Slack с помощью команд и реализовать выполнение функции внутри Yandex.Cloud. Но наш бот не совсем бот, он не умеет реагировать на сообщения пользователя. Исправим это.
Переходим в сервис **Cloud Functions**. Нажимаем кнопку **Создать функцию**. Задаем имя **for-slack-bot-small-talk**. Выбираем среду выполнения **python3.7**.
Создаем файл **requirements.txt** с содержимым аналогично предыдущему разу. Меняем содержимое файла **index.py** созданного по умолчанию, в консоли на содержание того же файла [в моем репозитории](https://github.com/golodnyj/webinar-serverless-slackbot/blob/master/steps/5-create-bot/index.py). Указываем точку входа **index.handler**. Увеличиваем тайм-аут до 5 секунд.
Указываем сервисный аккаунт и переменные **SLACK\_BOT\_TOKEN**, **SLACK\_SIGNING\_SECRET**, полученные ранее. Нажимаем кнопку **Создать версию**, не забываем скопировать идентификатор.
Функция по умолчанию всегда создается приватная и с помощью идентификатора и части спецификации API Gateway можно сделать ее публичной. Для этого отредактируем данные в шлюзе.
В сервисе **API Gateway** находим шлюз **for-slack-bot**, отредактируем его содержание: заменим секцию **/** на аналогичную, содержащуюся в файле [for-slack-bot.yml](https://github.com/golodnyj/webinar-serverless-slackbot/blob/master/steps/5-create-bot/for-slack-bot.yml), только заменяем **IDYOURFUNCTIONSMALLTALK** на идентификатор вашей функции. Сохраняем.
Переходим на панель управления Slack выбираем созданное приложение **ServerlessBotApp**. В секции **Event Subscriptions** передвигаем ползунок **Enable Events** в положение **on**. Указываем адрес **API Gateway** в поле **Request URL** и дожидаемся появления **Verified**.
В секции **Subscribe to bot events** на той же странице нажимаем кнопку **Add Bot User Event** и выбираем **message.im**.
Как только все заработает, возникнет автоматическое взаимодействие. Поток сообщений будет отправляться в **API Gateway**. На нашей стороне мы уже можем реализовать полноценный диалог с подключением других необходимых ресурсов. Можем расширять функциональность через подписку на определенные типы событий. Сейчас мы подписались только на один тип — получение сообщений.
Через точку доступа Slack отправляет запросы в виде POST-запросов, на стороне Yandex.Cloud вызывается функция. Запрос обрабатывается функцией и генерируется ответ.
Созданная ранее функция реагирует на сообщения пользователя **":wave:"** и "**knock knock**". Теперь у нас уже есть практически полнофункциональный бот, но нам предстоит подключить к нашему serverless-приложению СУБД для хранения данных, для хранения состояния и другой информации.
Шаг 6. Создаем БД для хранения данных
-------------------------------------
Для работы нашего serverless-приложения будем использовать СУБД Yandex Database, более подробно о ее особенностях [можно почитать тут](https://habr.com/ru/post/562746/).
В консоли облака переходим в дашборд текущего каталога и выбираем сервис **Yandex Database**. Нажимаем кнопку **Создать базу данных**. Создаем базу данных с именем **for-slack-bot**, выбираем **serverless** в качестве модели.
После создания БД переходим в ее содержимое, выбираем пункт **Навигация** и нажимаем кнопку **SQL-запрос**. В веб-редакторе в поле Запроса вставляем следующий текст:
```
CREATE TABLE coffee
(
id Utf8,
name Utf8,
PRIMARY KEY (id)
);
```
После успешного выполнения запроса в нашей БД появится таблица. В разделе **Навигация** выберете таблицу **coffee** и добавьте пару строк. Одну из строк с идентификатором равному **1**.
Перейдите в раздел **Обзор**. В интерфейсе вы увидите секцию **YDB эндпоинт**, в ней содержатся данные для формирования необходимых переменных. Для работы функции с Yandex Database потребуется три переменные. Переменная **ENDPOINT** будет иметь вид grpcs://ydb.serverless.yandexcloud.net:1234, переменную **DATABASE** обязательно начинать с /ru-central1/..., а переменная **USE\_METADATA\_CREDENTIALS** в нашем случае выставляется равной **1**.
Шаг 7. Реализуем команду, интегрированную в Slack и работающую с YDB
--------------------------------------------------------------------
Оставаясь в рабочем каталоге выбираем сервис **Cloud Functions** и привычным образом создаем новую функцию с именем **for-slack-bot-what-kind-of-coffee**. Выбираем среду выполнения **python3.7**.
Создаем файл **requirements.txt** с содержимым аналогично предыдущему разу, но в конце добавляем еще одну библиотеку.
```
ydb==0.0.41
```
Меняем содержимое файла **index.py** созданного по умолчанию, в консоли на содержание того же файла [в моем репозитории](https://github.com/golodnyj/webinar-serverless-slackbot/blob/master/steps/7-create-command-with-ydb/index.py). Указываем точку входа **index.handler**. Увеличиваем тайм-аут до 5 секунд.
Указываем сервисный аккаунт и переменные **SLACK\_BOT\_TOKEN**, **SLACK\_SIGNING\_SECRET**, полученные ранее. Добавляем еще три переменные для работы с YDB: **ENDPOINT**, **DATABASE**, **USE\_METADATA\_CREDENTIALS**. Нажимаем кнопку **Создать версию**, не забываем скопировать идентификатор.
Оставаясь в рабочем каталоге в облаке переходим в сервис **API Gateway** выбираем **for-slack-bot** и редактируем его. Вставляем секцию **/what-kind-of-coffee** со всем ее содержимым из файла [for-slack-bot.yml](https://github.com/golodnyj/webinar-serverless-slackbot/blob/master/steps/7-create-command-with-ydb/for-slack-bot.yml).
Заменяем **IDYOURFUNCTIONCOFFEE** на идентификатор созданной функции, а **IDYOURACCOUNT** — на идентификатор вашего сервисного аккаунта, созданного ранее. Сохраняем изменения. В этот момент у нас появилась опубликованная функция, способная получить данные из Yandex Database, остается вызвать ее из Slack.
В панели управления Slack выбираем созданное приложение **ServerlessBotApp**. В секции **Slash Commands** нажимаем **Create New Command**. Кстати, название команды и запрос URL со стороны Slack всегда можно отредактировать^ что очень удобно.
В поле **Command** вводим **/what-kind-of-coffee**, в поле **Request URL** указываем адрес **API Gateway**, дополнив его **/what-kind-of-coffee**. Нажимаем **Save**. Следуя инструкции, переустанавливаем Slack-приложение. Теперь в workspace можно вызвать новую команду.
Мы получили бот, с которым можно работать, расширять его возможности и прокачивать функциональность. Теперь вы можете создавать полноценные диалоги и получать данные.
Полные исходные тексты всех файлов, инструкции и видео шагов для реализации бота [есть в репозитории](https://github.com/golodnyj/webinar-serverless-slackbot).
P.S. Пара нюансов реализации
----------------------------
Первый. Когда вы создаете бота для Slack, рекомендую обратить внимание на реакцию на ввод команды. Эта реакция **должна быть меньше 3 секунд.** Если вы не укладываетесь в это время, Slack считает это ошибкой и начинает посылать сообщения в чат пользователю о том, что команда недоступна.
Лучше не дожидаться выполнения команды, а записать в базу данных сам факт ее вызова. Затем уже отдельной функцией обработать очередь вызовов команд, а результат вызова команды дослать позже. К тому моменту, как пользователь обратится в чат, вы сможете ему ответить полноценным диалогом.
Второй. В Yandex.Cloud есть активно растущее serverless-коммьюнити [Yandex Serverless Ecosystem](https://t.me/YandexCloudFunctions) в Telegram, где можно задавать вопросы, возникающие в процессе создания serverless-ботов и получать ответы от единомышленников и коллег.
И последнее: сейчас действует программа [free tier](https://cloud.yandex.ru/docs/billing/concepts/serverless-free-tier?utm_medium=habr&medium_source=article&utm_campaign=functions). Вы можете разработать свое приложение, в том числе и slack-бот, при этом сервисы тарифицироваться не будут, если вы уложитесь в лимиты программы. | https://habr.com/ru/post/564684/ | null | ru | null |
# Практика IronScheme
> Уверен, что вы перестанете играть в «мясо», ибо то, что я вам сейчас расскажу, покажется вам очень интересным, хотя бы потому, что многих специальных терминов вы не поймёте.
>
> Ярослав Гашек
[Часть 1 Введение в Scheme](http://habrahabr.ru/company/tcsbank/blog/267015/)
[Часть 2 Углубление в Scheme](http://habrahabr.ru/company/tcsbank/blog/267113/)
[Часть 3 Практика IronScheme](http://habrahabr.ru/company/tcsbank/blog/267119/)
Практика
--------
Теперь создадим несколько приложений, которые уже ближе к реальной жизни, чем примеры из предыдущей статьи. Философские вопросы и основы разработки мы рассмотрели в предыдущих статьях, поэтому эта будет состоять преимущественно из кода. Надеюсь, что код будет легко читаться, поэтому не буду его снабжать обильными комментариями.
Для начала разберемся, как из IronScheme можно получить доступ к классам .net
Программа на IronScheme начинается с импорта библиотек:
```
(import
(rnrs)
(ironscheme)
)
```
Чтобы использовать функции для взаимодействия с CLR нужно импортировать библиотеку (ironscheme clr):
```
(import
(rnrs)
(ironscheme)
(ironscheme clr)
)
```
Теперь нам доступны следующие функции:
**(clr-namespaces)**
Возвращает все импортированные пространства имен.
**(clr-reference reference)**
Подключает сборку к приложению, например (clr-reference System.Web).
**(clr-using namespace)**
Импортирует пространство имен: (clr-using System.IO).
**(clr-call type method instance arg ...)**
Вызывает метод объекта.
**(clr-cast type expr)**
Приводит объект к заданному типу.
**(clr-is type expr)**
Проверяет, имеет ли объект указанный тип.
**(clr-new type arg ...)**
Создает экземпляр класса и передает аргументы в конструктор.
**(clr-new-array type size)**
Создает массив с указанным типом и размером.
**(clr-event-add! type event instance handler)**
Добавляет обработчик события.
**(clr-event-remove! type event instance handler)**
Удаляет обработчик события.
**(clr-field-get type field instance)**
Получить значение поля.
**(clr-field-set! type field instance expr)**
Назначить полю значение.
**(clr-prop-get type property instance)**
Возвращает значение свойства.
**(clr-prop-set! type property instance expr)**
Задает значение свойства.
**(clr-static-call type method arg ...)**
Вызов статического метода.
**(clr-static-event-add! type event handler)**
Добавляет обработчик для статического события.
**(clr-static-event-remove! type event handler)**
Удаляет обработчик.
**(clr-static-field-get type field)**
Возвращает значение статического поля.
**(clr-static-field-set! type field expr)**
Задает значение статическому полю.
**(clr-static-prop-get type property)**
Возвращает значение статического свойства.
**(clr-static-prop-set! type property expr)**
Задает значение статического свойства.
Hello, world 2.0
----------------
Попробуем? Создайте файл hello-world-clr.ss с содержимым:
```
(import
(rnrs)
(ironscheme)
(ironscheme clr)
)
(clr-static-call Console WriteLine "Hello, world")
```
Этот пример демонстрирует вызов статического WriteLine метода класса System.Console.
Просто таймер
-------------
Теперь пример интереснее, запускаем таймер.
Как обычно вначале импортируем библиотеки:
```
(import
(rnrs)
(ironscheme)
(ironscheme clr)
)
```
Импортируем пространство имен:
```
(clr-using System.Threading)
```
Для удобства использования напишем две функции обертки clr- вызовов. Первая функция создает объект класса Timer, вторая меняет основные параметры таймера:
```
(define (timer-new handler)
(clr-new Timer handler)
)
(define (timer-change timer due-time period)
(clr-call Timer Change timer (clr-cast System.Int32 due-time) (clr-cast System.Int32 period))
)
```
Кастинг при clr вызовах нужен чтобы привести из внутреннего IronScheme представления к .Net типам.
Еще полезной будет функция блокирующая основной поток приложения, чтобы программа не завершилась:
```
(define (console-block)
(clr-static-call Console WriteLine "Press to terminate")
(clr-static-call Console ReadLine)
)
```
Чтобы использовать таймер нужно вначале объявить функцию обработчик:
```
(define (time-handler obj)
;; some code
)
```
Затем создаем объект таймера:
```
(define timer (timer-new time-handler))
```
И запускаем таймер указав период и задержку:
```
(timer-change timer delay period)
```
Теперь все вместе, пример печатает в консоль количество срабатываний.
**Полный исходник примера использования таймера**
```
(import
(rnrs)
(ironscheme)
(ironscheme clr)
)
(clr-using System.Threading)
;; ***************************************
(define (timer-new handler)
(clr-new Timer handler)
)
(define (timer-change timer due-time period)
(clr-call Timer Change timer (clr-cast System.Int32 due-time) (clr-cast System.Int32 period))
)
(define (console-block)
(clr-static-call Console WriteLine "Press to terminate")
(clr-static-call Console ReadLine)
)
;; \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
(define counter 0)
(define period 1000) ;;ms
(define (time-handler obj)
(set! counter (+ counter 1))
(displayln counter)
)
(define timer (timer-new time-handler))
(timer-change timer 0 period)
(console-block)
```
Работаем с Oracle DB
--------------------
Привожу пример подключения и запроса к СУБД Orcale. Полагаю, что читатель уже сам сможет разобраться, поэтому не буду расписывать, что и как здесь происходит. Вначале программы объявлены функции для работы с Oracle, далее для уже знакомого Timer. Затем создается подключение к базе и по таймеру делается запрос, результат запроса выводится в консоль.
Пример взят из реального приложения, используемого для мониторинга. Естественно конфиденциальные фрагменты кода заменены на «\*\*\*\*\*», но они и не критичны для понимания или использования примера для разработки собственных программ.
**Исходник примера работы с базой данных Oracle**
```
(import
(rnrs)
(ironscheme)
(ironscheme clr)
)
;; **************** Oracle **************;;
(clr-reference System.Data)
(clr-reference System.Data.OracleClient)
(clr-using System.Data.OracleClient)
(define (ora-connection-new connection-string)
(clr-new OracleConnection (clr-cast System.String connection-string))
)
(define (ora-connection-open connection)
(clr-call OracleConnection Open (clr-cast OracleConnection connection))
)
(define (ora-connection-create connection-string)
(define connection (ora-connection-new connection-string))
(ora-connection-open connection)
connection ;; return
)
(define (ora-command-new connection sql-string)
(clr-new OracleCommand (clr-cast System.String sql-string) (clr-cast OracleConnection connection))
)
(define (ora-command-parameter-add command key value)
(clr-call OracleParameterCollection Add
(clr-prop-get OracleCommand Parameters command)
(clr-cast System.String key)
(clr-cast System.Object value)
)
)
(define (ora-execute-reader command)
(clr-call OracleCommand ExecuteReader (clr-cast OracleCommand command))
)
(define (ora-read reader)
(clr-call OracleDataReader Read (clr-cast OracleDataReader reader))
)
(define (ora-get-value reader key)
(clr-call OracleDataReader GetValue reader
(clr-call OracleDataReader GetOrdinal reader key)
)
)
(define (ora-get-string reader key)
(clr-call Object ToString (ora-get-datetime reader key))
)
(define (ora-get-int32 reader key)
(clr-call OracleDataReader GetInt32 reader
(clr-call OracleDataReader GetOrdinal reader key)
)
)
(define (ora-get-datetime reader key)
(clr-call OracleDataReader GetDateTime reader
(clr-call OracleDataReader GetOrdinal reader key)
)
)
;;***************************************;;
;; **************** Timer ***************;;
(clr-using System.Threading)
(define (timer-new handler)
(clr-new Timer handler)
)
(define (timer-change timer due-time period)
(clr-call Timer Change timer (clr-cast System.Int32 due-time) (clr-cast System.Int32 period))
)
(define (console-block)
(clr-static-call System.Console WriteLine "Press to terminate")
(clr-static-call System.Console ReadLine)
)
;;\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*;;
;;######## GLOBAL #########;;
(define connection-string "Data Source=\*\*\*\*\*;User ID=\*\*\*\*\*;Password=\*\*\*\*\*;")
;;#########################;;
(define (complect-print reader)
(import (srfi :13))
(let loop ((index 1))
(if (ora-read reader)
(begin
(display " (")
(display (string-pad-right (number->string index) 5))
(display (string-pad-right (ora-get-value reader "\*\*\*\*\*") 15))
(display " ")
(display (string-pad-right (ora-get-value reader "\*\*\*\*\*") 20))
(display " ")
(display (ora-get-int32 reader "\*\*\*\*\*"))
(display " ")
(display (string-pad-right (ora-get-value reader "\*\*\*\*\*") 25))
(display " ")
(display (ora-get-string reader "\*\*\*\*\*"))
(displayln ")")
(loop (+ index 1))
)
)
)
)
(define (complect-display connection status)
(define sqlStr "select \* from \*\*\*\*\* where \*\*\*\*\* = :complect\_status")
(define cmd (ora-command-new connection sqlStr))
(define reader '())
(ora-command-parameter-add cmd "complect\_status" status)
(set! reader (ora-execute-reader cmd))
(display "(complect-status ")
(displayln status)
(complect-print reader)
(displayln ")")
(clr-call OracleDataReader Close reader)
)
(define (time-handler obj)
(define connection (ora-connection-create connection-string))
(clr-static-call System.Console Clear)
(displayln "\n;; \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ;;\n")
(complect-display connection 1)
(newline)
(complect-display connection 2)
(newline)
(complect-display connection 3)
(newline)
(complect-display connection 4)
(displayln "\n;; \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ;;\n")
(clr-call OracleConnection Close connection)
)
(define timer (timer-new time-handler))
(timer-change timer 0 3000)
(console-block)
```
WindowsForms
------------
И в завершение приведу простой пример оконного приложения. В этом примере я не стал заморачиваться с обертками .NET вызовов, т.к. мне была важна демонстрация принципа, того обстоятельства что и это возможно. Конечно, если обернуть вызовы, то размер кода сократится, за счет повторного использования.
```
(import
(rnrs)
(ironscheme)
(ironscheme clr)
)
(clr-reference System.Windows.Forms)
(clr-using System.Windows.Forms)
(define main-form (clr-new Form))
(clr-prop-set! Form Text main-form "--== Hello, world ==--")
(clr-prop-set! Form Size main-form (clr-new System.Drawing.Size 640 480))
(define lbl-message (clr-new Label))
(clr-prop-set! Label Text lbl-message "Message: \"Hello, Windows Forms(IronScheme) World!\"")
(clr-prop-set! Label Size lbl-message (clr-new System.Drawing.Size 320 20))
(clr-prop-set! Label Location lbl-message (clr-new System.Drawing.Point 150 200))
(clr-call Form+ControlCollection Add (clr-prop-get Form Controls main-form) lbl-message)
(clr-static-call Application Run (clr-cast Form main-form))
```
В качестве заключения
---------------------
В этой статье я пытался продемонстрировать, что для Scheme нет ничего невозможного, по крайней мере, исполняемого поверх .NET. Это вовсе не означает, что следует бросить привычный C# и начать кодить на Scheme. Конечно, программирования на Scheme имеют определенные преимущества, это становится понятно по мере более глубокого проникновения сознания в идеологию Lisp. Но все же поддержка C# студией со всякими там ReSharper, оставляют далеко позади Scheme в качестве основного языка для разработки под .NET. Безусловно, можно реализовать первоклассную поддержку и для Lisp поверх .NET, но очевидно не многим это нужно иначе давно сделали бы. Однако, Lisp и в частности Scheme может быть крайне полезен в качестве встраиваемого языка. В такой роли он имеет определенные преимущества перед другими встраиваемыми языками. Посредством Lisp можно реализовать читаемые и гибкие конфигурационные файлы, консольный интерфейс управления приложением, передачу данных по сети и многое другое. Но об этом несколько позже и в следующих статьях. | https://habr.com/ru/post/267119/ | null | ru | null |
# REST API на Symfony, FOSRestBundle + GlavwebDatagridBundle
Всем привет! В прошлой статье я рассказал о нашем опыте в REST API со сборкой на [FOSRestBundle + JMSSerializer](https://habrahabr.ru/post/302902/). Сегодня я поделюсь нашим подходом к разработке REST API на FOSRestBundle + GlavwebDatagridBundle.
Новые задачи.
-------------
С ростом количества REST проектов возрастали требования к нашему апи. Часто пользователями нашего апи являются сторонние разработчики, которые имеют те или иные потребности для своих решений. Так, например, не всем было по душе передавать конфигурацию вложенности объектов в запросах. Возможностей фильтрации из коробки так же не хватало.
Но самым весомым основанием к пересмотру подхода к разработке апи были проблемы с производительностью. Причинами этих проблем были либо не оптимально написанный SQL, либо дополнительные затраты на обработку результата доктриной и сериализером.
Если с SQL понятно в какую сторону оптимизировать, то с потерей производительности в доктрине и сериализере сложнее. Вот, как это выглядит после того, как запрос к БД отработал:
```
получение массива данных из PDO -> преобразования массива в объекты (в доктрине, гидрация) -> вызов листенера для каждого поля каждого объекта в jmsserializer -> преобразование объекта в json в сериализере.
```
Было решено сократить этот путь до:
```
получение массива данных из PDO -> преобразования массива в многомерный ассоциативный массив (в доктрине, гидрация) -> по необходимости, преобразование данных сразу в массиве.
```
Так как мы отказались от гидрации в объекты, пришлось отказаться и от JMSSerializer тоже. JMSSerializer делал много полезного для нашего апи (это я описал в [предыдущей статье](https://habrahabr.ru/post/302902/)). Кроме того он выполнял еще одну важную работу — догружал вложенные сущности, если они не были определены в join-ах.
Для того, чтобы закрыть образовавшуюся «дыру» в функциональности, возникшую в результате отказа от jmsserializer, был разработан GlavwebDatagridBundle.
В «двух словах» о GlavwebDatagridBundle
---------------------------------------
Коротко определить предназначение GlavwebDatagridBundle можно так: получать данные, отформатированные нужным образом, на основе фильтров, лимита и оффсета. Не понятно? Знаю. А теперь обо всем по порядку.
В основе GlavwebDatagridBundle лежат следующие компоненты:
* DatagridBuilder;
* Datagrid;
* Filter;
* DataSchema + Scope.
### DatagridBuilder
DatagridBuilder формирует QueryBuilder используя DataSchema, фильтры и дополнительные параметры запроса:
```
$datagridBuilder = $this->get('glavweb_datagrid.doctrine_datagrid_builder');
$datagridBuilder
->setEntityClassName(Entity::class)
->setFirstResult(0)
->setMaxResults(100)
->setOrderings(['id'=>'DESC'])
->setOperators(['field1' => '='])
->setDataSchema('entity.schema.yml', 'entity/list.yml')
;
```
Далее возвращает объект Datagrid:
```
$datagrid = $datagridBuilder->build($paramFetcher->all());
```
### Filter
Фильтры позволяют задавать дополнительные условия в запрос.
```
// Define filters
$datagridBuilder
->addFilter('field1')
->addFilter('field2')
;
```
### Datagrid
Datagrid получает QueryBuilder из DatagridBuilder и позволяет вернуть данные как в виде списка:
```
$datagrid->getList();
```
так и в виде одной строки:
```
$datagrid->getItem();
```
### DataSchema
DataSchema определяет набор данных в формате yaml:
```
schema:
class: AppBundle\Entity\Article
db_driver: orm
properties:
id: # integer
type: # ArticleType
name: # string
body: # text
publish: # boolean
publishAt: # datetime
```
Определяет поля и связи:
```
schema:
class: AppBundle\Entity\Movie
db_driver: orm
properties:
...
tags: # AppBundle\Entity\Tag
join: left
properties:
id: # integer
```
Дополнительные условия:
```
schema:
class: AppBundle\Entity\Article
db_driver: orm
conditions: ["{{alias}}.publish = true"]
properties:
....
```
Так же возможно определять дополнительные условия и для связей:
```
schema:
class: AppBundle\Entity\Movie
db_driver: orm
properties:
...
articles: # AppBundle\Entity\Article
conditions: ["{{alias}}.publish = true"]
join: none
properties:
....
```
DataSchema так же реализует функцию догрузки вложенных сущностей, если они не были сконфигурированы как join:
```
schema:
class: AppBundle\Entity\Movie
db_driver: orm
properties:
...
articles: # AppBundle\Entity\Article
join: none
properties:
id: # integer
```
DataSchema используется для построения запроса в DatagridBuilder и для преобразования данных в Datagrid.
### Scope
Scope позволяет сузить набор данных, определенных в DataSchema.
Например, с помощью scope можно определить небольшой объем данных для списка записей (article\list.yml):
```
scope:
id:
name:
```
и полный набор данных для просмотра одной записи (article\view.yml):
```
scope:
id:
type:
name:
body:
publish:
publishAt:
movies: # AppBundle\Entity\Movie
id:
name:
```
От слов к демо.
---------------
Предлагаю вашему вниманию вымышленное апи кинотеатра, созданное специально для демонстрации. Сущности и поля сущностей подобраны таким образом, чтобы максимально раскрыть возможности апи.
Демо проект размещен на [гитхабе](https://github.com/glavweb/rest-demo-app).
Для того, что бы развернуть проект локально нужно сделать 3 простых действия:
1. Создать проект через композер.
```
composer create-project glavweb/rest-demo-app
```
2. Выполнить миграции.
```
php bin/console d:m:m -n
```
3. Выполнить фикстуры.
```
php bin/console h:d:f:l -n
```
### Сущности
В наличии следующие сущности:
* Movie. Фильмы.
* MovieDetail. Подробная информация о фильме фильма.
* MovieSession. Сеансы фильмов.
* MovieGroup. Группы фильмов.
* MovieComment. Комментарии к фильмам.
* Image. Изображения, используются в комментариях к фильмам.
* Article. Статьи.
* Tag. Тэги.
Между ними имеем следующие связи:
1. один-ко-многим (сеансы фильма, комментарии);
2. многие-к-одному (группа фильмов);
3. многие-ко-многим (теги);
4. один-к-одному (инфо о фильме).
Дополнительные особенности:
1. Не опубликованные комментарии доступны только авторам.
2. Администраторам и модераторам доступны все комментарии.
3. Комментарий созданный пользователем входящим в группу администраторов или модераторов является опубликованным автоматически.
### Пользователи и группы пользователей
Группы пользователей:
1. Администраторы. Имеют полный доступ ко всем записям в системе администрировния.
2. Модераторы. Имеют ограниченный доступ в системе администрирования (могут только редактировать и удалять комментарии).
3. Пользователи. Не имеют доступа к системе администрирования. Через апи приложения могут добавлять новые комментарии, редактировать и удалять только собственные комментарии.
Предустановленный набор пользователей:
1. Андминистратор. Группа: администраторы. Логин: admin, пароль: qwerty
2. Модератор. Группа: модераторы. Логин: login: moderator, пароль: qwerty
3. Пользователь 1. Группа: пользователи. Логин: login: user-1, пароль: qwerty
4. Пользователь 2. Группа: пользователи. Логин: login: user-2, пароль: qwerty
### Сценарии
**Сценарий 1.**
Пользователь не авторизован. Ему доступны все фильмы и комментарии, подтвержденные модераторами. Пользователь не может создавать комментарии, у него нет доступа к системе администрирования.
**Сценарий 2.**
Пользователь авторизован. Принадлежит к группе «Пользователь». Ему доступны так же комментарии подтвержденные модераторами и собственные комментарии. Пользователь может создавать комментарии и прикреплять изображения к комментариям, может редактировать и удалять свои комментарии. Система администрирования не доступна.
**Сценарий 3.**
Пользователь авторизован. Принадлежит к группе «Модератор». Ему доступны все фильмы и комментарии. Модератор может создавать комментарии и прикреплять изображения к комментариям, может редактировать и удалять любые комментарии. Доступны ограниченные возможности системы администрирования — доступ к комментариям.
**Сценарий 4.**
Пользователь авторизован. Принадлежит к группе «Администратор». Ему доступны все фильмы и комментарии. Может создавать комментарии и прикреплять изображения к комментариям, может редактировать и удалять любые комментарии. Доступны полные возможности системы администрирования.
### Система администрирования
Система администрирования доступна админам и модераторам.
URL: /admin
### Примеры запросов к Api
URL к документации апи: /api/doc
### Специальные параметры
**\_scope**
С помощью этого параметра можно определить скопу отличный от дефолтного. Например, получим сокращенный список фильмов состоящий только из id и name.
```
GET /api/movies?_scope=list_short
```
**\_oprs**
Параметр "\_oprs" позволяет определить оператор для переданных в фильтр значений. Т.е. если нет возможности передать оператор первым символом в параметре к фильтру, это можно сделать с помощью параметра "\_oprs". Например, это полезно для массивов когда, нужно передать «NOT IN»:
```
GET /api/articles?_oprs[type]=<>&type=photo_report
```
**\_sort**
С помощью этого параметра можно определить порядок сортировки. Например, получаем все статьи сортированные по имени (от последней до первой буквы) и ID (от меньшего к большему):
```
GET /api/articles?_sort[name]=DESC&_sort[id]=ASC
```
**\_offset**
С помощью параметра "\_offset" можно определить позицию для списка. Например, для того что бы получить все записи начиная с 11-й, передадим "\_offset=10":
```
GET /api/articles?_offset=10
```
**\_limit**
Этот параметр определяет лимит для списка. Например, получаем первые 10 статей:
```
GET /api/articles?_limit=10
```
### Примеры фильтров
**Строковые фильтры**
Для строковых фильтров по умолчанию поиск осуществляется по вхождению подстроки.
```
GET /api/articles?name=Dolorem
```
Если нужно обратное, т.е. найти все записи, в которых нет вхождения данной подстроки, то необходимо передать "!" перед значением:
```
GET /api/articles?name=!Dolorem
```
Если нужно полное сравнение, то необходимо поставить знак "=" перед значением:
```
GET /api/articles?name==Dolorem+eaque+libero+maxime.
```
Не равно, определяется следующим образом (символы "<>" перед значением):
```
GET /api/articles?name=<>Dolorem+eaque+libero+maxime.
```
**Enum типы**
Enum типы ищуются по полному сравнению (=):
Для того что бы найти статьи с типом news необходимо передать news:
```
GET /api/articles?type=news
```
Такой запрос вернет пустой результат:
```
GET /api/articles?type=new
```
**Массивы**
Для того, что бы отфильтровать по массиву значений (IN), необходиом передать массив следующим образом [«name1»,«name2»,«name3'...]. Например, для того, чтобы получить статьи с типом photo\_report и news:
```
/api/articles?type=["photo_report","news"]
```
Получить статьи все кроме new и photo\_report:
```
/api/articles?_oprs[type]=<>&type=["photo_report",+"news"]
```
**Даты**
Операторы больше/меньше доступны как для числовых фильтров, так и для фильров дат. Например, получить статьи позже 2016-06-07:
```
/api/articles?publishAt=>2016-06-07
```
Получить статьи раньше 2016-06-07:
```
/api/articles?publishAt=<2016-06-07
```
Диапазон дат, можно получить следующим образом:
```
GET /api/articles?publishAt=[">2016-03-06","<2016-03-13"]
```
Заключение
----------
Для желающих ознакомиться с тем как это реализовано в коде — [ссылка на гитхаб](https://github.com/glavweb/rest-demo-app). | https://habr.com/ru/post/303366/ | null | ru | null |
# Настройка Wifi в Linux при помощи Adhoc на примере Ubuntu
Эта тема уже не раз поднималась, но хорошей и легкой инструкции я так и не нашел.
Данная статья расчитана на новичков в мире Linux поэтому тут используются наиболее легкие методы настройки.
Для начала ставим пакеты:
`sudo apt-get install wireless-tools dhcp3-server`
Далее создаем сеть через апплет например название «My Wifi»
И настроим интерфейс(для определения интерфейса воспользуйтесь командой iwconfig)
Пишем в консоли из под root
`ifconfig wlan0 down
iwconfig wlan0 mode ad-hoc
iwconfig wlan0 channel 1
iwconfig wlan0 Bit 54Mb/s
iwconfig wlan0 essid 'My Wifi'
ifconfig wlan0 10.42.43.1 netmask 255.255.255.0 up
iwconfig wlan0
ifconfig wlan0 up
echo 1 > /proc/sys/net/ipv4/ip_forward
iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE`
Разберем шаги:
* ifconfig wlan0 down — отключаем интерфейс.
* iwconfig wlan0 mode ad-hoc — устанавливаем режим Ad-hoc
* iwconfig wlan0 channel 1 — ставим ad-hoc канал
* iwconfig wlan0 Bit 54Mb/s — скорость(по стандарту 11Mb/s)
* iwconfig wlan0 essid 'My Wifi' — название нашей созданной сети
* ifconfig wlan0 10.42.43.1 netmask 255.255.255.0 up — IP адрес компьютера и маска подсети
* iwconfig wlan0 — проверяем настройки
Вот мои:
`wlan0 IEEE 802.11bg ESSID:"Bupyc"
Mode:Ad-Hoc Frequency:2.412 GHz Cell: 8A:BF:88:4B:4E:60
Tx-Power=11 dBm
Retry long limit:7 RTS thr:off Fragment thr:off
Power Management:off
Link Quality:0 Signal level:0 Noise level:0
Rx invalid nwid:0 Rx invalid crypt:0 Rx invalid frag:0
Tx excessive retries:0 Invalid misc:0 Missed beacon:0`
* ifconfig wlan0 up — запускаем интерфейс
* echo 1 > /proc/sys/net/ipv4/ip\_forward
iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
Настраиваем раздачу интернета через NAT
Не забываем подставить свой интерфейс и IP адреса.
Данные команды можно добавить в автозагрузку, ибо эти настройки иногда сбрасываются
Настроим dhcp для раздачи ip адресов.
`sudo gedit /etc/dhcp3/dhcpd.conf`
Cтираем там все(если не нужно) и пишем
`ddns-update-style ad-hoc;
default-lease-time 3600;
max-lease-time 9000;
authoritative;
log-facility local7;
subnet 10.42.43.0 netmask 255.255.255.0 {
interface wlan0;
range 10.42.43.2 10.42.43.255;
option domain-name-servers 195.34.32.116; # пишем либо свой dns сервер, либо dns провайдера
option routers 10.42.43.1;
option broadcast-address 10.42.43.0;
}`
`sudo gedit /etc/default/dhcp3-server`
Там пишем интерфейс откуда идет интернет.
`INTERFACES="eth0"`
Перезапускаем dhcp
`sudo /etc/init.d/dhcp3-server restart`
Также для автоматической настройки можно прописать в файле /etc/network/interfaces все параметры.`sudo gedit /etc/network/interfaces
auto wlan0
iface wlan0 inet static
address 10.42.43.1
netmask 255.255.255.0
broadcast 10.42.43.255
network 10.42.43.0
wireless-essid Bupyc
wireless-mode ad-hoc
wireless-channel 11
wireless-rate 54Mb/s`
Теперь достаточно соединиться с любого устройства к данной сети и интернет будет работать.
Это первая моя статья на хабре, так что строго не судите. | https://habr.com/ru/post/88281/ | null | ru | null |
# Тест Йохансена на коинтеграцию
Цель данной статьи - поделиться результатами сравнительного анализ двух тестов на коинтеграцию, теста Энгла-Гренджера и теста Йохансена. Для этого нам понадобится рассмотреть соотношение между двумя и более переменными, понять, что такое VAR процесс, как перейти к VECM модели, в чем заключается процедура Йохансена, и как интерпретировать результат статистического теста, полученного от стандартного пакета типа Matlab.
VAR процесс
-----------
Регрессия полезна, когда анализируются только два ряда, потому что в этом случае может быть не более одного коэффициента коинтеграции. В случае со многими переменными может быть более одного вектора коинтеграции. Следовательно, нужна методология, которая бы определила структуру всех векторов коинтеграции.
Векторный авторегрессионный (VAR) процесс, основанный на гауссовых (нормально распределенных) ошибках, часто использовался в качестве описания макроэкономических временных рядов. Причин для этого много: VAR-модель гибкая, легко оцениваемая и, как правило, хорошо вписывается в макроэкономические данные. Однако возможность объединения долгосрочной и краткосрочной информации с использованием свойств коинтеграции, вероятно, является наиболее важной причиной, по которой VAR-модель продолжает вызывать интерес как у эконометристов, так и у прикладных экономистов.
Теоретические экономические модели традиционно разрабатывались как неслучайные математические сущности и часто применялись к эмпирическим данным путем добавления процесса случайных ошибок в математическую модель.
С эконометрической точки зрения эти два подхода принципиально отличаются друг от друга: первый начинается с явной случайной формулировки всех данных, а затем сужает общую статистическую (динамическую) модель путем наложения поддающихся проверке ограничений на параметры, второй начинается с математической (статической) формулировки теоретической модели, а затем расширяет модель путем добавления случайных компонентов.
К сожалению, было доказано, что эти два подхода, даже если применяются к идентичным данным, дают очень разные результаты, поэтому приводят к различным выводам. С научной точки зрения это неудовлетворительно. Поэтому здесь мы попытаемся преодолеть разрыв между двумя точками зрения, начав с некоторых типичных вопросов, которые представляют теоретический интерес, а затем покажем, как можно ответить на эти вопросы на основе статистического анализа VAR-модели. Поскольку статистический анализ по своей конструкции «больше», чем теоретическая модель, он не только отвечает на конкретные теоретические вопросы, но и дает дополнительное представление о макроэкономической проблеме.
Теоретическую модель можно упростить, сделав допущение «при прочих равных условиях», то есть что «все остальное неизменно», в то время как статистически четкая эмпирическая модель должна решать теоретическую проблему в контексте «все остальное меняется». Встраивая теоретическую модель в более широкие эмпирические рамки, анализ статистически обоснованной модели может подтвердить наличие подводных камней в макроэкономическом рассуждении. В этом смысле VAR-анализ может быть полезен для создания новых гипотез или для изменения слишком узко заданных теоретических моделей.
На практике полезно классифицировать переменные, которые характеризуются высокой степенью персистентности во времени (незначительный возврат к среднему), как нестационарные, а переменные, характеризующиеся значительной тенденцией возврата к среднему, как стационарные. Однако важно подчеркнуть, что стационарность / нестационарность или, наоборот, порядок интегрирования являются не свойством экономической переменной, а удобным статистическим приближением для разграничения краткосрочных, среднесрочных и долгосрочных изменений в данных.
Перейдем к случаю, когда мы наблюдаем вектор  переменных. В этом случае необходимо дополнительно обсудить ковариации между переменными в момент времени , а также их ковариации между моментами времени  и . Ковариации содержат информацию о статических и динамических связях между переменными, которую мы хотели бы раскрыть с помощью эконометрики. Для простоты  будет использоваться для обозначения как случайной величины, так и ее реализации.
Рассмотрим -мерный вектор :
![x_t = \left[\begin{array}{c} x_{1,t} \\ x_{2,t} \\ \vdots \\ x_{p,t} \\\end{array}\right], t = 1,\dots,T.](https://habrastorage.org/getpro/habr/upload_files/d8b/a7e/61e/d8ba7e61e9820c631601ea21aeb9cfce.svg)Введем следующее обозначение на случай, когда не были сделаны упрощающие предположения:
![E[x_t] = \left[\begin{array}{c} \mu_{1,t} \\ \mu_{2,t} \\ \vdots \\ \mu_{p,t} \\\end{array}\right], Cov[x_t,x_{t-h}] = \left[\begin{array}{cccc} \sigma_{11.h} & \sigma_{12.h} & \dots & \sigma_{1p.h} \\ \sigma_{21.h} & \sigma_{22.h} & \dots & \sigma_{2p.h} \\ \vdots & \vdots & \ddots & \vdots \\ \sigma_{p1.h} & \sigma_{p2.h} & \dots & \sigma_{pp.h} \\\end{array}\right] = \Sigma_{t.h}, t = 1,\dots,T.](https://habrastorage.org/getpro/habr/upload_files/7d1/db4/723/7d1db472364665e54e606f66553b3238.svg)Теперь предположим, что одно и то же распределение применимо ко всем  и что распределение приблизительно нормально, поэтому первые два момента вокруг среднего значения (центральные моменты) являются достаточными для описания вариации в данных. Введем обозначение:
![Z = \left[\begin{array}{c} x_1 \\ x_2 \\ \vdots \\ x_T \\\end{array}\right], E[Z] = \left[\begin{array}{c} \mu_1 \\ \mu_2 \\ \vdots \\ \mu_T \\\end{array}\right] = \tilde \mu,](https://habrastorage.org/getpro/habr/upload_files/00d/e07/0cf/00de070cfef179e12d7d01ee2fc8e7a5.svg)где  - вектор размерности . Ковариационная матрица представлена следующим образом
![E[(Z - \tilde \mu)(Z - \tilde \mu)'] = \left[\begin{array}{ccccc} \Sigma_{1.0} & \Sigma_{2.1}^{'} & \dots & \Sigma_{T-1.T-2}^{'} & \Sigma_{T.T-1}^{'} \\ \Sigma_{2.1} & \Sigma_{2.0} & & \dots & \Sigma_{T.T-2}^{'} \\ \vdots & \vdots & \ddots & \vdots & \vdots \\ \Sigma_{T-1.T-2} & \vdots & & \Sigma_{T-1.0} & \Sigma_{T.1}^{'} \\ \Sigma_{T.T-1} & \Sigma_{T.T-2} & \dots & \Sigma_{T.1} & \Sigma_{T.0} \\\end{array}\right] = \sum_{(Tp \times Tp)}^{\sim},](https://habrastorage.org/getpro/habr/upload_files/ba5/7f5/e1b/ba57f5e1b467f2ee3d2f270411fff33b.svg)где . Вышеприведенное обозначение дает полное общее описание многомерного нормального векторного случайного процесса. Поскольку параметров для оценки гораздо больше, чем наблюдений, то с практической точки зрения такое описание бесполезно, и необходимо упростить предположения для сокращения числа параметров. Эмпирические модели обычно основаны на следующих предположениях:
*  для всех , ;
*  для всех .
Теперь мы можем записать среднее значение и ковариации в более простой форме:
![\tilde \mu = \left[\begin{array}{c} \mu \\ \mu \\ \vdots \\ \mu \\\end{array}\right], \tilde \Sigma = \left[\begin{array}{ccccc} \Sigma_{0} & \Sigma_{1}^{'} & \Sigma_{2}^{'} & \dots & \Sigma_{T-1}^{'} \\ \Sigma_{1} & \Sigma_{0} & \Sigma_{1}^{'} & \ddots & \vdots \\ \Sigma_{2} & \Sigma_{1} & \Sigma_{0} & \ddots & \Sigma_{2}^{'} \\ \vdots & \ddots & \ddots & \ddots & \Sigma_{1}^{'} \\ \Sigma_{T-1} & \dots & \Sigma_{2} & \Sigma_{1} & \Sigma_{0} \\\end{array}\right].](https://habrastorage.org/getpro/habr/upload_files/c13/eda/a3b/c13edaa3b7ed93aa43f83d4b842172ce.svg)Два приведенных выше допущения для бесконечного  определяют слабо стационарный процесс. Когда эти два предположения будут выполнены, VAR-модель будет иметь постоянные параметры.
Пусть  - случайный процесс (упорядоченный ряд случайных переменных) для . Тогда  считается стационарным в широком смысле. Стационарность в узком смысле требует, чтобы распределение  было таким же, как  для 
* ![E[x_t] = -\infty < \mu < \infty](https://habrastorage.org/getpro/habr/upload_files/ef4/db7/a73/ef4db7a73992e6bde86480cd411ecc8f.svg) для всех ,
* ![E[x_t - \mu]^2 = \Sigma_{0} < \infty](https://habrastorage.org/getpro/habr/upload_files/75d/c70/698/75dc7069841dffc3ce054d009414f874.svg) для всех ,
* ![E[(x_t - \mu)(x_{t+h} - \mu)] = \Sigma_{h} < \infty](https://habrastorage.org/getpro/habr/upload_files/7f1/bda/ef1/7f1bdaef103109218b889d553e85f954.svg) для всех  и 
Эмпирический анализ начинается с матрицы ![X = [x_1,\dots,x_T]](https://habrastorage.org/getpro/habr/upload_files/1df/fd8/5ca/1dffd85ca9a31cd71b8b88d72ee96e8a.svg), где  - это  вектор переменных. Исходя из предположения, что наблюдаемые данные  являются реализацией случайного процесса, можно выразить совместную вероятность  при заданном начальном значении  и значении параметра , описывающего случайный процесс:
Для данной функции вероятности оценки максимального правдоподобия могут быть найдены путем максимизации функции правдоподобия. Здесь мы ограничимся обсуждением многомерного нормального распределения. Для выражения совместной вероятности  удобно использовать процесс  вместо  матрицы . Поскольку у  размерность , а у  - , то параметров гораздо больше, чем наблюдений без упрощения допущений. Но даже если мы вводим упрощающие ограничения на среднее значение и ковариации процесса, они не дают прямой информации об экономическом поведении. Поэтому, разложив совместный процесс на условный и частный, а затем последовательно повторяя разложение для частного процесса, мы можем получить более полезную формулировку:
где
![X_{t-1}^0 = [x_{t-1},x_{t-2},\dots,x_1,X_0].](https://habrastorage.org/getpro/habr/upload_files/721/255/b1f/721255b1f5d9a1a8f3c1dfa3e9be3c2b.svg)Теперь покажем, что VAR-модель является условным процессом
Можно увидеть, как  и  связаны с  и . Сначала разложим данные на два набора, вектор  и условный набор , то есть
![X = \left[\begin{array}{c} x_t \\ X_{t-1}^0 \\\end{array}\right].](https://habrastorage.org/getpro/habr/upload_files/f6b/69f/479/f6b69f47914f0948b2282bba306c5fd4.svg)Запишем частный и условный процесс:
![m_1 = E[x_t],](https://habrastorage.org/getpro/habr/upload_files/6b5/41c/d5f/6b541cd5fc2bf4066d30a8d4642402ba.svg)![y_{2,t} = \left[\begin{array}{c} x_{t-1} \\ x_{t-2} \\ \vdots \\ x_1 \\\end{array}\right],](https://habrastorage.org/getpro/habr/upload_files/f70/769/0ff/f707690ff1095995fb459cbcf82dabd1.svg)![m_2 = \left[\begin{array}{c} E[x_{t-1}] \\ E[x_{t-2}] \\ \vdots \\ E[x_1] \\\end{array}\right],](https://habrastorage.org/getpro/habr/upload_files/4a0/9fb/25d/4a09fb25dd0d8ab40c1920cf1a6b0d9c.svg)![\tilde \Sigma = \left[\begin{array}{c|ccc} \Sigma_0 & \Sigma_1^{'} & \dots & \Sigma_{T-1}^{'} \\ \hline \Sigma_1 & \Sigma_{0} & \Sigma_1^{'} & \vdots \\ \vdots & \ddots & \ddots & \Sigma_1^{'} \\ \Sigma_{T-1} & \dots & \Sigma_1 & \Sigma_0 \\\end{array}\right] = \left[\begin{array}{cc} \Sigma_{11} & \Sigma_{12} \\ \Sigma_{21} & \Sigma_{22} \\\end{array}\right].](https://habrastorage.org/getpro/habr/upload_files/79d/23c/978/79d23c9784d2ae8021131119b86c1be3.svg)Теперь можно вывести параметры условной модели:
где
и
Разница между наблюдаемым значением процесса и его условным средним значением обозначена как :
Подставляя выражение для условного среднего значения, получаем:
Используя обозначение , ![[\Pi_1,\Pi_2,\dots,\Pi_{T-1}] = \Sigma_{12} \Sigma_{22}^{-1}](https://habrastorage.org/getpro/habr/upload_files/2b1/1ed/1dd/2b11ed1dd2b8d04fa8d43cf8c4005fa3.svg) и принимая, что , получаем векторную авторегрессионную модель -го порядка:
где  - , а  считаются заданными.
Если верно предположение, что ![X = [x_1,x_2,\dots,x_T]](https://habrastorage.org/getpro/habr/upload_files/20c/2d1/bd3/20c2d1bd3f3b6e9f2d52980df27acbed.svg) является многомерным нормальным процессом, то из этого следует, что VAR-модель:
* линейна по параметрам;
* имеет постоянные параметры;
* имеет нормально распределенные ошибки .
Обратите внимание, что постоянство параметров зависит от постоянства ковариационных матриц  и . Если какая-либо из них изменится в результате преобразования или вмешательства во время анализа выборки, вероятно, изменятся как свободный член , так и «коэффициенты наклона» . Таким образом, допущения о постоянстве параметров сильно зависят от контекста и обычно требуют, чтобы для соответствующего периода времени моделировались все основные известные структурные изменения.
Было показано, что VAR-модель по сути представляет собой переформулировку ковариаций данных. Вопрос заключается в том, можно ли интерпретировать модель с точки зрения рационального экономического поведения, и если да, то можно ли использовать модель в качестве «плана эксперимента», когда данные собираются путем пассивных наблюдений. Идея заключается в интерпретации условного среднего значения  VAR-модели как описания планов агентов во время  с учетом имеющейся информации ![X_{t-1}^0 = [x_{t-1},\dots,x_{t-k}]](https://habrastorage.org/getpro/habr/upload_files/69d/d3b/f5f/69dd3bf5f4914bc83a218470bb3117c7.svg). В соответствии с допущениями VAR-модели, разница между средним значением и фактической реализацией представляет собой процесс белого шума
Таким образом, допущение  согласуется с экономическими агентами, которые рациональны в том смысле, что они не допускают систематических ошибок при составлении планов на время  на основе имеющейся информации в момент времени . Например, VAR-модель с автокоррелированными и/или гетероскедастическими остатками описывает агентов, которые не используют всю информацию, содержащуюся в данных, как можно более эффективно. Это связано с тем, что, включив систематические изменения в остатки, агенты могут повысить точность, с которой они реализуют свои планы. Поэтому проверка предположений модели, то есть проверка остатков на соответствие белому шуму, имеет решающее значение не только для правильного статистического вывода, но и для экономической интерпретации модели как примерного описания поведения рациональных агентов.
К сожалению, во многих экономических приложениях допущение о многомерной нормальности для VAR-модели в ее простейшей форме не выполняется. Поскольку в целом статистические выводы справедливы только в той степени, в какой удовлетворяются предположения, заложенные в основу модели, это потенциально является серьезной проблемой. Поэтому нужно спросить, возможно ли модифицировать базовую VAR-модель таким образом, чтобы она сохраняла свою привлекательность в качестве удобного описания основных свойств данных и в то же время позволяла делать обоснованные выводы.
Исследования в области моделирования показали, что достоверные статистические выводы чувствительны к нарушению некоторых допущений, таких как параметрическая нестабильность, автокорреляция остатков (чем выше, тем хуже) и асимметричные остатки, при этом достаточно устойчивы к другим, таким как избыточный коэффициент эксцесса и гетероскедастичность остатков.
В любом случае, прямое или косвенное тестирование предположений имеет решающее значение для успеха эмпирического применения. Как только мы поймем причины, по которым модель не удовлетворяет допущениям, часто появляется возможность модифицировать модель, чтобы в итоге получить статистически «хорошо себя зарекомендовавшую» модель. Важными инструментами в этом контексте являются:
* использование интервенционных фиктивных переменных для объяснения значимых политических или институциональных событий в выборке;
* обусловленность слабо или сильно экзогенными переменными;
* проверка измерений выбранных переменных;
* коррекция периода выборки, чтобы избежать структурных изменений или разделить выборку на более однородные периоды.
ECM процесс
-----------
Так называемая векторная модель исправления ошибок (далее VECM) дает удобную переформулировку VAR-модели в терминах разностей, запаздывающих разностей и уровней процесса. У этой формулировки есть несколько преимуществ:
1. Эффект мультиколлинеарности, который обычно сильно проявляется в данных временных рядов, значительно снижается в форме исправления ошибок. Разности гораздо более «ортогональны», чем уровни переменных.
2. Вся информация о долгосрочных эффектах обобщается в матрице уровней (в дальнейшем обозначена как ). Следовательно, ей можно уделить особое внимание при решении проблемы коинтеграции.
3. Интерпретация оценок интуитивно более понятна, поскольку коэффициенты можно естественным образом разделить на краткосрочные и долгосрочные эффекты.
4. Формулировка VECM дает прямой ответ на вопрос, «почему цена актива изменилась с предыдущего по настоящий период в результате изменений в выбранном наборе информации».
Теперь рассмотрим модель VAR, сформулированную в общей форме VECM без константы и тренда:
где  - целое число между 1 и , определяющее положение лага ECM-члена. Обратите внимание, что значение функции правдоподобия не меняется даже при изменении значения .
VAR(2)-модель в VECM формулировке при определена как:
где , а . В уравнении лагированная матрица уровней  находится во времени .
CVAR процесс
------------
Рассмотрим нестационарную VAR-модель и покажем, что наличие единичных корней (стохастических трендов) приводит к условию неполного ранга  на матрице долгосрочных уровней .
Коинтеграция подразумевает, что определенные линейные комбинации переменных векторного процесса интегрированы более низким порядком, чем сам процесс. Таким образом, если нестационарность одной переменной соответствует нестационарности другой, то существует их линейная комбинация, которая становится стационарной. Другой способ выразить это взаимоотношение заключается в том, что когда две или несколько переменных имеют общие стохастические (и детерминистические) тренды, они будут иметь тенденцию двигаться вместе в долгосрочной перспективе. Такие векторы коинтеграции  часто могут быть интерпретированы как долгосрочные равновесные соотношения переменных и, следовательно, представляют значительный экономический интерес.
В рамках VAR-модели гипотеза о коинтеграции может быть сформулирована в виде ограничения на неполный ранг матрицы . Воспроизведем ниже VAR(2)-модель в виде ECM с :
и дадим оценку неограниченной матрице .
Если , то . Из этого следует, что  не может иметь полного ранга, так как обратное приведет к логическому несоответствию в уравнении. Рассмотрим  как простую матрицу с полным рангом. В этом случае в каждом уравнении стационарная переменная  будет равна нестационарной переменной  плюс некоторые запаздывающие стационарные переменные  и член со стационарной ошибкой. Поскольку стационарная переменная не может быть равна нестационарной переменной, то либо , либо матрица должна иметь неполный ранг:
где  и  - -матрицы, . Таким образом, при гипотезе  имеем коинтегрированную VAR(2)-модель:
где  -  - вектор коинтеграции.  интерпретируется как скорость приведения процесса к равновесию. В соответствии с гипотезой о том, что , все стохастические компоненты в модели являются стационарными, и система теперь логически непротиворечива.
Если , то  стационарно, и применяется стандартный вывод. Если , то в  существует  автономных трендов, так что каждый  является нестационарным со своим собственным индивидуальным трендом. По сути мы имеем VAR-процесс в ряде разностей. В этом случае векторный процесс управляется  различными стохастическими трендами, и невозможно получить векторы коинтеграции между уровнями переменных. Мы говорим, что переменные не имеют общих стохастических трендов и, следовательно, не движутся вместе во времени.
В этом случае VAR-модель с уровнями может быть переформулирована в VAR-модель с разностями без потери долгосрочной информации. Поскольку  , в модели с разностями применяется стандартный вывод. Если  , то  и существует  направлений, по которым процесс можно сделать стационарным с помощью линейных комбинаций. Это и есть векторы коинтеграции. Причина нашего интереса к ним заключается в том, что они часто могут быть интерпретированы как отклонения от стабильных экономических отношений.
R процесс (консолидация общей VAR модели)
-----------------------------------------
Рассмотрим VARмодель в форме ECM с :
где , - это вектор, ,  - количество детерминированных компонент, таких как константа или тренд, а начальные значения  считаются заданными.
Мы используем следующие сокращенные обозначения:
![Z_{0t} = \Delta x_t,\\Z_{1t} = \tilde x_{t - 1},\\Z_{2t} = [\Delta x'_{t -1}, \Delta x'_{t-2}, \dots, \Delta x'_{t - k + 1}],](https://habrastorage.org/getpro/habr/upload_files/860/758/c6c/860758c6c96eaacf910f6e26ed73c11b.svg)тогда мы можем переписать VARмодель в более компактной форме:
где ![\Psi = [\Gamma_1, \Gamma_2, \dots, \Gamma_{k - 1}]](https://habrastorage.org/getpro/habr/upload_files/16e/caa/76d/16ecaa76da984c15654fa7bce97e82a3.svg). Теперь мы консолидируем краткосрочные «транзитные» эффекты, , чтобы получить «чистую» модель долгосрочной коррекции. Чтобы объяснить идею «консолидации», которая используется во многих различных ситуациях в эконометрике, мы сначала проиллюстрируем ее использование в модели множественной регрессии.
Теорема Фриша-Во-Ловела (Frisch-Waugh-Lovell, FWL) гласит, что OLS-оценка  в модели линейной регрессии,  может быть получена в два этапа.
1. Построить регрессию от , получая остатки из .
Построить регрессию от , получая остатки из .
2. Построить регрессию от , чтобы получить оценку , то есть .
Таким образом сначала мы консолидируем влияние на и , а затем строим регрессию для «очищенного» , то есть , от «очищенного» , то есть .
Воспользуемся той же идеей для VAR-модели. Сначала определим вспомогательные регрессии:
где ,  - МНК оценки, . Таким образом, это эмпирические аналоги ковариационных матриц .
Консолидированная модель
важна для понимания как статистических, так и экономических свойств VAR-модели. Путем консолидации исходная «грязная» VAR, содержащая краткосрочные эффекты коррекции и интервенции, была преобразована в «чистую» равновесную форму коррекции, в которой коррекция происходит исключительно в направлении долгосрочных равновесных отношений. Это означает, что мы не только преобразовали «грязную» эмпирическую модель в красивую статистическую модель, но и в более интерпретируемую экономическую форму.
Тест Йохансена
--------------
Тест Йохансена, также называемый LR-тестом на коинтеграционный ранг или тестом следа (трейс тестом), основан на VAR-модели в R-форме, где сконцентрирована вся краткосрочная динамика, фиктивные и другие детерминированные компоненты:
Тест Йохансена называется тестом следа, потому что асимптотическое распределение статистики является следом матрицы, основанной на функциях броуновского движения или стандартных винеровских процессах. Тест Йохансена для определения ранга коинтеграции  включает следующие гипотезы:
*  , то есть наличие  единичных корней,  векторов коинтеграции, нестационарны;
*  , то есть отсутствие единичных корней, стационарны.
Соответствующая LR-статистика имеет вид (статистика следа):
где  можно интерпретировать как квадрат канонических корреляций между линейной комбинацией уровней  и линейной комбинацией разностей . В этом смысле величина  является показателем того, насколько сильно линейное отношение  коррелирует со стационарной частью процесса  . Когда  , линейная комбинация нестационарна и не существует поправки на равновесие.
Процедура тестирования заключается в следующем. Сначала проверяется нулевая гипотеза о том, что существует один вектор коинтеграции, затем гипотеза о двух векторах и т.д. Мы отвергаем нулевую гипотезу, что - число векторов коинтеграции - меньше чем , если значение статистического критерия больше указанного критического значения.
Также возможна проверка нулевой гипотезы против альтернативной о том, что ранг на единицу больше, чем предполагается в нулевой гипотезе:
*  ;
*  .
В таком случае применяется статистика максимального собственного числа:
Пример: преобразование VAR(3) в ECM
-----------------------------------
Возьмем в качестве примера VAR(3) процесс:
Это достаточно сложное уравнение может быть выражено в матричной форме (опустим вектор с ошибками для краткости):
![\left[\begin{array}{c} x_{1,t} \\ x_{2,t} \\\end{array}\right] = \left[\begin{array}{cc} a_1 & b_1 \\ c_1 & d_1 \\\end{array}\right] \cdot \left[\begin{array}{c} x_{1,t-1} \\ x_{2,t-1} \\\end{array}\right] + \left[\begin{array}{cc} a_2 & b_2 \\ c_2 & d_2 \\\end{array}\right] \cdot \left[\begin{array}{c} x_{1,t-2} \\ x_{2,t-2} \\\end{array}\right] + \left[\begin{array}{cc} a_3 & b_3 \\ c_3 & d_3 \\\end{array}\right] \cdot \left[\begin{array}{c} x_{1,t-3} \\ x_{2,t-3} \\\end{array}\right],](https://habrastorage.org/getpro/habr/upload_files/f41/084/a9a/f41084a9adc574a8655fe4f05445a617.svg)![\left[\begin{array}{c} x_{1,t} \\ x_{2,t} \\\end{array}\right] = \Pi_1 \cdot \left[\begin{array}{c} x_{1,t-1} \\ x_{2,t-1} \\\end{array}\right] + \Pi_2 \cdot \left[\begin{array}{c} x_{1,t-2} \\ x_{2,t-2} \\\end{array}\right] + \Pi_3 \cdot \left[\begin{array}{c} x_{1,t-3} \\ x_{2,t-3} \\\end{array}\right] + \left[ \begin{array}{c} \varepsilon_{1,t} \\ \varepsilon_{2,t} \\ \end{array} \right].](https://habrastorage.org/getpro/habr/upload_files/b03/9d4/b54/b039d4b54f162e69a805866b9275e455.svg)Далее мы должны преобразовать модель через разности. Это можно сделать следующим образом. Во-первых, мы вычитаем
![\left[ \begin{array}{c} x_{1,t-1} \\ x_{2,t-1} \\ \end{array} \right]](https://habrastorage.org/getpro/habr/upload_files/a08/cd2/8f1/a08cd28f15f39080f49504e9ea18a04f.svg)из обеих частей уравнения, преобразуя левую сторону уравнения в разности:
![\left[\begin{array}{c} x_{1,t} \\ x_{2,t} \\\end{array}\right] - \left[\begin{array}{c} x_{1,t-1} \\ x_{2,t-1} \\\end{array}\right] = \Pi_1 \cdot \left[\begin{array}{c} x_{1,t-1} \\ x_{2,t-1} \\\end{array}\right] - \left[\begin{array}{c} x_{1,t-1} \\ x_{2,t-1} \\\end{array}\right] + \Pi_2 \cdot \left[\begin{array}{c} x_{1,t-2} \\ x_{2,t-2} \\\end{array}\right] + \Pi_3 \cdot \left[\begin{array}{c} x_{1,t-3} \\ x_{2,t-3} \\\end{array}\right],](https://habrastorage.org/getpro/habr/upload_files/51c/0fd/e54/51c0fde549c2a2912c592b883141c554.svg)![\left[\begin{array}{c} \Delta x_{1,t} \\ \Delta x_{2,t} \\\end{array}\right] = (\Pi_1 - I) \cdot \left[\begin{array}{c} x_{1,t-1} \\ x_{2,t-1} \\\end{array}\right] + \Pi_2 \cdot \left[\begin{array}{c} x_{1,t-2} \\ x_{2,t-2} \\\end{array}\right] + \Pi_3 \cdot \left[\begin{array}{c} x_{1,t-3} \\ x_{2,t-3} \\\end{array}\right] + \left[ \begin{array}{c} \varepsilon_{1,t} \\ \varepsilon_{2,t} \\ \end{array} \right].](https://habrastorage.org/getpro/habr/upload_files/6ef/72f/b72/6ef72fb720d9468578eabd28405de1d7.svg)Мы можем преобразовать это выражение следующим образом:
![\left[\begin{array}{c} \Delta x_{1,t} \\ \Delta x_{2,t} \\\end{array}\right] = (\Pi_1 - I) \cdot \left[\begin{array}{c} x_{1,t-1} \\ x_{2,t-1} \\\end{array}\right] + (\Pi_2 + \Pi_1 - I - (\Pi_1 - I)) \cdot \left[\begin{array}{c} x_{1,t-2} \\ x_{2,t-2} \\\end{array}\right] + \\ + \Pi_3 \cdot \left[ \begin{array}{c} x_{1,t-3} \\ x_{2,t-3} \\ \end{array} \right].](https://habrastorage.org/getpro/habr/upload_files/47a/f72/351/47af723517c4f28b59f56bc2b8bb1643.svg)Открывая скобки, получаем:
![\left[\begin{array}{c} \Delta x_{1,t} \\ \Delta x_{2,t} \\\end{array}\right] = (\Pi_1 - I) \cdot \left[\begin{array}{c} x_{1,t-1} \\ x_{2,t-1} \\\end{array}\right] + (\Pi_1 + \Pi_2 - I) \cdot \left[\begin{array}{c} x_{1,t-2} \\ x_{2,t-2} \\\end{array}\right] - (\Pi_1 - I) \cdot \left[\begin{array}{c} x_{1,t-2} \\ x_{2,t-2} \\\end{array}\right] + \\ + \Pi_3 \cdot \left[\begin{array}{c} x_{1,t-3} \\ x_{2,t-3} \\\end{array}\right].](https://habrastorage.org/getpro/habr/upload_files/b37/13d/f59/b3713df59bffb94a3efac3291b4e17eb.svg)Группируем члены с общими множителями:
![\left[\begin{array}{c} \Delta x_{1,t} \\ \Delta x_{2,t} \\\end{array}\right] = (\Pi_1 - I) \cdot \left(\left[\begin{array}{c} x_{1,t-1} \\ x_{2,t-1} \\\end{array}\right] - \left[\begin{array}{c} x_{1,t-2} \\ x_{2,t-2} \\\end{array}\right]\right) + (\Pi_1 + \Pi_2 - I) \cdot \left[\begin{array}{c} x_{1,t-2} \\ x_{2,t-2} \\\end{array}\right] + \\ + \Pi_3 \cdot \left[\begin{array}{c} x_{1,t-3} \\ x_{2,t-3} \\\end{array}\right].](https://habrastorage.org/getpro/habr/upload_files/d7d/cbe/f38/d7dcbef38a4cdc5fffffd7616c623d53.svg)В результате получим выражение:
![\left[\begin{array}{c} \Delta x_{1,t} \\ \Delta x_{2,t} \\\end{array}\right] = (\Pi_1 - I) \cdot \left[\begin{array}{c} \Delta x_{1,t-1} \\ \Delta x_{2,t-1} \\\end{array}\right] + (\Pi_1 + \Pi_2 - I) \cdot \left[\begin{array}{c} x_{1,t-2} \\ x_{2,t-2} \\\end{array}\right] + \Pi_3 \cdot \left[\begin{array}{c} x_{1,t-3} \\ x_{2,t-3} \\\end{array}\right].](https://habrastorage.org/getpro/habr/upload_files/095/52b/280/09552b280aae10d8d6046fdac3103327.svg)Схожая процедура применяется по отношению к матрице :
![\left[\begin{array}{c} \Delta x_{1,t} \\ \Delta x_{2,t} \\\end{array}\right] = (\Pi_1 - I) \cdot \left[\begin{array}{c} \Delta x_{1,t-1} \\ \Delta x_{2,t-1} \\\end{array}\right] + (\Pi_1 + \Pi_2 - I) \cdot \left[\begin{array}{c} x_{1,t-2} \\ x_{2,t-2} \\\end{array}\right] + \\ + (\Pi_3 + \Pi_1 + \Pi_2 - I - (\Pi_1 + \Pi_2 - I)) \cdot \left[\begin{array}{c} x_{1,t-3} \\ x_{2,t-3} \\\end{array}\right].](https://habrastorage.org/getpro/habr/upload_files/899/6ac/d83/8996acd8339b41a52c17c416c2aa3e4b.svg)Открывая скобки, получаем:
![\left[\begin{array}{c} \Delta x_{1,t} \\ \Delta x_{2,t} \\\end{array}\right] = (\Pi_1 - I) \cdot \left[\begin{array}{c} \Delta x_{1,t-1} \\ \Delta x_{2,t-1} \\\end{array}\right] + (\Pi_1 + \Pi_2 - I) \cdot \left[\begin{array}{c} x_{1,t-2} \\ x_{2,t-2} \\\end{array}\right] +\\ + (\Pi_1 + \Pi_2 + \Pi_3 - I) \cdot \left[\begin{array}{c} x_{1,t-3} \\ x_{2,t-3} \\\end{array}\right] - (\Pi_1 + \Pi_2 - I) \cdot \left[\begin{array}{c} x_{1,t-3} \\ x_{2,t-3} \\\end{array}\right].](https://habrastorage.org/getpro/habr/upload_files/56b/2fd/8c4/56b2fd8c41fb84a4c113e4c0639fd85e.svg)Группируем члены с общими множителями:
![\left[\begin{array}{c} \Delta x_{1,t} \\ \Delta x_{2,t} \\\end{array}\right] = (\Pi_1 - I) \cdot \left[\begin{array}{c} \Delta x_{1,t-1} \\ \Delta x_{2,t-1} \\\end{array}\right] + (\Pi_1 + \Pi_2 - I) \cdot \left( \left[\begin{array}{c} x_{1,t-2} \\ x_{2,t-2} \\\end{array}\right] - \left[\begin{array}{c} x_{1,t-3} \\ x_{2,t-3} \\\end{array}\right] \right) + \\ + (\Pi_1 + \Pi_2 + \Pi_3 - I) \cdot \left[\begin{array}{c} x_{1,t-3} \\ x_{2,t-3} \\\end{array}\right].](https://habrastorage.org/getpro/habr/upload_files/dc9/bce/327/dc9bce327cd0ebefa5010c66c5efb6d9.svg)В результате получаем:
![\left[\begin{array}{c} \Delta x_{1,t} \\ \Delta x_{2,t} \\\end{array}\right] = (\Pi_1 - I) \cdot \left[\begin{array}{c} \Delta x_{1,t-1} \\ \Delta x_{2,t-1} \\\end{array}\right] + (\Pi_1 + \Pi_2 - I) \cdot \left[\begin{array}{c} \Delta x_{1,t-2} \\ \Delta x_{2,t-2} \\\end{array}\right] + \\ + (\Pi_1 + \Pi_2 + \Pi_3 - I) \cdot \left[\begin{array}{c} x_{1,t-3} \\ x_{2,t-3} \\\end{array}\right].](https://habrastorage.org/getpro/habr/upload_files/4b9/48c/cdb/4b948ccdb9a9b8dade98b6a795cdbd1e.svg)Обозначим , , , получим VAR(3) модель в ECM форме:
Мы видим, что VAR-процесс уровней рядов может быть записан как VAR-процесс разностей за исключением одного члена .
Ранг матрицы  дает число векторов коинтеграции в рядах динамики (ранг матрицы - это число линейно независимых рядов). Таким образом, ранг матрицы говорит о том, что следует делать. Если  имеет нулевой ранг, то матрица  - нулевая. Это показывает, что коинтеграции в рядах данных нет, и для достижения стационарности требуется нахождение разностей.
Если матрица  - полная, то ряды уже стационарны (матрица  имеет обратную, и, таким образом, выражение может быть решено для уровней, выраженных в разностях. Это будет верным только если ряды уровней ).
Если ранг  лежит между 0 и  ( , в нашем случае , ), то существует  векторов коинтеграции. Модель исправления ошибки включает в себя краткосрочные изменения, которые поддерживают долгосрочное равновесие.
Тест Йохансена в MATLAB
-----------------------
У нас есть два ряда цен акций, и . Мы хотим, чтобы и были коинтегрированными, то есть чтобы ранг коинтеграции был равен 1. Рассмотрим два тикера Московской биржи, TATN  и TATNP  за 2020 год:
Динамика цен акций TATN и TATNPТест Йохансена выполняется с помощью функции jcitest, которая на вход принимает массив из временных рядов, в данном случае размера , где  - количество торговых дней. На выходе функция возвращает логическое значение, равное 1, если нулевая гипотеза отвергается в пользу альтернативной, и 0 – иначе.
```
testPrices(:,1) = prices(:,indexY);
testPrices(:,2) = prices(:,indexX);
[hjt,pValuejt,statjt,cValuejt,mles] = jcitest(testPrices, 'model', 'H2');
[hjtm,pValuejtm,statjtm,cValuejtm,mlesm] = jcitest(testPrices, 'model', 'H2', 'test', 'maxeig');
```
#### Статистика следа
Дальше начинается самое интересное: программа выдает ответ, который обычному человеку сложно понять, потому что он приходит в виде массива логических значений.
Результат теста Йохансена для статистики следаВикипедия нас к такому не готовила, поэтому давайте разберемся, что здесь происходит. Гипотетически тест следа может привести к трем различным вариантам ранга коинтеграции и, следовательно, количествам единичных корней.
1. , , когда 
2. , , когда , 
3. , , когда , 
где  - статистика следа, - соответствующие критические значения,  в нашем случае равно 2, так как у нас две переменные,  (TATN) и  (TATNP). Поэтому, чтобы оценить значение  , мы должны выполнить последовательность тестов.
Отметим, что асимптотические таблицы определяются так, что когда  истинна, тогда , где  задается как:
Рассмотрим результат теста для нулевого ранга. В чем здесь заключается нулевая гипотеза?
*  , то есть наличие 2 единичных корней, 0 векторов коинтеграции, и  нестационарны;
*  , то есть отсутствие единичных корней,  и  стационарны;
* .
Из ответа матлаба мы видим, что нулевая гипотеза отвергается для нулевого ранга ( для ). Это означает, что  асимптотически.
Рассмотрим результат теста для первого ранга. В чем здесь заключалась нулевая гипотеза?
*  , то есть наличие 1 единичного корня, 1 вектора коинтеграции, и  нестационарны;
*  , то есть отсутствие единичных корней,  и  стационарны;
* .
Следующее значение  соответствует , истинному коинтеграционному числу, а  в соответствии с ответом матлаба о том, что нулевая гипотеза не отвергается для первого ранга (  для ). Таким образом последний вариант .
Резюмируем:
* 
* 
* 
Таким образом правильное значение  асимптотически принимается в 95% всех случаев, что как раз и должна делать процедура 5%-ного теста.
#### Статистика максимального собственного числа
Практически тот же самый результат мы видим для статистики максимального собственного числа.
Результат теста Йохансена для статистики максимального собственного числаЗдесь у нас есть следующие варианты:
* , когда 
* , когда , 
где  - статистика максимального собственного числа, - соответствующие критические значения.
Напомним, что  задается как:
Рассмотрим результат теста для нулевого ранга. В чем здесь заключается нулевая гипотеза?
* 
* 
* 
Из ответа матлаба мы видим, что нулевая гипотеза отвергается для нулевого ранга ( для ). Это означает, что  асимптотически.
Рассмотрим результат теста для первого ранга. В чем здесь заключалась нулевая гипотеза?
* 
* 
* 
Следующее значение  соответствует истинному коинтеграционному числу, а  в соответствии с ответом матлаба о том, что нулевая гипотеза не отвергается для первого ранга (  для ).
По результатам обеих статистик мы видим, что пара (TATN, TATNP) является коинтегрированной.
Тест Энгла-Грэнджера vs Тест Йохансена
--------------------------------------
Мной была проанализирована 1 621 пара акций Московской биржи за 2020 год на дневных данных. В 87% случаев результаты теста Энгла-Гренджера и теста Йохансена совпали.
Также было проанализировано 3 193 890 пар на американских биржах (NYSE, NASDAQ и AMEX) за 2020 год на дневных данных. Также в 87% случаев результаты теста Энгла-Гренджера и теста Йохансена совпали.
Еще было проанализировано 21 725 пар на криптобиржах (Poloniex, Binance, Kraken) за 2020 год на дневных данных. В 86% случаев результаты теста Энгла-Гренджера и теста Йохансена совпали.
С практической точки зрения для принятия решения о том, стоит ли добавлять пару активов в портфель, а также для оценки весовых коэффициентов лучше использовать оба теста на коинтеграцию. | https://habr.com/ru/post/686314/ | null | ru | null |
# Биткоин-кошельки: зачем и как хранить свои приватные ключи
*Перевод статьи*[*Bitcoin Wallets*](https://www.swanbitcoin.com/bitcoin-wallets-not-your-keys-not-your-bitcoin)*подготовлен биткоинером*[*Tony ₿*](https://twitter.com/TonyCrusoe)
Итак, вы приобрели немного биткоинов, и теперь столкнулись со следующим вопросом: как их лучше всего хранить? Мы поможем вам подобрать тот кошелек, который подойдет именно вам.
Хотя ничего сложного, на первый взгляд, в этом нет, выбор кошелька сопряжен с немалым количеством нюансов. *Сколько у вас биткоинов? Как часто вы планируете их тратить? Вы уверены, что ваши ключи в большей безопасности, чем в холодном кастодиальном хранилище?* Ответы на эти вопросы помогут найти правильное решение именно для вас.
Биткоин является активом на предъявителя, а это значит, что вы можете хранить ключи от своих биткоинов самостоятельно. Когда вы храните свои собственные биткоин-ключи, вы напрямую контролируете свои деньги. Таким образом, вам не приходится обращаться к услугам третьей стороны (например, банку) и доверять ей. Поэтому, как только вы с уверенностью сможете заявить, что риск личного хранения ваших ключей ниже, чем риск потери их кастодиальным хранителем, становится просто необходимо настроить схему самостоятельного хранения собственных биткоинов. Принятие этого решения зависит, главным образом, от вашего понимания того, как и зачем хранить свои собственные биткоин-ключи. В этой статье мы поможем вам прийти к пониманию как первого, так и второго.
В этой статье мы рассмотрим следующие аспекты:
* “Не твои ключи — не твои биткоины”
* Безопасность против удобства
* Разновидности биткоин-кошельков
* Мультиподпись (мультисиг)
* Наша рекомендация по выбору оптимального кошелька именно для ВАС
Ну что ж, начнем!
Биткоин — актив на предъявителя
-------------------------------
В криптографии публичный ключ используется для шифрования сообщений, а приватный ключ — для их расшифровки. Если кто-то хочет отправить вам зашифрованное сообщение, он шифрует его вашим публичным ключом. Ваш приватный ключ — единственный способ расшифровать это сообщение, поэтому, пока вы — единственный владелец приватного ключа, никому кроме вас не удастся прочитать это сообщение.
Биткоин использует криптографию публичного и приватного ключей для обеспечения безопасности транзакций. При создании биткоин-кошелька создается приватный ключ. Кошелек создает публичные ключи, которые хешируются и используются в качестве адресов для получения биткоинов. Приватный ключ необходим для подтверждения владения биткоинами, хранящимися по соответствующему адресу. Он же предоставляет возможность потратить монеты.
Если вы лично не контролируете приватные ключи, связанные с вашими биткоинами, то на самом деле вы не являетесь обладателем своих биткоинов. Другими словами, если биржа или банк хранит ваши биткоины от вашего имени, вы не контролируете свои монеты напрямую. Вы передаете ответственность за обеспечение безопасности своих биткоинов третьей стороне, а вместе с ответственностью вы передаете и сами монеты.
Чтобы в полной мере воспользоваться уникальными свойствами Биткоина в качестве денег, вам необходимо самостоятельно контролировать собственные приватные ключи. Как часто говорят сами биткоинеры, “не твои ключи — не твои биткоины”. Самостоятельное хранение приватных ключей позволяет убедиться в том, что ваши монеты не могут ни конфисковать, ни изъять, ни украсть. Но решение хранить свои собственные ключи делает вас ответственным за безопасность собственных биткоинов. Наша цель — помочь вам освоиться с перспективой хранения своих собственных ключей.
Теперь рассмотрим возможные варианты управления собственными биткоин-ключами.
`безопасность против удобства`
Компромиссы кастодиального хранения
-----------------------------------
Главный выбор, который придется сделать при хранении биткоинов — это соотношение безопасности и удобства. Очевидно, что безопасность и удобство — это важные и необходимые характеристики при хранении чего-либо, однако они прямо противоположны друг другу.
Вопрос заключается в том, где непосредственно в спектре "Безопасность — Удобство" вы находитесь.
Чтобы лучше понять, какой способ хранения является наиболее оптимальным именно для вас, примите во внимание следующее:
* Общая стоимость - храните ли вы порядка 0,1%, 1% или более 10% вашего капитала в биткоинах? Наиболее приемлемый способ хранения ваших биткоинов напрямую зависит от ответа на этот вопрос. Очевидно, вы будете готовы испытать определенные неудобства, если это гарантирует более надежную защиту 50% вашего капитала.
* Сроки / Доступность - Когда и как часто вам необходимо тратить свои биткоины? Данный биткоин-кошелек является скорее текущим счетом, среднесрочным сберегательным счетом или больше напоминает долгосрочный пенсионный счет?
*Профессиональный совет:*не усложняйте схему хранения до такой степени, чтобы самому забыть, как получить доступ к средствам. Интернет кишит историями биткоинеров о владельцах, потерявших свои монеты в силу использования слишком сложных настроек, в результате чего они забывали, как получить доступ к своим монетам.
Обзор кошельков: бумажные, аппаратные, мобильные, десктопные и мультисиг биткоин-кошельки
-----------------------------------------------------------------------------------------
Теперь, когда вы решили приобрести биткоин (отличное решение), пришло время определиться, где хранить ваши монеты. В самом начале пути этот выбор может показаться ошеломляющим. В этом разделе мы предоставим краткий обзор возможных вариантов хранения. Как и большинство вещей в жизни, все сводится к компромиссам.
**Бумажные биткоин-кошельки**
*Что это такое:*пользователи распечатывают приватные ключи и адреса Биткоина на листе бумаги.
*Плюсы:* доступ к приватным ключам через интернет невозможен. Этот вариант подходит для длительного хранения.
*Минусы:* трудно сделать резервную копию, если вы потеряли лист бумаги, вы потеряли свои биткоины. Пользователи вынуждены ламинировать и хранить кошелек в пожароустойчивом месте. Для простоты траты биткоинов необходимо импортировать данные в программный или аппаратный кошелек.
**Аппаратные биткоин-кошельки**
*Что это такое:* пользователи хранят приватные ключи при помощи специального оборудования.
*Плюсы:* доступ к аппаратному кошельку получить гораздо проще, чем к бумажному; приватные ключи никогда не касаются интернета, что снижает риск их потери; эффективны для длительного хранения. Если вы потеряете свой аппаратный кошелек, вы можете использовать сид-фразу (фразу резервного копирования) для восстановления данных.
*Минусы:* необходимо создать резервную копию исходной фразы, которую обычно пишут на бумаге и поэтому у нее те же проблемы, что и бумажных кошельков. Если ваш аппаратный кошелек украдут, существует риск того, что ваши средства будут взломаны, хотя это значительно сложнее, чем украсть монеты с простого бумажного кошелька.
*Примеры:*Ledger, Trezor, Coldcard, BitBox
**Мобильные биткоин-кошельки**
*Что это такое:* пользователи хранят приватные ключи на мобильном устройстве.
*Плюсы:* простота в использовании; удобно для начинающих; хорошее решения для небольших сумм, удобно для повседневных платежей, даже учитывая, что не так много пользователей часто тратят свои биткоины прямо сейчас (слишком высокая выгода долгосрочного хранения).
*Минусы:* наименее безопасный вариант, поскольку приватные ключи хранятся на устройстве, подключенном к интернету. Если злоумышленник получает физический доступ к вашему телефону, средства могут быть оперативно отправлены на подконтрольные ему кошельки. Не подходит для длительного хранения.
*Примеры:* Blockstream Green, Samourai (только Android)
**Десктопные биткоин-кошельки**
*Что это такое:* пользователи хранят приватные ключи на своем компьютере.
*Плюсы:* хороший UX; удобно для повседневных платежей, даже учитывая, что не так много пользователей часто тратят свои биткоины прямо сейчас (слишком высокая выгода долгосрочного хранения).
*Минусы:* не самый безопасный вариант, так как компьютеры,как правило, подключены к интернету и уязвимы к атакам -> не подходят для длительного хранения средств.
*Примеры:* Bitcoin Core, Wasabi, Electrum; Wasabi, вероятно, лучший биткоин-кошелек для Mac и один из лучших анонимных биткоин-кошельков.
**Мультисиг биткоин-кошельки**
*Что это такое:* пользователи хранят приватные ключи в специальном кошельке, для авторизации которого требуется несколько приватных ключей, в противном случае ваши средства не могут быть перемещены. Например, в мультисиг-кошельке “2-из-3” для отправки средств пользователю требуются любые два из трех приватных ключей.
*Плюсы:* один из самых безопасных способов хранения ваших биткоинов; снижает эффективность физических атак; схема пригодна для длительного хранения.
*Минусы:* более сложная схема настройки, но существует несколько сервисов, облегчающих процесс; тратить биткоины сложнее, но в этом и заключается суть схемы.
*Примеры:* хранилище Unchained Capital (2-из-3), Casa (2-из-3 и 3-из-5), Blocksteam Green (2-из-2), Electrum.
“Горячие” биткоин-кошельки против “холодных”: в чем разница?
------------------------------------------------------------
Горячие кошельки подключены к интернету. Это означает, что ваши ключи доступнее, чем в случае с аппаратным кошельком. При этом ваши средства более уязвимы для хакеров. Горячие кошельки рекомендуются только для хранения и взаимодействия с небольшими суммами.
Холодные кошельки НЕ подключены к интернету. Это означает, что к вашим средствам сложнее получить доступ. Холодные кошельки не так удобны для пользователей, но злоумышленникам гораздо сложнее их взломать. Холодные кошельки следует рассматривать как единственный вариант для длительного хранения.
**Резервные сид-фразы биткоин-кошельков**
Большинство кошельков требуют записи “резервной сид-фразы”. Эта мера предосторожности предусмотрена на случай, если вы потеряете доступ к своим приватным ключам и/или кошельку. Это также означает, что пользователи должны проявлять особую осторожность со своими резервными копиями, поскольку они содержат всю необходимую информацию для доступа к их средствам. Относитесь к резервным копиям так же, как относились бы к сокровищу.
**Биткоин-кошельки, не использующие сид-фразу**
Одним из способов хранения биткоинов являются кошельки, не использующие сид-фразу. Они предназначены для учетных записей с несколькими подписями (мультисиг), в которых пользователи не создают резервные копии, а полагаются на службу резервного копирования. Сервис *Casa* является лидером в данном сегменте благодаря своему мультисиг продукту *Keymaster*.
**Мультисиг-кошельки: как это работает**
Для перемещения ваших средств мультисиг-кошельки требуют нескольких подписей, а не единственную подпись с приватным ключом. Существует много способов создания мультисиг-кошелька, но в качестве примера предлагаем использовать схему “2-из-3”.
Для пользователя это означает, что 3 приватных ключа относятся к одному биткоин-кошельку. Чтобы перевести средства, для подписания транзакции вам нужно, как минимум, 2 приватных ключа из этих трех. Большинство пользователей физически/географически разделяют местоположение каждого ключа с целью дальнейшей минимизации рисков. Важно не оказаться “слишком изобретательным”, иначе можно обдурить самого себя и потерять собственные средства (это случалось не раз).
Как упоминалось выше, вот несколько примеров мультисиг-кошельков:
* Green Wallet by Blocksteam (2-из-2)
* Keymaster by Casa (2-из-3 и 3-из-5)
* Unchained Capital (2-из-3)
* Electrum
**Преимущества схемы мультисиг**
Мультисиг допускает место для ошибки. Если у вас только один приватный ключ и вы его потеряете, получить доступ к средствам будет невозможно. Однако, если вы используете настройку 2-из-3, то в случае потери одного из приватных ключей вы при этом не лишаетесь доступа к своим средствам.
Мультисиг также снижает уровень опасности физических атак. Допустим, вам угрожают физически и заставляют отказаться от ваших биткоинов. Если бы у вас был обыкновенный кошелек (не мультисиг), то вам бы, скорее всего, пришлось передать доступ к вашим сбережениям атакующему. Однако, если вы настроили схему мультисиг, один из ваших ключей находится у вас, а другие — в отдаленной локации (например, в офисе и в сейфе). Подобное географическое разделение ключей значительно снижает стимул для злоумышленника преследовать вас и ваши сбережения.
Наша рекомендация: выбирайте биткоин-кошелек в зависимости от процентной доли хранящихся чистых активов
Самый простой способ определиться со способом хранения биткоинов — сосредоточиться на том, “сколько денег поставлено на карту”. Другими словами, какой процент вашего собственного капитала хранится тем или иным способом? Это — наш взгляд на ситуацию, но, конечно, каждый должен принимать собственное решение. Используйте эту статью скорее как ориентир, чем как универсальное решение:
\*\*
Небольшие суммы (~ 0,1% собственного капитала) — мобильный биткоин-кошелек
* *Blockstream Green* — обладает встроенной функцией мультисиг 2-из-2. Это, пожалуй, лучший биткоин-кошелек для iPhone.
* *Casa Keymaster (режим с одним приватным ключом)* — резервное копирование без использования сид-фразы.
Средние суммы (~ 1% собственного капитала) — аппаратный биткоин-кошелек
* *Ledger*
* *Trezor*
* *Coldcard*
Большие суммы (более 10% собственного капитала) - мультисиг биткоин-кошелек
* *Casa Keymaster Multisig* — простой в использовании интерфейс, можно выбрать схему 2-из-3 или 3-из-5. Casa предлагает инструмент самовосстановления, однако лично я его не использовал и, прежде чем рекомендовать, хотел бы провести дополнительные исследования,.
* *Unchained Capital Multisig* — простой в использовании интерфейс, настройка 2-из-3, возможность получить доступ к финансовым услугам на основе вашего биткоин-депозита.
* *Самостоятельно настроенная схема мультисиг* — пользователи могут самостоятельно создавать и настраивать схему мультисиг. Это требует определенных технических знаний по сравнению с использованием сервисов, но плюсом данного решения выступает повышенный уровень конфиденциальности.
*Профессиональный совет:* диверсифицируйте ваши настройки долгосрочного хранения. Если значительная часть вашего капитала хранится в Биткоине, в ваших интересах диверсифицировать свои активы. Это сглаживает возможные риски потери всех средств. Например, храните треть своих биткоинов с помощью Casa, треть с Unchained Capital, а оставшуюся треть на бумажном кошельке.
Подведем итоги
--------------
Это вкратце — наш взгляд на самостоятельное хранение биткоинов. Если вы все еще не уверены в собственных силах, не переживайте. Мы рекомендуем вам взять свои биткоин-ключи под контроль только тогда, когда вы освоитесь со всеми сопутствующими особенностями. Но мы призываем вас продолжить погружаться в подробности уникальной возможности, предоставляемой Биткоином: способность полностью контролировать свои собственные сбережения.
Самостоятельное хранение упрощается с каждым днем. Оцените свою ситуацию и выберите самый оптимальный для себя способ хранения. Мы здесь, чтобы помочь, обращайтесь с любыми вопросами.
Эта статья подготовлена и переведена командами Swan Bitcoin и [Bitcoin Translated](https://t.me/bitcoin_translated). | https://habr.com/ru/post/530676/ | null | ru | null |
# Embedded Linux. Отладка ядра
Придя в embedded linux из мира микроконтроллеров, такого привычного инструмента отладки кода, как пошаговая отладка кода на целевой железке с помощью аппаратного программатора, - очень не хватало. В предыдущих статьях описано, как мы учились дебажить загрузчик u-boot: [1](https://habr.com/ru/post/578830/), [2](https://habr.com/ru/post/585432/). С ядром все оказалось сложнее. Например, выяснилось, что ядро Linux в принципе невозможно скомпилировать с отключенной оптимизацией (-O0). В статье описывается как нам все таки удалось запустить ядро на микропроцессоре ARM в режиме пошаговой отладки.
Подготовка исходников
---------------------
```
$ git clone https://github.com/wireless-road/imx6ull-openwrt.git
$ cd imx6ull-openwrt
$ ./compile.sh flexcan_ethernet
```
Исходники ядра после завершения сборки можно найти тут:
```
./build_dir/target-arm_cortex-a7+neon-vfpv4_musl_eabi/linux-imx6ull_cortexa7/linux-4.14.199/
```
Сборка ядра с флагом -Og
------------------------
Первым делом мы попытались скомпилировать ядро с отключенной оптимизацией и наткнулись на неприятный сюрприз:
```
$ cd ./build_dir/target-arm_cortex-a7+neon-vfpv4_musl_eabi/linux-imx6ull_cortexa7/linux-4.14.199/
$ make menuconfig
```
Такой возможности в принципе не предусмотрено! Предлагается только два варианта оптимизации: `-O2` и `-Os`. Отладка в `GDB` в обоих случаях не даст ничего хорошего, - вместо пошагового прохождения кода `Program Counter` будет хаотично перепрыгивать целые куски кода и вызовы функций. При попытке вычитать значения переменных вы будете то и дело натыкаться на сообщение: `Optimized Out`. Если ручками залезть в `.config` и `Makefile` и попытаться собрать ядро с флагом `-O0`, то сборка упадет с большим количеством сообщений об ошибке. Как [выяснилось](https://unix.stackexchange.com/questions/153788/linux-cannot-compile-without-gcc-optimizations-implications), это в принципе невозможно, поскольку оптимизация при сборке ядра используется для совершенно других целей, для которых флаги оптимизации не должны использоваться, а именно, для отключения не использующегося кода. Грязный хак, от которого, видимо, уже не избавиться. На наше счастье, кое кто до нас все таки озадачивался проблемой отладки ядра и даже написал [патч](https://patchwork.kernel.org/project/linux-arm-kernel/patch/20181028130945.23581-5-changbin.du@gmail.com/), который позволяет собрать ядро с флагом `-Og`, но, почему-то, отклоненный сообществом. В итоге, пришлось его адаптировать вручную под наши исходники.
Суть патча заключается в том, чтобы добавить третий вариант сборки ядра, оптимизированного под отладку:
```
+ifdef CONFIG_CC_OPTIMIZE_FOR_DEBUGGING
+KBUILD_CFLAGS += -Og
+KBUILD_CFLAGS += $(call cc-disable-warning,maybe-uninitialized,)
+else
ifdef CONFIG_CC_OPTIMIZE_FOR_SIZE
KBUILD_CFLAGS += -Os $(EXTRA_OPTIMIZATION)
else
KBUILD_CFLAGS += -O2 -fno-reorder-blocks -fno-tree-ch $(EXTRA_OPTIMIZATION)
endif
+endif
```
и отключить дефайнами возникающие на этапе компиляции ошибки:
```
+#if !defined(__CHECKER__) && !defined(CONFIG_CC_OPTIMIZE_FOR_DEBUGGING)
# define __compiletime_warning(message) __attribute__((warning(message)))
# define __compiletime_error(message) __attribute__((error(message)))
#endif /* __CHECKER__ */
```
Полный код патча и связанных с ним изменений можно глянуть тут: [1](https://github.com/wireless-road/imx6ull-openwrt/commit/c87f285b2b3b1a29fb9e2356b4f0f64ca45d7091), [2](https://github.com/wireless-road/imx6ull-openwrt/commit/03c6b875d13477a86e2e89cab138f25f65930e0e).
Device Tree и JTAG
------------------
Далее нужно убедиться, что пины микропроцессора, на которые выведен JTAG интерфейс не переиспользуется для каких-либо других целей. Для этого открываем, используемый нами dts-файл и ищем упоминания jtag-пинов. Если вы находите что-либо похожее:
```
pinctrl_sai2: sai2grp {
fsl,pins = <
MX6UL_PAD_JTAG_TDI__SAI2_TX_BCLK 0x17088
MX6UL_PAD_JTAG_TDO__SAI2_TX_SYNC 0x17088
MX6UL_PAD_JTAG_TRST_B__SAI2_TX_DATA 0x11088
MX6UL_PAD_JTAG_TCK__SAI2_RX_DATA 0x11088
MX6UL_PAD_JTAG_TMS__SAI2_MCLK 0x17088
>;
};
```
то вам не повезло. Возможность отладки ядра вы сможете получить только отключив интерфейс, которые переиспользует JTAG-пины. Их придется [отключить](https://github.com/wireless-road/imx6ull-openwrt/commit/8de195a31ddebd90aa70379abbb3821be5199af9). Т.е. в худшем случае, если вам нужно отладить функционал, задействующий JTAG-пины микропроцессора, у вас не получится этого сделать. Т.е. необходимость использования JTAG-интерфейса нужно заложить еще на этапе разработки печатной платы устройства. Либо уточнить в документации на приобретаемый модуль.
Последнее, что можно сделать, создать конфигурацию [сборки](https://github.com/wireless-road/imx6ull-openwrt/commit/47621ba7384d656a48dc4eaafe81443fbed02632), в котором по умолчанию выбрана оптимизация для целей отладки:
```
CONFIG_KERNEL_CC_OPTIMIZE_FOR_DEBUGGING=y
```
После этого можно выполнить повторную сборку образа:
```
./compile.sh flexcan_ethernet
```
либо только ядра отдельно:
```
make target/linux/compile
```
Графическая IDE Eclipse
-----------------------
Ее настройки под исходники ядра практически ничем не отличается от настройки для отладки загрузчика U-boot: раздел "Установка IDE и создание проекта" предыдущей [статьи](https://habr.com/ru/post/578830/) с тем лишь отличием, что при создании проекта нужно выбрать каталог с исходниками ядра вместо исходников загрузчика.
На данный момент нам пока не удалось корректно дебажить ядро из Eclipse, а потому оно пока используется лишь для навигации по коду. В будущем, планируем прикрутить полноценную графическую отладку кода из IDE.
Отладка ядра в консольном режиме
--------------------------------
Итак, приступаем непосредственно к отладке.
Запускаем железку и прерываем загрузку ядра, чтобы остаться в консоли U-boot:
Запускаем GDB сервер:
```
$ JLinkGDBServer -device MCIMX6Y2 -if JTAG -speed 1000
```
Запускаем GDB сессию:
```
$ cd ./build_dir/target-arm_cortex-a7+neon-vfpv4_musl_eabi/linux-imx6ull_cortexa7/
$ gdb-multiarch vmlinux.debug --nx
```
в консоли gdb сесии:
```
(gdb) target remote localhost:2331
(gdb) restore flexcan_ethernet-uImage binary 0x82000000
(gdb) restore image-flexcan_ethernet.dtb binary 0x83000000
(gdb) b __hyp_stub_install
Breakpoint 1 at 0x80110b20: file arch/arm/kernel/hyp-stub.S, line 89.
(gdb) c
Continuing.
```
после этого должна ожить консоль загрузчика. Выполните в ней загрузку ядра:
```
=> bootm 82000000 - 83000000
```
После этого переключитесь обратно в консоль gdb сессии, вы должны увидеть что-то подобное:
```
Breakpoint 1, __hyp_stub_install () at arch/arm/kernel/hyp-stub.S:89
89 store_primary_cpu_mode r4, r5, r6
(gdb)
```
Вы находитесь в той точке, с которой начинается работа ядра! Попробуйте погулять по коду командами [s и n](https://www.tutorialspoint.com/gnu_debugger/gdb_commands.htm), и вывести значения переменных/регистров командой [p](https://www.tutorialspoint.com/gnu_debugger/gdb_commands.htm):
Если продолжите шагать по коду командами s и n, то можете утомиться. Чтобы быстрее попасть в интересующую вас функцию, задайте точку остановки, например, функцию `start_kernel`:
```
(gdb) b start_kernel
(gdb) c
```
попробуйте пошагать и в ней. Не должно быть никаких хаотичных перемещений по коду, т.е. если вы задаете команду n (перепрыгнуть функцию), то вы недолжны неожиданно оказаться в теле какой-либо другой функции. Значения большинства встречающихся в коде переменных должно также быть доступно для считывания без каких-либо сообщений "**optimized out**". Для сверки можете использовать Eclipse, чтобы убедиться, что все действительно идет по плану:
На этом все.
В дальнейших статьях мы:
* запустим в отладчике работу u-boot и ядра последовательно;
* разберемся, как загрузчик передает управление ядру;
* построим карту загрузки ядра по аналогии с [картой U-boot](https://habr.com/ru/post/585432/);
* упакуем инструменты разработки в docker-контейнер, что сведет к минимуму ошибки при развертывании среды разработки новыми разработчиками (в том числе новичками), включая и запуск графической IDE, и подключение к USB программатору из докер-контейнера;
* научимся дебажить модули ядра и многое другое. | https://habr.com/ru/post/592671/ | null | ru | null |
# Уязвимость в Telegram позволяет скомпрометировать секретные чаты
### Публикация к юбилею Telegram
В секретных чатах Telegram используется «сквозное шифрование», и что? End to end encryption Telegram слабо защищает переписку пользователей. Простой пример: злоумышленник достал приватный ключ.pgp Алисы, естественно, чтобы расшифровать сообщение, зашифрованное для Алисы необходим пароль от этого ключа, который невозможно сбрутить, придерживаясь современной доктрины парольной защиты. В Telegram end to end encryption на Android — это становится возможно с вероятностью 100%. Обход двухфакторной аутентификации, восстановление пин-кода и угон секретных чатов в Telegram об этой уязвимости и будет статья.
В своей работе я постараюсь описать подробный мануал по уязвимости в Telegram на Android-девайсах, приведу примеры по восстановлению local code Telegram на Android, Desktop Linux/Windows. Скомпрометирую секретный чат Telegram. В этом противостоянии с командой Дурова мне поможет моя компания: Я (Root); Android 7.0; Android 6.0 (root); Android 4.4.2 (root); ПК с OS GNU/Linux/Windows (root). На первый взгляд кажется силы не равны, посмотрим…
#### ИМХО. С чего все началось
В моем случае всю мощь PR-кампании вокруг платформы Telegram ощутил и я. На огромных колесах «Телеги» хайп катился от месяца к месяцу, не имея ни центра, ни границ. Влияние Э. Сноудена на популяризацию повсеместного пользовательского шифрования переписки. Вспомните культовый мессенджер ICQ с его приложением QIP 2005 на Desktop-е, там вся переписка хранилась на ПК в открытом доступе в файлах .txt. Telegram по поводу шифрования переписки «кто первый стал массово шифровать частную переписку» не сразу, но позже заявил, что пионер – это он. История Telegram ничем особо не выделялась: конкурс на безопасность протокола MTProto от durov; калымы для художников и художниц (рисование стикеров); API по созданию ботов/приложений; ICO TON, принесшее хозяевам Telegram немалые деньги; блокировка мессенджера в Иране, РФ и снова в Иране; а также поступлению в сеть редких онлайн-вбросов подноготной Telegram. В июле 2018г. «Телега промчалась и по мне». Когда на массовом рынке мессенджеров появился «очередной Telegram» со своим слоганом и небольшой оговоркой (это супер быстро, просто и бесплатно). «Telegram — это приложение для обмена сообщениями с акцентом на скорость и безопасность». На счет последнего в таком крутом слогане, durov и его команда (за счет Николая Дурова техническая сторона команды сильная) открыто взаимодействуют со специалистами по ИБ/багхантерами, которые находят/пытаются найти уязвимости в протоколе MTProto или баги на платформе Telegram. Специалисты присылают свой материал на почту security@telegram.org — это официальный метод такого взаимодействия «охотниками за головами» и разработчиками Telegram, так же об этом упоминается и [тут](https://hackerone.com/telegram)
> На самом деле мы приветствуем экспертов по безопасности для аудита нашей системы и будем благодарны **за любые отзывы** (security@telegram.org)
Неофициальный формат общения, когда письма игнорируются со стороны разработчиков Telegram, и тогда спецы обычно постят свои твиты в микроблоге, где некоторые из них комментирует durov.
К услугам ~~Черного принца~~ пользователя конфиденциальность на мобильной платформе Telegram представлена, как неприступная, грозная, новомодная разработка MTProto от Николая Дурова. Секретные чаты в Telegram (далее СЧ) – это чаты, которые присутствуют на мобильной платформе Telegram и защищены сквозным шифрованием, ключи хранятся только на устройствах на которых были сгенерированы, а еще это гордость Telegram-Dubai (так их назову). СЧ Telegram считаются очень защищенными чатами во всем мире, в Telegram-Dubai мире. Несколько раз durov сотрясал воздух, сравнивая свой продукт с конкурентами в публичной воинственной форме и всегда побеждал.
Обойдя end to end encryption Telegram мессенджера на Android, баг-репорт отправил письмом на вышеупомянутый e-mail. Ответа не получил, спустя несколько дней написал в техподдержку волонтерам Telegram. Волонтеры мне ответили, что донесут мою мысль до руководства Telegram, запросив с меня уточнение: откуда и когда я отправил свое письмо. Спустя две недели тишины я еще раз напомнил о своем письме волонтерам, на этот раз и добровольцы мессенджера полностью проигнорировали моё напоминание. Через неделю я снова повторил отправку письма на официальную почту Telegram — нет ответа. Что же остается, чем же заняться? докучать со своим баг-репортом по Telegram через микроблог?, осаждать неофициальные источники общения команды durov-а? Или написать и выложить статью для СМИ? Прямо какая-то кибербюрократия сформировалась в рядах Telegram. Не могу не отметить [w9w](https://habr.com/ru/users/w9w/) с habr.com, который, по моему мнению, нашел лучшую уязвимость на платформе Telegram: уязвимость в telegra.ph. Суть – «любой» юзер мог отредактировать чужую статью на telegra.ph. Со своим отчетом об уязвимости [w9w](https://habr.com/ru/users/w9w/) (он нашел их несколько) так же не смог достучаться на security@telegram.org. После прохождения бюрократического квеста, [w9w](https://habr.com/ru/users/w9w/) получил за найденные уязвимости маленькое финансовое вознаграждение. Интересно, это жадность Telegram? или какая-то другая причина? Вернемся к Telegram, немного отзывов о нем.
У многих людей есть свой семейный фотоальбом, у багхантеров — свой послужной список «найденных багов/ошибок/уязвимостей». В своем ПС, по окончанию работы над статьей, я равнодушно закрашу ячейку B30 в красный цвет, тем самым, оставив свой вопрос к команде Telegram открытым.
#### Часть 1. Восстановление local code Telegram на OS Android Linux/Windows Desktop. Основано на реальных событиях
В июле летом 2018г. на Github-е один из разработчиков ~~неформальной группировки~~ версии John The Ripper (далее JTR) выложил написанный на Python-е исходный код парсинг-модуля «telegram2john.py» (по наводке от «случайного» пользователя, который вчитался в код с [411](https://github.com/DrKLO/Telegram/blob/4ebcbf61cd1ce04685c82f93b962d1094c5ffac2/TMessagesProj/src/main/java/org/telegram/messenger/UserConfig.java) строки). Из названия программы становится ясно для чего и кому служит данный модуль. Кому не понятен смысл подобных модулей, это модули, расширяющие функционал JTR. Официальный JTR умеет потрошить 8 форматов, а JTR jumbo-1-bleeding – 263 формата (не считая + добрую сотню sha1/2/md5/$ динамических форматов), и один из таких форматов — Telegram local code. Опробовав «telegram2john.py», я обнаружил ошибку в нем: одна из трех функций парсинга local code Telegram работала некорректно, о чем я и сообщил на Github-е разработчикам JTR. [Исправление](https://github.com/magnumripper/JohnTheRipper/blob/bleeding-jumbo/run/telegram2john.py) для «telegram2john.py» вышло оперативно. Это не первое обращение по найденным багам к разработчикам JTR, и каждый раз быстрый ответ и не менее быстрое исправление ошибок — просто приятно, когда существует такие будничные налаженные каналы связи. Через пару дней ~~на тайном вече~~ модуль «telegram2john.py» утвердили и отправили в репозиторий JTR.
**Схема восстановления local code (Desktop-Telegram) — [многоэтапный процесс](https://github.com/magnumripper/JohnTheRipper/issues/3280):**
`Read the salt (32 bytes), encrypted data and sha1 of decrypted data from a file.
Compute a PKCS5_PBKDF2_HMAC_SHA1 on the UTF8 (passcode), using the salt, 4000 iterations, keysize of 256 bytes
Use a Telegram-specific KDF to get the AesKey and AesIV (Relatively cheap - bunch of memcpy and 4x sha1)
Perform an AES-IGE-DECRYPT on the encrypted data using the derived key and IV from step 3.
Compare sha1 of decrypted data with the sha1 read in step 1. If they match - passcode is correct.`
**userconfing.xml (Android)**
Внутренности `/data/data/org.telegram.messenger/shared_prefs/userconfing.xml`
Для пользователя JTR операция «кровотечения/Android-Telegram» упрощается до двухэтапного процесса: с помощью модуля «telegram2john.py» «вытягивание хэша» на Джоновском препроцессоре из файла userconfing.xml, принадлежащему приложению Telegram (моментальная по времени операция), и brute force этого «хэша» с помощью JTR. При такой операции вероятность восстановления local code на Android-е составляет 100% успеха, время ожидания несколько миллисекунд. Вероятность восстановления local code на Desktop-е Linux/Windows составляет X% успеха, время ожидания неопределенное. Почему? Потому что, во-первых, local code — обычный цифровой pin код на Telegram из четырех цифр (10^4 всевозможных комбинаций pin-а) ни больше ни меньше, во-вторых, алгоритм шифрования local code Telegram на Android-е **некриптостойкий [SHA256($s.$p.$s)]**, отсюда высокая скорость перебора пароля. По-другому обстоят дела с Desktop-приложениями Telegram, где нет секретных чатов: в приложении на Desktop-е, шифрование local code криптостойкое (скорость перебора на CPU хэша Desktop/Telegram в 10000 раз медленнее скорости перебора хэша Anroid/Telegram), а главное local code на Desktope/Telegram можно задавать «любой» длины и использовать любые символы.
*Криптостойкость local code Desktop Telegram высокая, скорость brute force в 10k раз медленнее brute force local code Android Telegram.*
Лично у меня складывается впечатление, что разработчики Telegram трудились над созданием уникального и защищенного своего протокола MTProto, а не над всесторонней конфиденциальностью пользователя, например, открытый кэш приложения, хранящийся в не под корневом каталоге Android, или некриптостойкий local code, который, как оказывается, восстанавливается со 100% вероятностью.
На момент написания статьи, JTR-ы из коробки в свежих ОС Kali Linux и Parrot Security не обновлялись с 2015г., имеют баги, не позволяющие парсить local code Telegram (JTR jumbo-1-bleeding всегда имеет какие-то баги, но его функционал развивается круче чем вы думаете, если вы думаете о ПО Hashcat). Итак, искушенный пользователь Kali/Parrot взломать восстановить Local code Telegram не сможет, в Windows/Android JTR-ы усеченные по функционалу — тоже не годится. Поэтому необходимо устанавливать на свою OS JTR c Github (для Linux-систем). Чтобы компиляция ПО JTR прошла успешно, до компиляции программы доставляете пакет в вашу OS «libssl-dev», далее
```
git clone git://github.com/magnumripper/JohnTheRipper -b bleeding-jumbo john && sudo apt-get install libssl-dev && chmod +x -R john/ && cd john/src && ./configure && make -s clean && make -sj4
john/run/telegram2john.py userconfing.xml > хэш
#если модуль "telegram2john.py" доставили в GNU/Linux отдельно, тогда запускаете так:
python telegram2john.py userconfing.xml > хэш
JohnTheRipper/run/john хэш --mask=?d?d?d?d
#Результат последних двух команд – получение local code Android Telegram за две мс.
```
*Восстановлен local code Android Telegram. Pin 5369.*
Аналогично и с брутом local code Telegram приложений Desktop Linux/Windows, вместо файла «userconfing.xml» указывается путь к каталогу Telegram:
(Linux): ~/telegram2john.py ~/.local/share/TelegramDesktop;
(Windows): ~/telegram2john.py «C:/Users/Name/AppData/Roaming/Telegram Desktop» (для устаревшего приложения Telegram на Windows);
(Windows): ~/telegram2john.py ”Telegram Desktop" (для обновленного приложения Telegram на Windows).
Обратите внимание, если вы повторно захотите распарсить local code Telegram, JTR выдаст «No password». Причина — пароль уже был найден ранее. Джонни, никогда не восстанавливает пароль по второму и последующему разу, вместо этого, используйте опцию « --show хэш», но иногда могут случаться баги, и опция "--show" не отработает как надо (с другими хэшированиями такие баги встречал, но все уже поправили разработчики JTR). В таком случае загляните в файл ~/john/run/john.pot, все найденные пароли хранятся в нем, если его очистить, то можно повторно брутить хэши с найденными паролями.
*John The Ripper не собирается повторно «пачкать руки ~~в крови~~» о local code Android Telegram*
**файл userconfing.xml**, который является мишенью для JTR, расположен в под корневом каталоге Android:
```
/data/data/org.telegram.messenger/shared_prefs/userconfing.xml
```
А значит добраться до файла можно, имея root права, или через TWRP или с помощью digital forensics.
Подробный видео-мануал по восстановлению local code Telegram на Android/Linux/Windows ссылка в конце статьи.
#### Часть 2. Белые начинают и проигрывают. Угон секретных чатов в Telegram. Основано также на реальных событиях
**Как базируется защита в Telegram:**
1. Ввод номер телефона;
2. Получение смс, либо кода в приложении на другом устройстве – по желанию, ввод смс-кода или кода полученного в приложении на другом устройстве.
3. Временная блокировка аккаунта при частом (в том числе успешном) залогинировании пользователя.
При перехвате такой смс можно ворваться в учетку пользователя, но доступ к секретным чатам ~~террориста~~ не получить, так как они существуют и живут только на устройствах ~~приспешника ИГИЛ~~, где были сгенерированы, а значит особо не разгуляться тем, кто держит в узде мобильных операторов связи.
**Опциональная, базовая + усиленная защита Telegram:**
1. Ввод номер телефона;
2. Получение смс, либо кода в приложении на другом устройстве – по желанию, ввод смс-кода или кода с приложения;
3. Ввод cloud code Telegram (хранится на сервере Telegram и у вас в уме, сбрасывается/привязывается через e-mail);
4. Установка local code (на Android-е, настройки — конфиденциальность и безопасность – код пароль);
5. Проверка текущей/последних сессий входа в мессенджер;
6. Выход из всех сессий кроме текущей;
7. Очистка содержимого СЧ по таймеру;
8. Запрет на скрин/запись экрана СЧ;
9. Временная блокировка аккаунта при частом (в том числе успешном) залогиннировании пользователя;
10. Как выяснилось при угоне СЧ (вход в чужую учетку с другого ip) временный бан реального/скомпрометированного аккаунта ~ через 5 минут и отмена СЧ в Telegram. В одной же сети реальной/скомпрометированной учетки, Telegram забывает банить за угон аккаунта.
**Ниже я покажу, что СЧ уязвимы, один из таких СЧ я угоню (свой тестовый аккаунт в Telegram) и буду выдавать себя за пользователя «Хозяин»**
После успешного восстановления local code Telegram я решил пощупать файлы рядом с файлом userconfing.xml на Android-е. Создал секретный чат, посмотрел какие файлы и в каких подкаталогах обновляются по времени. Попробовал скопировать эти файлы с OS Android 4.4.2 на другой гаджет с OS Android 6.0 (перенос файлов между гаджетами осуществлял через архивы rar; zip). Установил с GP последнюю версию Telegram на Android 6.0. Перенес c Android 4.4.2 > Android 6.0 обновленные файлы в аналогичные каталоги
```
/data/data/org.telegram.messenger/shared_prefs
/data/data/org.telegram.messenger/files
/data/data/org.telegram.messenger/no_backup
```
Согласно ~~ворованной~~ своей тестовой учетки Telegram восстановил права (какие были на 4.4.2) для каждого файла и папки персонально, операция небыстрая (у разных файлов самые разнообразные права), назначил UID GID «Telegram».
Запустил приложение. Тут же все ворованные файлы обновились по времени, а меня приветствовал экран «нового пользователя». Telegram вел себя так, как будто я новый юзер и предлагал зарегаться или войти через телефон (стандартная процедура при первоначальной установке Telegram на Android). То есть я не смог ворваться в чужую учетку. Подкрался еще и еще несколько раз с разных сторон, но в конечном итоге – **фэйл**.
**Попробовал другой способ – бэкап тестовой учетки Telegram через Titanium backup.**
Сделал бэкап приложения на Android 4.4.2, развернул бэкап 4.4.2. на Android 6.0.
Права на «ворованное» приложение, смена UID/GID не требуется – все сделает Titanium Baсkup. Запускаю Telegram скомпрометированной учетки на Android 6.0 и магия! Получаю запрос на ввод local code пользователя «Хозяин». Такой миттельшпиль с бэкапом предоставил обход двухфакторной аутентификации без жертв и выкрутасов. Telegram со своей стороны запросил лишь local code от угнанной учётки. Отправляю украденный файл
```
/data/data/org.telegram.messenger/shared_prefs/userconfing.xml
```
на VDS с установленной ОС Kali Linux, где JohnTheRipper больше не спал в запущенных процессах, пришло его время действовать. В следующее мгновение на local code обрушился ад! Хэш не выдержал ни секунды, дал трещину.
Красным выделил (сверху вниз) полученные:
* Хэш для JTR с помощью модуля telegram2john.py;
* Восстановленный local code Android Telegram;
* Джонни full time job (неприлично-высокая скорость brute force пароля, опцию — - -mask=?d?d?d?d, сообщающая Джонни чтобы он подбирал 4х значный цифровой код не включил, чтобы JTR разогнался и показал свою ~~ярость~~ скорость);
* Запрос к JTR восстановленного local code.
Крутой Джонни! неправда ли?
~~Надругавшись над «частью» собственности компании Telegram,~~ Восстановив с помощью JTR Android local code Telegram, вошел c другого ip в ~~чужой~~ свой тестовый аккаунт, который изначально располагался на Android 4.4.2., а теперь скомпонованный на Android 6.0. При этом вижу все секретные чаты жертвы и всю переписку в них. Попробовал написать, в созданном ранее СЧ, пользователю Android 7.0 и сообщение успешно отправилось. Юзер Android 7.0 отправил ответ, ответное сообщение было не просто получено, а получено на двух гаджетах: на Android 6.0 и на Android 4.4.2. Проверил последние сессии входа: у реального пользователя отображался его ip и его гаджет Teclast Android 4.4.2 (настройки- конфиденциальность и безопасность-активные сеансы); у злоумышленника Android 6.0 в «активных сеансах» отображался девайс Teclast Android 4.4.2, ip Вирджиния. То есть реальный пользователь не получает информацию через «Активные сеансы», что его учетка была скомпрометирована, а получает «ложную» информацию, что он находится в сети с одного своего устройства и с одного своего ip.
Реальный пользователь через активные сессии не видит, что он скомпрометирован. В истории последних сеансов не фиксируются точки входа злоумышленника. Более того, в реальном аккаунте «Хозяина» я щелкнул «выйти из всех сеансов кроме текущего». Злоумышленника при этом не выкинуло из сеанса, независимо от онлайн/офлайн статуса атакующего.
Попробовал ту же операцию относительно скомпрометированной учетки – результат аналогичен: «Хозяина» не выкинуло из Telegram, сессионные ключи прежние. Неимоверно, да?
Может графические ключи СЧ индикатор безопасности? Ключи секретных чатов не индикатор безопасности, в данном эксперименте они все три бьются между собой.
*Все ключи одинаковые в том числе и у скомпрометированной учетки.*
Telegram заявляет, если ключи бьются на 2х устройствах, вы в безопасности — это не так. *(Отступление. Сверять ключи все же нужно, после установки Telegram на Android и при создании самого первого СЧ, у пользователей СЧ отсутствовали слепки ключей, а графические изображения ключей отличались на устройствах. СЧ работал как обычно, что произошло я так и не разобрался, и это был единичный случай, когда ключи не бились между собой).*
**Вернулся к первому методу «copy-paste», который у меня изначально не получился.**
Повторил все свои предыдущие шаги, добавив промежуточное 3-е действие.
1) Установил с GP последнюю версию Telegram.
2) Перенес каталоги с OS 4.4.2 на другой гаджет с OS 6.0 (перенёс только чувствительные данные. Приложение Telegram и другие его каталоги не копировал)
```
/data/data/org.telegram.messenger/shared_prefs
/data/data/org.telegram.messenger/files
/data/data/org.telegram.messenger/no_backup
```
3) **Удалил папку на Android 6.0**, шах
```
/data/data/org.telegram.messenger/code_cache
```
4) Права не восстанавливал персонально, вместо этого, раздал всем вышеописанным каталогам «рекурсивно» права 777 (полный доступ). Назначил тем же каталогам владельца и владельца группы (UID/GID) «Telegram» (на самом деле «рекурсивно» в root каталоге плохо работает в TC, поэтому пришлось перепроверять назначение прав).
5) Вперёд! Запускаю Telegram в другой сети с другим ip – неудача, снова это приветствие нового пользователя на английском языке.
6) Вперёд! Перезапускаю Telegram, шах и мат! Telegram выдал предупреждение на ввод local code пользователя, который был на Android-e 4.4.2 (и который восстанавливается с вероятностью 100%), при этом запросы со стороны Telegram на cloud code или смс отсутствовали и до сих пор отсутствует напрочь. Обход двухфакторной аутентификации, нет! обход End to end encryption Telegram выполнен успешно.
Результат: сообщения злоумышленника в СЧ так же успешно отправлялись от имени реального пользователя, и также была доступна вся переписка СЧ. Спустя ~400 ударов моего тревожного сердца, опасения подтвердились: угнанная учетка была заблокирована Telegram-ом у злоумышленника и у реального пользователя; СЧ – отменен.
*Временная блокировка учетки Telegram.*
Авторизовавшись повторно в Telegram (иногда бан бывает на сутки, но мне повезло, почему-то в этот день все баны раздавались на секунды), у реального пользователя было все как обычно, а злоумышленник уже не мог снифить скомпрометированную учетку (сессионные ключи обновились).
#### Несколько официальных утверждений Telegram мне удалось опровергнуть
> telegram.org/faq – «СЧ могут быть только на устройствах происхождения СЧ».
Я – «Как видите СЧ могут быть не только на устройствах происхождения СЧ, но и на устройствах, где имеется Root и ключ СЧ, независимо от версии OS Android».
> telegram.org/faq – «Вы можете сравнить это изображение (примечание: изображение ключа СЧ) с тем, которое имеет ваш друг — если оба изображения одинаковы, вы можете быть уверены, что секретный чат безопасен»
Я – «Да, безопасен, но только в Telegram-Dubai мире»; «нельзя быть уверенным, что чат безопасен».
> telegram.org/faq – «Мы также рекомендуем включить двухэтапную аутентификацию и установить сильный код доступа для блокировки вашего приложения, вы найдете обе опции в настройках — Конфиденциальность и безопасность».
Я – «Сильный код доступа установить можно только в приложениях Telegram Desktop Linux/Windows, но не pin/«password» в приложении на Android»
> telegram.org/faq – «Пользователь с корневым доступом может легко обойти функции безопасности, встроенные в операционную систему, прочитать память процесса или получить доступ к ограниченным областям, таким как внутреннее хранилище. Как только у злоумышленника есть доступ к корню, любые усилия по смягчению угроз становятся бесполезными. Никакое приложение не может быть названо безопасным в этих обстоятельствах, независимо от того, насколько сильно шифруется».
Я – «Понаписали [FUD](https://ru.wikipedia.org/wiki/FUD) знает чего в попытке и на кибербудущее при любом раскладе отплыть белым лебедем, т.е. маркетинговая чушь, обусловленная нехваткой квалифицированных технических кадров в далёком 2013г.» Восстановить local code Android и получить/клонировать учетку. С каждой новой неверной попыткой ввода pin, Telegram увеличивает время ожидания между попытками ввода pin-а. Видимо, таким алгоритмом Telegram удовлетворен в защите пользователя от ручного brute force 10^4 всевозможных комбинаций pin-ов, но удовлетворен ли пользователь, когда его легко так скомпрометировать? Если разработчики Telegram хотели бы смягчить угрозы в этих обстоятельствах, они могли бы это реализовать ни как временную блокировку на несколько секунд на неверный ввод local code, а заменить на Telegram Android-е функцию «пустышки» pin на password, с шифрованием PBKDF2 — это сильно замедлит атаку brute force. Как пример хорошей защиты – password на вход в зашифрованную БД паролей Keepass2Android.
> telegram.org/faq «Вы можете получать доступ к сообщениям в секретном чате из своего устройства происхождения. Они безопасны до тех пор, пока ваше устройство безопасно в вашем кармане».
Я – «Вот где, оказывается правда!»
#### Выводы
* Local code Telegram (pin) на Android-е взламывается в JTR мгновенно и c вероятностью 100%, это ведет к последствиям: угон секретных чатов, вскрытию переписки СЧ, выдавание злоумышленника за реального пользователя. Защита от этого «трюка» — временный бан от Telegram и новые сессионные ключи для реального пользователя.
* Операция по угону СЧ схожа с воровством cookie + взлом pin + «заморочка с правами» если использовать метод «copy-paste».
* Для восстановления pin-а/password-a Telegram на Android-е, необходимо работать с файлом приложения мессенджера расположенным в
```
/data/data/org.telegram.messenger/shared_prefs/userconfing.xml
```
Добраться до «чувствительных файлов» можно, имея root права, или через TWRP или с помощью digital forensics.
* Для злоумышленника угон учетки — это возможность не только сдампить переписку, но и возможность причинить урон настоящему хозяину аккаунта: например, очистить «свое» облако. В таком случае реальный пользователь потеряет безвозвратно свои данные в «избранном». Официально удалить учетку Telegram, и если, например, Вы были админом какого-нибудь сообщества, то лишитесь админских привилегий.
* Часто пользователи устанавливают local code на Telegram Desktop-e такой же, как pin на Android-e — это ловушка, 4х значный local code Telegram на Windows/Linux перебирается <1 минуты, а доступ к ПК получить зачастую проще, чем доступ к гаджету.
* UPD. Разработчики Telegram должны заменить «pin» на Android-е на «password», с криптостойким шифрованием (как реализовано на Telegram Desktop-e или в других мобильных приложениях, например Keepass...) используя, к примеру PBKDF2 и пд…
А так же отвязать функцию разблокировки отпечатком пальца (на гаджете, где отсутствует устройство отпечаток пальца) при открытии новой БД (это **третья [уязвимость в Telegram](https://habr.com/ru/post/442586/)/Android**, которую я изначально проглядел в своих экспериментах). Неважно какой pin/pass local code установлен был на угнанной учётке (его можно даже не взламывать), вход в аккаунт жертвы доступен по отпечатку (отпечаток любой, который установлен на гаджете атакующего, это работает против Telegram, но не работает атака «отпечатком» против Яндекс деньги, Keepass2android offline, Сбербанк онлайн).
* security@telegram.org, да и в целом техподдержка в Telegram, как сервис реагирования и взаимодействия пользователь-разработчик не на высоте.
* За период «молчания» Telegram выпустил обновление в GP, но обновление плановое и было связано с Passport telegram, также выходило еще обновление, но уязвимость, которую я продемонстрировал в данной статье все еще действует, и любой желающий может воспользоваться ей.
* На баг-репорт (обнаруженную уязвимость) Telegram никак не отреагировал. Ответа скорее всего и не последует.
**спойлер**
**Демонстрация восстановления local code Telegram на Android/Linux/Windows.**
**Демонстрация уязвимости секретных чатов Telegram.**
*P.S.: дата/время на отдельных скринах или скрин-видео может не совпадать, так как эксперименты в Telegram и скрины делал по ходу написания статьи, а из-за раздачи банов Telegram-ом статья писалась несколько дней.*
*P.P.S.: в комментариях некоторых пользователей интересует свойства root-прав. На многих гаджетах у пользователей есть root (см спойлер), а более технически-подкованные пользователи стремятся получить полный root над своим устройством. Те же, кто никогда в GNU/Linux не работал не поймет «что к чему» (Android — это Linux без GNU лишь по дефолту). Ради безопасности преподы делают на Windows учетки «гость» своим студентам и многих очников это устраивает? Любой Android-смартфон без корневого доступа принадлежит производителю, а не пользователю.
Имея зашифрованные: переписку писем почтового приложения своим gpg/pgp ключом, или БД паролей keepass2android offline, или обычный текст в запароленном архиве rar. Это «невозможно» вскрыть злоумышленнику/правоохранителю даже если у него полный root и ваш разлоченный гаджет или полный его бэкап. В Telegram Android по умолчанию с pin, можно сдампить всю переписку и все СЧ с вероятностью 100% успеха.*
**...**
*Так же в комментариях был совет использовать local code на Android-e «password» вместо «pin». Будьте осторожны с такими советами: [Продолжение уязвимости...](https://habr.com/ru/post/442586)* | https://habr.com/ru/post/419551/ | null | ru | null |
# Взлом игрового архива трэш-клона GTA 3 и использование Kaitai для упрощения распаковки
Эта статья продолжает идею предыдущей ["Как у меня получилось взломать и распаковать ресурсы старой игры для PSX"](https://habr.com/ru/post/347382/) здесь я также попытаюсь с точки зрения "новичка в реверс-инжиниринге" описать ход мыслей и действий с помощью которых мне удалось "с нуля" разобраться в устройстве игрового архива.
Я рассчитываю, что она может быть полезна тем, кто боится открывать hex-редактор, думая, что это какая-то хакерская программа, надеюсь мне удастся показать, что даже уровня "продвинутого пользователя" и начальных навыков программирования может хватить для таких вот "вещей".
Часть Первая - Изучаем игру
---------------------------
Итак, перво-наперво нужно собрать информацию по игре, файлы которой мы решили “взломать”.
шикарное меню игры
Представляю вашему вниманию **Car Jacker,** он же **Crazy Drive Away,** он же **Car Boosting**, и местами даже **Car Jacker 2**.
Игры были сделаны в 2004-2005 годах некой конторой **Kozmogames Inc.** на движке с пафосным названием **e^N-gine.**
Такое обилие личин объясняется, скорее всего тем, что в разных странах и у разных издателей игра выходила под разными названиями, видимо для того, чтобы геймеры не могли ничего про нее прочитать до момента покупки, и тем самым не передумали ее покупать.
Сами игры представляют из себя песочницы в стиле GTA с десятком миссий.
изучаем "свойства" экзешникаСкачать их всех можно по [ссылке в интернет-архиве](https://archive.org/details/kozmogames-ilya-stepanov).(если вдруг кто-то захочет сам пользуясь моим руководством повторить взлом)
Приступаем к изучению самой игры, для этого открываем папку в которую она установилась. И вот что предстает нашему взору:
содержимое каталога с игройСама игра весит менее 100мб из которых 90мб занимает файл data.pak, который и представляет собой главный и единственный игровой архив.
В файле config.ini глаза бросается вот такая строчка:
**FontFile=textures\GUI\AGLettericaCondensedLight.dds**
содержимое config.ini
Тут мы видим относительный путь к файлу со шрифтами, но самого файла в папке с игрой нет, поэтому можно предположить что он хранится где-то внутри data.pak.
Попутно загуглим, что такое dds, оказывается это формат хранения текстур DirectX.
Отложим это пока в голове и откроем data.pak hex-редактором.
В самом начале файла нам предстаёт вот такая картина:
начало файла data.pakПервые несколько байт с какими-то данными, потом группа нулей, потом опять данные.
С одной стороны выглядит как типичный заголовок, где обычно сначала сигнатура или какое-то смещение, потом нули.
Но вот в чем проблема, первые байты это явно не сигнатура и не смещение, а скорее какая-то абракадабра.
Но отметим для себя, что наличие одинаковых байт “00”, идущих друг за другом говорит нам о том, что весь файл или хотя бы его часть - не сжаты.
На всякий случай, я пропустил архив через "Dragon UnPACKer" и парочку других перспективных универсальных игровых сканеров, на предмет открытых ресурсов, но ожидаемо - безуспешно.
Продолжаем листать data.pak в hex-редакторе дальше, а именно “перематываем” примерно на середину.
пример того как выглядит файл data.pal ближе к серединеОпять огромное количество повторяющихся байтов FF. Если бы архив был сжат, такие сегменты в первую очередь пошли бы под нож, значит опять отмечаем у себя, что сжатия тут нет.
Но тогда почему универсальные игровые распаковщики не обнаружили те же файлы формата .dds, которые упоминались в конфиге?
Листаем дальше, в самый конец файла:
самый конец файла data.pakА вот это уже интересно! Последние 160кб файла занимает вот такая структура как на скриншоте.
Блоки равного размера содержащие что-то ОООЧЕНЬ похожее на текст , а остальная часть забита нулями.
Ощущение, что это текст, еще усиливает и то, что если присмотреться, то последовательность у “текста” на скриншоте отличается только четвертым символом с конца. Уж не пути ли это к файлам, с одинаковыми именами и расширениями, отличающимися лишь цифрой в конце?
занятное повторение в последовательностяхТогда получается что **\ИИж** - это расширение. А помните у нас в файле config.ini был путь к какому-то файлу формата .dds?
Это не может быть совпадением, можно открыть таблицу ANSI(а точнее win-1251) и посмотреть, что нужно сделать с **.dds** чтобы оно превратилось в **\ИИж**, но я поступил несколько иначе, создал текстовый файл и открыл его в том же hex-редакторе.
смотрим десятичные значения байтов с символамиРедактор HxD в одном из окон показывает выделенные байты в разных системах счисления.
И вот что получилось в виде текста и в десятичной системе счисления.
**.dds**
2E 64 64 73
46 100 100 115
**\ИИж**
5C C8 C8 E6
92 200 200 230
Я думаю вы уже догадались что произошло. Числовое значение каждого байта было умножено на 2.
`Небольшой дисклеймер для “настоящих” программистов - не надо кричать сейчас в монитор, АЛЛО ЭТО БИТОВЫЙ СДВИГ и делать “рукалицо”. Мы же тут собрались ради тех, кто в программирование и реверс-инжиниринг пытается зайти с черного входа, так что про битовый сдвиг будет, но чуть позже.`
Но есть небольшой нюанс.
Во-первых, умножение на 2 должно приводить к тому, что результат должен делиться на 2, а некоторый байты в файле на 2 не делятся.
Во-вторых, умножение на два чисел начиная со 128 даст результат больше 255, что в свою очередь переполнил максимальное для одного байта значение 255, а у нас тут очевидно каждый байт должен остаться байтом.
Я эту проблему решил на интуитивном уровне, мне было очевидно что единственный способ “утрясти” проблему, сделать следующее: если результат умножения на два больше 255 - отнять от результата 255.
Это во-первых превратит четное после умножения число в нечетное, что не даст ему перекрыть ни одно из чисел до 128 умноженных на два, которые дали четный результат, а во-вторых при обратном декодировании, если вы встретили нечетное число, вы сразу поймете что это результат умножения на два, который превысил 255 и поймете что с ним сделать(добавить 255, а потом разделить на два).
`Многие наверное скажут, блин чувак, ну ты офигел, как до такого можно дойти самому, это же какая-то "высшая математика".
Я могу частично с этим согласиться, и поэтому чуть ниже расскажу как можно было дойти до такого же решения без таких вот озарений.`
Часть вторая - Пишем расшифровщик
---------------------------------
Пришло время создать Proof-of-Concept расшифровщика.
Я свой писал на java. но тут чтобы легче читалось напишу на java-подобном псевдокоде.
```
File fileI = new File("data.pak");
byte [] fileBytes = Files.readAllBytes(fileI);
for (int i=0;i
```
"Код" выше делает следующее: читает файл в массив байтов, потом проходит по этому массиву циклом и если байт не делится на 2, то прибавляет к нему 255 и делит на два, а если делится, то просто делит на два, а результат всего этого записывается в новый файл.
Теперь откроем в редакторе расшифрованный файл data\_dec.pak и изучим его структуру.
самое начала расшифрованного архиваМожно заметить что первые несколько байт архива, которые до этого были абракадаброй превратились в слово attack, но нас интересует конец файла, где, судя по всему, описана его структура.
конец архива после расшифровкиСравнив несколько блоков подряд, можно легко определить их структуру.
Первые 128 байтов из 140 - это текст, который содержит имя файла и виртуальный путь к нему.
Потом идет 4 блока по 4 байта, каждое из которых - число Int.
Первое число(выделено зеленым) - смещение относительно начала архива.
Второе число(выделено синим) - размер файла.
Третье число - всегда нули.
Четвертое число - тоже размер файла, оно всегда равно второму, по крайней мере для этого архива.
Первый файл называется
**.\Animations\blackguy\_with\_bat\attack.ALF**
Исходя из имени и пути к файлу, очевидно что это анимация атаки.
Смещение у него - 00 00 00 00 , т.е он начинается с самого начала архива, с первого байта.
Помните, когда мы открыли файл после расшифровки, в первых байтах было написано attack. Скорее всего формат этого файла с анимацией подразумевает, что в его начале хранится его имя.
Давайте перейдем по смещению 00 01 28 EC, т.е к концу первого файла архива, там мы видим слово fallback, что соответствует имени второго файла
**.\Animations\blackguy\_with\_bat\fallback.ALF**
Таким образом можно убедится, что все устроено так как мы и предположили.
`А сейчас вернемся к тому второму альтернативному способу того как можно выяснить что делать с нечетными байтами.
В оглавлении архива нечетные байты встречаются только в смещениях, так как весь английский текст находится в первой половине таблицы ansi и всегда при умножении на два окажется в пределах 255.
Допустим мы не до конца декодировали архив,(пропусти все нечетные байты)
Для первых двух файлах в оглавлении текст у нас есть полностью, а вот смещения преобразованы только частично.
Вот что у нас бы получилось:
первый блок
имя:
.\Animations\blackguy_with_bat\attack.ALF
числа
00 00 00 00
00 01 28 D9 (D9 тут не декодирован так как это нечетное число 217)
00 01 28 D9
второй блок:
.\Animations\blackguy_with_bat\fallback.ALF
числа
00 01 28 D9
00 00 3F 2C (3F тут тоже не декодирован)
00 00 3F 2C
в любом случае 00 01 28 D9 выглядит вполне как 4 байтное число, и разумно было бы сходить посмотреть что там по этому смещению.
Попав на него мы видим что оказались в паре байт от слова fallback, складываем в уме 2+2, понимаем что вместо 00 01 28 D9 мы должны были бы попасть на 00 01 28 EC.
Выходит, что EC (236) ,которое при умножении на два дает 472, должно как-то превратится в D9 (217). Ну и тут уже очевидно что разница между ними равна 255. И мы приходим к точно такому же решению, которое было описано выше. Вуаля!`**Ладно, а теперь забудьте все, что я выше писал.**
Несмотря на то, что мы смогли разобраться в том, как создатели движка\игры обфусцировали данные архива, для меня очевидно, что какой бы халтурой для сруба бабла, не была их игра, они бы никогда не стали в код движка вставлять какие-то прибавления и вычитания “255”. Во-первых это слишком ресурсоемко(слишком много дополнительных операций) во-вторых слишком криво с точки зрения программирования.
Ясно, что должен быть какой-то более низкоуровневый и простой способ проделать с байтами тоже самое, что мы тут выше делали с помощью прибавления 255 и деления на 2.
Недолгий гуглеж на тему того, какие способы делить и умножать на 2 применительно к байтам и битам существуют, выдал результат в виде [Битового Сдвига](https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B9_%D1%81%D0%B4%D0%B2%D0%B8%D0%B3).
Еще [вот тут по ссылке есть онлайн инструмент](https://onlinetoolz.net/bitshift) чтобы поиграться с битовым сдвигом для разных чисел или можно использовать даже калькулятор windows переключив его в “режим программиста”.
Если лень ходить по ссылкам, то объясню вкратце, как это работает:
Возьмем два примера которые мы разбирали выше.
**DEC 100
HEX 64
bit 01100100**
Если применить сдвиг бит влево для 01100100, то получится 11001000, что в свою очередь равно 200 и эквивалентно умножению на два.,
Если же взять число
**DEC 236
HEX EC
bit 11101100**
то при сдвиге влево мы получим 11011001 что в свою очередь равно 217(D9)
`В этом месте мне бы хотелось показать какой-то максимально красивый и короткий java-код, который бы ультимативно доказал превосходство и красоту битового сдвига над убожеством деления на 2 и прибавления 255, но java к огромному сожалению делает сдвиг совсем не так, как нам надо, она или увеличивает число до двух байт при сдвиге влево, либо если ее принудительно ограничить байтом - сжирает сдвинутые единицы заменяя их нулями. Поэтому код для реализации сдвига так, как нам надо, будет выглядеть в разы более монструозно, в виду запредельного количества костылей, чем код с делением и прибавлением 255.
Но говнокодить в java нам и не нужно, мы будем использовать kaitai(он наговнокодит все за нас).`
**Осталось разгадать последнюю загадку.**
Так как оглавление архива расположено в его конце, для того чтобы создать полноценный распаковщик, нам нужно каким-то образом программно научится понимать, либо где расположено начало этого оглавления, либо его размер.
И тут стоит обратить внимание на самый-самый конец архива.
выделен последний блок оглавленияДело в том, что последний блок оглавления заканчивается за 4 байта до конца архива.
В декодированной версии эти байты - 4F FD FF FF, в изначальной 9E FB FF FF.
Тут мне по правде говоря пришлось серьезно поломать голову. Помог встроенный в редактор "инспектор данных" и то, что я при написании распаковщика додумался вставить туда счетчик блоков в оглавлении.
В архиве было **1122** файла(блоков в оглавлении) и при выделении последних 4 байт в оригинальном data.pak, до декодирования, у меня глаз зацепился за это число.
количество файлов в архиве в виде отрицательного числаОказалось что последние 4 байта в файле не нужно подвергать декодированию, и они хранят **ОТРИЦАТЕЛЬНОЕ** значение количества блоков в оглавлении.
Таким образом вырисовывался алгоритм распаковки:
1. Прочитать последние 4 байта, получить количество(1122) файлов\блоков
2. Декодировать путем битового сдвига вправо весь остальной файл
3. Умножить число блоков на размер одного блока(1122 умножить на 144(байт в блоке)
4. Отступить от конца файла 4+(1122\*144) байт
5. 1122 раза прочитать блоки оглавления, каждый раз извлекая соответствующий файл
Часть третья - Kaitai
---------------------
Во-первых, почему и зачем. Мне в каментах к прошлой статье написали :
Ну я и решил его попробовать.**Итак что такое Kaitai и зачем он нам нужен в данном случае:**
1. [Kaitai](https://kaitai.io/) - декларативный язык описания структуры бинарных данных
2. Он позволяет в текстовом .ksy файле используя специальный синтаксис, описать структуру таких файлов, как например игровой архив описанный выше, в том числе с обфускацией и сжатием.
3. Такой .ksy файл может быть использован сам по себе, например в составе [библиотеки с описанием всевозможных форматов](https://formats.kaitai.io/) или же его можно скомпилировать в классы(исходный код) какого-нибудь языка и использовать в своем проекте для работы с этими бинарными файлами.
Давайте же посмотрим, что я с помощью Kaitai смог сделать.
Для начала вынесем обфускаций данных за скобки и опишем уже декодированный формат.
Так проще разобраться в новом для себя языке, а сходу не было понятно, можно ли в рамках Kaitai реализовать битовый сдвиг(оказалось можно и очень легко), а декодирование можно было бы потом прикрутить уже сверху средствами java.
Вот что получилось в первой итерации:
```
meta:
id: autothief_pak
file-extension: pak
application: CarJacker game
endian: le
instances:
toc_count:
pos: _io.size - 4
type: s4
toc:
pos: _io.size - 4 + toc_count * 144
type: toc_record
repeat: expr
repeat-expr: -toc_count
types:
toc_record:
seq:
- id: name
type: strz
encoding: ASCII
size: 128
- id: ofs_body
type: u4
- id: len_body
type: u4
- id: unk1
type: u4
- id: unk2
type: u4
instances:
file_content:
pos: ofs_body
size: len_body
```
Опишу по порядку:
Первый блок “**meta**” вроде понятен сам по себе - набор обязательный полей, дающий понять структура какого именно файла описана ниже.
Второй блок **instances** -это один из способов описание объектов. В данном случае я создал объект **toc\_count**(количество записей в оглавлении), который находится на позиции “размер файла минус 4 байта” и типа **s4** (Signed 4 bytes), а также объект **toc,** который находится по адресу “размер файла - 4 + кол-во записей умножить на 144”
При этом объект **toc** имеет повторяющийся тип **toc\_record**, который описан ниже, с числом повторений равным переменной **toc\_count.**
Дальше в блоке **types** идет описание единственного упомянутого мной "кастомного типа", который я упомянул - **toc\_record.**
**seq** - второй(или первый) главный в kaitai способ описания объектов. В отличие от **instances** , которые могут иметь динамическое расположение и размер, данные внутри **seq** должны идти с начала, один за одним, и иметь фиксированный размер, наш **toc\_record** как раз такой, если вы помните.
Итак, там у нас сначала **name**, строковое имя файла длиной 128 байт, z в конце **strz** в данном случае значит что 00 в конце строки можно обрезать.
Потом **ofs\_body** - "смещение" файла в виде **unsigned 4 bytes**, такой же **len\_body** - “размер файла” и два бесполезных числа.
Еще внутри каждой **toc\_record** мы создаем в каком-то смысле “виртуальный” **instance “file\_content”,** позиция и размер которого берется из значений самого **toc\_record**.
Это и будет наш извлекаемый из архива файл.
Я сказал "виртуальный", потому что сам файл в архиве хранится отдельно от оглавления, но так как **instances** в Kaitai позволяют указывать любое расположение, то мы может как бы запихнуть ссылку на файл прямо в объект из оглавления.
Вроде бы на первый взгляд все получилось красиво. На языке Kaitai удалось минималистично и относительно понятно описать структуру игрового архива, игнорируя правда применяемое в нем кодирование путем битового сдвига.
На предварительно декодированном архиве этот .ksy файл работает как надо.
Но давайте попробуем реализовать еще и битовый сдвиг непосредственно силами Kaitai, оказывается он это может.
Для этого нужно по сути добавить одну вот такую строчку.
**process: ror(1)** ( сдвиг на 1 бит вправо)
Но тут возникает проблема, куда не всунь в .ksy-файле выше этот **process: ror(1)** он работать не будет.
`Два года назад компилятор просто валился с кучей разных стэк-трейсов, в зависимости от места инжекта процессинга, я назаводил багов, сейчас проверил, стэк-трейсов нет, зато есть красивые ошибки текстом, которые говорят, что "процессинг так не может".`
Насколько я понял, проблема в том что **process** не умеет работать внутри **instances** , его смущает неопределенность размера данных которые нужно подвергнуть обработки.
Поэтому пришлось несколько “обезобразить” красивый и компактный файл, добавив в него дополнительный уровень **seq (**в самом верху), чтобы заработал процессинг.
Вот что получилось во второй итерации, теперь с битовым сдвигом и как следствие полным декодированием:
```
meta:
id: autothief_pak
file-extension: pak
application: CarJacker game
endian: le
seq:
- id: body
size: _io.size-4
process: ror(1)
type: pak_body
- id: toc_count
type: s4
types:
pak_body:
instances:
toc:
pos: _io.size + _root.toc_count * 144
type: toc_record
repeat: expr
repeat-expr: -_root.toc_count
toc_record:
seq:
- id: name
type: strz
encoding: ASCII
size: 128
- id: ofs_body
type: u4
- id: len_body
type: u4
- id: unk1
type: u4
- id: unk2
type: u4
instances:
file_content:
pos: ofs_body
size: len_body
```
Теперь структура файла такая:
В самом верху фиксированные **seq-**объекты **body** и **toc\_count.**
У объекта **body** размер “весь файл минус последние 4 байта” он имеет кастомный тип **pak\_body** и к нему применен процессинг **xor(1)**.
**toc\_count** - это знаковый int(4 байта), который идет следом.
Ну а тип **pak\_body** в свою очередь устроен точно так же как был устроен первый .ksy файл.
Получилось так что ради добавления процессинга, за который отвечает одна строка, файл пришлось усложнить и его размер вырос на 4 строки. Но хотя бы работает…
Теперь следующий этап. На основе этого .ksy файла мы с помощью компилятора kaitai сгенерируем java-классы. с помощью которых и будем работать с архивом(напишем красивый распаковщик)
Генерация происходит вот таким вот нехитрым образом из командной строки:
**.\kaitai-struct-compiler.bat -t java autothief\_pak.ksy**
В результате у нас создается файл **AutothiefPak.java** размером 6кб, который мы добавляем в наш Java проект.
Чтобы этот класс заработал как надо, ему нужна библиотека **kaitai-struct-runtime**, которую в свою очередь можно добавить через maven или вручную.
В итоге для распаковки архива достаточно вот такого компактного кода:
```
public class Unpacker {
public static void main(String[] args){
AutothiefPak pack = AutothiefPak.fromFile("data.pak"); //загружаем и сразу парсим файл в обьект AutothiefPak
for (AutothiefPak.TocRecord file : pack.body().toc()){ //для каждой записи TocRecord внутри оглавления делаем следующее
Path filePath = Paths.get(file.name()); //извлекаем путь
Files.createDirectories(filePath.getParent()); // создаем директории под этот путь
Files.write(filePath, file.fileContent()); // записываем содержимое массива байтов fileContent в файл по этому пути
}
}
}
```
И как результат работы программы, у нас на диске появляется 121 папка со 1122 файлами представляющие собой распакованные и декодированные ресурсы игры.
**Спасибо за внимание, надеюсь этот пост сподвигнет кого-нибудь к собственным успешным исследованиям.** | https://habr.com/ru/post/689354/ | null | ru | null |
# Динамическая визуализация геокодированных данных (Twitter) с помощью R
##### «Новый год шагает по стране»
Я являюсь ярым фанатом геосоциальных сервисов. Они позволяют наглядно увидеть физическую реализацию социального пространства. Это то, о чем писал [Бурдьё](http://ru.wikipedia.org/wiki/%D0%91%D1%83%D1%80%D0%B4%D1%8C%D1%91,_%D0%9F%D1%8C%D0%B5%D1%80), но что для него было доступно лишь в виде мысленного конструкта. Foursquare вообще является моей безответной любовью. Но об этом как-нибудь в следующий раз, а сегодня поговорим о Twitter.
Незадолго до конца предыдущего, 2012-го, года мне захотелось увидеть, как выглядит «волна» новогодних твитов-поздравлений. Посмотреть, как она проходит через часовые пояса. Сказано — сделано. Использованные инструменты: R, Python и ffmpeg.
#### Сбор данных
Пока супруга занялась праздничными приготовлениями и не вспомнила про меня, с помощью python и [tweetstream](http://pypi.python.org/pypi/tweetstream) делаем примитивный парсер твит-потока [statuses/filter](https://dev.twitter.com/docs/api/1.1/post/statuses/filter).
```
import tweetstream
stream = tweetstream.FilterStream('TWITTER_LOGIN', 'TWITTER_PASSWORD', track = keywords_list)
for tweet in stream:
if tweet['coordinates']:
# Декодируем время создания твита в date-time объект
# (в API Twitter встречаются два возможных варианта написания)
try:
timestamp = datetime.datetime.strptime(tweet['created_at'], '%Y-%m-%d %H:%M:%S')
except ValueError:
timestamp = datetime.datetime.strptime(tweet['created_at'][4:-10]+tweet['created_at'][-4:], '%b %d %H:%M:%S %Y')
# Прибавляем 4 часа - "переводим" время на московское
timestamp += datetime.timedelta(hours=4)
# Сохраняем время создания в виде строки
timestamp = datetime.datetime.strftime(timestamp, '%Y-%m-%d %H:%M:%S')
# Пишем все в БД
cursor.execute('INSERT INTO tweets(link, latitude, longitude, date) VALUES ("http://www.twitter.com/{0}/status/{1}", "{2}", "{3}", "{4}")'.format(
tweet['user']['screen_name'],
tweet['id'],
str(tweet['coordinates']['coordinates'][0]),
str(tweet['coordinates']['coordinates'][1]),
str(tweet['created_at'])
))
db.commit()
```
`keywords_list` — Список ключевых слов, хеш-тегов и фраз, относящихся к поздравлению с Новым годом. Не забываем, что данный вызов API не учитывает морфологию, так что в ключевые слова надо постараться внести как можно больше релевантных словоформ. Мой список:
* #сновымгодом,
* #СНовымГодом2013,
* #НГ2013,
* #СНаступающим2013,
* #НовыйГОД,
* #СНаступающимНовымГодом,
* #НОВОГОДНИЙтвит,
* с новым годом,
* с наступающим,
* с новым 2013,
* с годом змеи,
* с наступающим годом змеи,
* Нового Года,
* новом году.
Все, супруга обратила внимание на лишние рабочие руки, так что запускаем парсер и спешим на помощь. Напоследок вносим свою лепту в «увеличение энтропии»:
#### Обзор полученных данных
~~Ночь с пятницы на понедельник~~ первые дни нового года пролетели незаметно. Праздник прошел, парсер можно выключать и смотреть на «улов». Всего набралось ~10 тыс. твитов. Геометки в Twitter не пользуются популярностью. Для мобильности я скинул дамп в .csv таблицу вида «ссылка — широта — долгота — временная метка». Грузим таблицу в R:
```
twits <- read.csv2('ny_tweets.csv', header=F)
colnames(twits) <- c('Link', 'Longitude', 'Latitude', 'Timestamp')
twits$Timestamp <- strptime(twits$Timestamp, format='%Y-%m-%d %H:%M:%S')
twits$Latitude <- round(as.numeric(as.character(twits$Latitude)), digits=1)
twits$Longitude <- round(as.numeric(as.character(twits$Longitude)), digits=1)
twits$Longitude <- sapply(twits$Longitude, function(x){
if(x < (-169)){
x<-360+x
} else {x}
})
```
Переводим временные метки в соответствующий формат, округляем широты и долготы — будем смотреть твиттер-активность по сетке в одну десятую градуса. Последнее преобразование долгот необходимо для дальнейшей визуализации, чтобы не потерять сообщения с Чукотки.
Теперь подгружаем [ggplot2](http://ggplot2.org/) и смотрим распределение по времени:
```
library('ggplot2')
p <- ggplot()
p <- p + geom_histogram(aes(x=twits$Timestamp, fill = ..count..), binwidth = 3600)
p <- p + ylab('Количество') + xlab('Время (по часам)')
p <- p + theme(legend.position = 'none')
p <- p + ggtitle(expression('Распределение "новогодних" твитов'))
p
```
Выглядит все примерно так, как и ожидалось, что приятно радует. Можем продолжать.
#### Отрисовка карты
Ggplot2 предлагает богатый набор инструментов для быстрого построения информативных и симпатичных графиков. Полная документация с примерами: [ggplot docs](http://docs.ggplot2.org).
Для отрисовки карты будем использовать функцию geom\_polygon, позволяющую рисовать полигоны по заданным координатам. Контуры стран будут браться из библиотеки [maps](http://cran.r-project.org/web/packages/maps/index.html). За основу был взят вариант отрисовки, описанный в заметке [«How to draw good looking maps in R»](https://uchicagoconsulting.wordpress.com/tag/r-ggplot2-maps-visualization/). Незначительно видоизменяем описанный вариант, подгоняя его под собственные нужды и «представления о прекрасном»:
```
# Грузим все данные
# countries - вектор с названиями стран, которые надо отрисовывать
library('maps')
full_map <- map_data('world')
table(full_map$region)
need.map <- subset(full_map, region %in% countries & long>-25 & long<190 & lat>25)
# Рисуем контуры
p <- ggplot()
p <- p + geom_polygon(aes(x=need.map$long, y=need.map$lat, group = need.map$group), colour='white', fill='grey20', alpha=.5)
# Рисуем "точки" отдельных крупных городов для "оживления пейзажа"
# cities - это dataframe вида "название города - широта - долгота"
p <- p + geom_point(aes(cities$Long, cities$Lat), colour='skyblue', size=1.5)
# Убираем подписи к осям, легенду, фиксируем размер поля для вывода, добавляем заголовок
p <- p + theme(axis.line=element_blank(),axis.text.x=element_blank(),
axis.text.y=element_blank(),axis.ticks=element_blank(),
axis.title.x=element_blank(),
axis.title.y=element_blank(),
legend.position = 'none',
text=element_text(family='mono', size=20, face='bold', colour='dodgerblue3')
)
p <- p + scale_x_continuous(limits = c(-15, 190))
p <- p + scale_y_continuous(limits = c(30, 82))
p <- p + ggtitle(expression('#HappyNewYear in Russian Twitter - 2013'))
```
Картинку хочется как-то оживить и добавить информативности. Поместим в кадр часы. Вот интересный вариант с часами: [Create an animated clock in R with ggplot2 (and ffmpeg)](http://www.drewconway.com/zia/?p=2800). Но там используется полярная система координат, что нам не подходит, т.к. потребует лишних телодвижений в виде создания подграфика. Придется делать свой «велосипед». Берем функцию для расчета координат окружности по центру и диаметру (подсмотрено [здесь](http://stackoverflow.com/questions/6862742/draw-a-circle-with-ggplot2)):
```
draw.circle <- function(center,diameter=1, npoints = 100){
r = diameter / 2
tt <- seq(0,2*pi,length.out = npoints)
xx <- center[1] + r * cos(tt)
yy <- center[2] + r * sin(tt) * roundcoef
return(data.frame(x = xx, y = yy))
}
```
Теперь считаем точки для трех окружностей: белый фон-задник, серый «верхний» фон и 12 точек на окружности для часовых засечек:
```
curtime <- c(as.numeric(format(frame.time, '%H')), as.numeric(format(frame.time, '%M')))
clock.center <- c(180, 35)
circdat <- draw.circle(clock.center, diameter=20)
circdat2 <- draw.circle(clock.center, diameter=19.7)
circdat3 <- draw.circle(clock.center, diameter=18, npoints=13)
```
Считаем положение стрелок:
```
arrow.r = c(5.5,8.8) # Длина стрелок
if(curtime[1]>=12){curtime[1]=curtime[1]-12}
hourval <- pi*(.5 - (curtime[1]+(curtime[2]/60))/6)
minval <- pi*(.5 - curtime[2]/30)
hour.x <- clock.center[1] + arrow.r[1] * cos(hourval)
hour.y <- clock.center[2] + arrow.r[1] * sin(hourval)
minute.x <- clock.center[1] + arrow.r[2] * cos(minval)
minute.y <- clock.center[2] + arrow.r[2] * sin(minval)
```
Рисуем часы (функции geom\_polygon, geom\_segment, geom\_point):
```
# Три окружности: фон и часовые засечки
p <- p + geom_polygon(aes(x=circdat$x,y=circdat$y), colour='grey100', fill='grey100', alpha = .5)
p <- p + geom_polygon(aes(x=circdat2$x,y=circdat2$y), colour='grey80', fill='grey80', alpha = .5)
p <- p + geom_point(aes(circdat3$x, circdat3$y), colour='skyblue')
# Часовая стрелка, минутная, "гвоздик" оси стрелок
p <- p + geom_segment(aes(x=clock.center[1], y=clock.center[2], xend=hour.x, yend=hour.y), size=3, colour='dodgerblue3')
p <- p + geom_segment(aes(x=clock.center[1], y=clock.center[2], xend=minute.x, yend=minute.y), size=1.5, colour='dodgerblue4')
p <- p + geom_point(aes(clock.center[1], clock.center[2]), colour='blue4')
```
Вот что получилось (на карте еще и тестовые данные по «активности», но только в Москве и окрестностям):
#### Прорисовываем кадры
Исходные данные — таблица с координатами и временем публикации твита. На выходе мы хотим получить набор кадров. Сделаем так: будем в настройках задавать время 1-го кадра, время последнего кадра и временную разницу между соседними кадрами. Общее количество кадров будет рассчитываться в R. Далее — цикл от 1 до последнего кадра. В каждом кадре будет вычисляться «текущее» время. Далее — из исходной таблицы будем отбирать твиты, попадающие в требуемый временной интервал (30 минут до «текущего» времени кадра — «текущее» время кадра).
```
start.date <- '2012-12-31 00:00:00'
finish.date <- '2013-01-01 12:00:00'
seconds.in.frame <- 30
start.date <- strptime(start.date, format='%Y-%m-%d %H:%M:%S')
finish.date <- strptime(finish.date, format='%Y-%m-%d %H:%M:%S')
frames <- as.numeric(difftime(finish.date, start.date, units='secs'))/seconds.in.frame
for(i in 1:frames){
frame.time <- start.date + i*seconds.in.frame
frame.twits <- subset(twits, Timestamp <= frame.time & Timestamp > frame.time - ma.period)
...
```
Далее делаем таблицу сопряженности «широта — долгота» (напомню, что значения широты и долготы были ранее преобразованы из непрерывных в дискретные путем округления до одной десятой). И «разворачиваем» таблицу сопряженности в dataframe из 3 колонок: широта, долгота, частота (количество твитов в данной точке). Убираем строки, в которых частота равна нулю или координаты выходят за установленные границы.
```
...
frame.twits <- melt(table(frame.twits$Latitude, frame.twits$Longitude))
colnames(frame.twits) <- c('Lat', 'Long', 'Volume')
frame.twits$Lat <- as.numeric(as.character(frame.twits$Lat))
frame.twits$Long <- as.numeric(as.character(frame.twits$Long))
frame.twits <- frame.twits[frame.twits$Volume>0 &
frame.twits$Long>=-25 & frame.twits$Long<=190 &
frame.twits$Lat>=25 & frame.twits$Lat<=85,]
...
```
Преобразование широты и долготы в числовые переменные необходимо потому, что после «сворачивания-разворачивания» данных они преобразуются в категориальные (factor в терминологии R).
Осталось посчитать цвета точек. Для этого в предварительном цикле вычисляется максимальный возможный объем твитов в одной точке за весь будущий «фильм». Он берется за максимум (`max.color`), а относительно него рассчитываются цвета для всех остальных точек (логарифмирование — чтобы «выровнять» шкалу):
```
...
frame.colors <- round(1 + (8*log(frame.twits$Volume)/max.color), digits=0)
...
```
Теперь можно рисовать точки (если они есть):
```
...
if(nrow(frame.twits)>0){
p <- p + geom_point(aes(frame.twits$Long,frame.twits$Lat, size=frame.twits$Volume * 5),
colour=twits.colors[frame.colors], alpha = .75)
}
...
```
Вроде бы все, можно сохранять изображение и закрывать цикл, но для очередного «оживления картинки» я решил добавить несколько реальных сообщений в кадр. Для этого из общего массива случайно выбрал несколько десятков твитов, для них собрал тексты сообщений и создал еще один dataframe — время публикации, текст твита, «время жизни», «время появления», «время исчезновения», цвет, координаты, размер и прозрачность. Время жизни, координаты, цвет и размер генерируются при инициализации скрипта со случайными отклонениями от «оптимальных» значений:
```
twit.texts$x <- rnorm(nrow(twit.texts), mean = 100, sd = 30)
twit.texts$y <- rnorm(nrow(twit.texts), mean = 56, sd = 15)
twit.texts$size <- rnorm(nrow(twit.texts), mean = 10, sd = 2)
```
Вывод в кадр контролируется с помощью прозрачности: если «текущее» время кадра не попадает во «время жизни» твита, его «непрозрачность» (opacity) равна нулю. Если в текущем времени твит «существует» — его непрозрачность рассчитывается в зависимости от близости к центру жизненного периода. Получается, что твит «проявляется» и плавно исчезает. В коде это выглядит следующим образом:
```
...
twit.texts$opacity <- as.numeric(by(twit.texts, 1:nrow(twit.texts), function(row){
if(frame.time < row$t.start | frame.time > row$t.end){
row$opacity <- 0
} else {
row$opacity <- 0.7 *
(1 - (abs(as.numeric(difftime(row$Timestamp, frame.time, unit='sec'))) /
(row$t.delta * seconds.in.frame / 2)))
}
}))
p <- p + geom_text(aes(x=twit.texts$x, y=twit.texts$y, label=iconv(twit.texts$Text,to='UTF-8')),
colour=twit.texts$color, size=twit.texts$size, alpha = twit.texts$opacity)
...
```
Вывод текстов организован с помощью geom\_text.
Вот теперь все. Можно сохранять кадр и закрывать цикл.
```
...
f.name <- as.character(i)
repeat{
if(nchar(f.name) < nchar(as.character(frames))){
f.name <- paste('0', f.name, sep='')
} else {
break
}}
ggsave(p, file=paste('frames/img', f.name, '.png', sep=''), width=6.4, height=3.6, scale = 3, dpi=100)
}
```
Длина f.name «нулями» подгоняется таким образом, чтобы все имена «подходили» под одну маску по количеству символов.
#### Собираем видео
Для сборки итогового ролика использовался [ffmpeg](http://ffmpeg.org/):
`ffmpeg -f image2 -i img%04d.png -q:v 0 -vcodec mpeg4 -r 24 happynewyear.mp4`
Однако не все так просто. Видео целиком не собирается — у .png файлов, получаемых от ggplot2, разная глубина цвета. Возможно, эту проблему можно было решить каким-то более правильным способом, но я воспользовался [Python Imaging Library](http://www.pythonware.com/products/pil/):
```
import os
from PIL import Image
path = u'/path/to/frames/'
dirList=os.listdir(path)
for filename in dirList:
if filename[-3:] == 'png':
im = Image.open(path + filename).convert('RGB')
im.save(path + filename)
```
Теперь все кадры собираются в один ролик. Видео готово, можно грузить на YouTube. Добавляем пару YouTube-эффектов (ведь если ружье висит на стене, из него надо время от времени постреливать).
Финал:
В данном тексте я описал не все части R-скрипта, а часть цитат из кода скомпонована по принципу решаемой задачи, а не по логике работы. Поэтому в приложении выкладываю ссылку на полный код с незначительным количеством комментариев: [pastebin.com](http://pastebin.com/eWRwtE9J)
#### Возможные варианты развития
1. Добавить дату, т.к. 12-часовой циферблат не слишком информативен, когда требуется визуализировать временной интервал в несколько суток.
2. Добавить полоску с гистограммой или чем-то вроде графика плотности вероятности по общему объему данных в каждый момент времени.
#### Вопросы к сообществу
1. Существует ли для R библиотека, сопоставимая по простоте с maps, но с более актуальной информацией по современной геополитике? Без USSR, Yugoslavia и Czechoslovakia?
2. Как можно попробовать оптимизировать вычисление цветов палитры точек, чтобы не «прогонять» предварительно весь цикл «вхолостую»?
3. Можно ли «побороть» ggplot2 или ffmpeg, чтобы не требовалось дополнительной перекодировки цветности кадров (исключить PIL из процесса)?
4. И вообще — выслушаю другие указания на собственную гуманитарную криворукость и возможности оптимизации.
Спасибо!
#### Полезные ссылки
1. [How to draw good looking maps in R](https://uchicagoconsulting.wordpress.com/tag/r-ggplot2-maps-visualization/) — использование maps и ggplot2 для отрисовки карт;
2. [Create an animated clock in R with ggplot2 (and ffmpeg)](http://www.drewconway.com/zia/?p=2800) — анимированные аналоговые часы на R;
3. [Simple data mining and plotting data on a map with ggplot2](http://rpsychologist.com/parsing-data-from-a-text-file-and-plotting-where-people-live-using-ggplot2-and-openstreetmaps/) — использование OSM-карт в R. | https://habr.com/ru/post/165305/ | null | ru | null |
# Паттерны проектирования для iOS разработчиков. Observer, часть I
#### Вместо предисловия
Прошло уже 17 лет с тех пор, как вышла легендарная книга Банды Четырех, посвященная Паттернам проектирования (Design patterns). Несмотря на столь солидный срок, тяжело оспорить актуальность описанных в ней методик. Паттерны проектирования живут и развиваются. Их применяют, обсуждают, ругают и хвалят. К сожалению, для многих они до сих пор остаются излишней абстракцией.
Обсуждая разные вопросы программирования с коллегами как в жизни, так и на различных ресурсах, довольно часто приходится объяснять важность того или иного паттерна. Так и родилась идея на конкретных примерах показать, насколько их использование может облегчить жизнь программиста. Даже если речь идет о такой платформе, как iOS.
#### Паттерн Observer
##### Пример из жизни
Студент Вася очень любит ходить на вечеринки. Если быть точнее, они заняли настолько важную часть его жизни, что его выгнали из института. Занявшись поиском работы, Вася понял, что почти ничего не знает и не умеет. Хотя, подождите… У Васи есть очень много знакомых красивых девушек, которых хлебом не корми — дай проникнуть на классную тусовку без приглашения. Также Васю знают во всех соответствующих заведениях его города. Наконец, Вася понимает: чтобы вечеринка удалась (обеспеченные посетители потратили много денег), хорошо бы наполнить ее красивыми девушками (на которых эти деньги будут потрачены).
Так Вася ~~стал сутенером~~ открыл свой бизнес. Владельцы заведений обращаются к Васе (кто же не знает Васю?!) с новостями о модных закрытых мероприятиях. Вася сообщает своим знакомым девушкам о том, что он может их туда провести. Откуда же он берет девушек? Все просто: возьмем Свету. Она познакомилась с Васей в клубе на прошлой неделе. Света давно мечтала побывать на какой-нибудь элитной тусовке, поэтому попросила Васю записать ее номер телефона. Девушка она симпатичная, одета совсем недурно, так что Вася согласился. Так Света **подписалась** на Васины услуги и стала **наблюдателем**. Впрочем, Вася предупредил ее, что позвонит он сам, когда придет время.
Прошел год, Света закончила институт, нашла себе работу и, главное, вышла замуж! Ей больше не хочется ходить на вечеринки, поэтому вчера она позвонила Васе и попросила не донимать ее больше своими идиотскими сообщениями. Так она **отписалась** от (весьма подозрительного) **субъекта** Васи. Впрочем, она знает, что всегда может подписаться снова (она все еще симпатичная, молодая, хорошо одевается).
Тем временем, Вася не стоял на месте, а расширял бизнес. Недавно он познакомился с несколькими весьма обеспеченными футболистами, которые любят расслабиться на вечеринке и всегда готовы угостить симпатичных девушек безалкогольным коктейлем. Естественно, их тоже можно приглашать на разного рода мероприятия (организаторы в восторге, платят Васе больше денег). Расширение бизнеса прошло незаметно: действительно, какая разница, кому звонить? И у девушек, и у футболистов есть телефоны. Иногда, сообщая о новом мероприятии, Вася даже путает, с кем он разговаривает.
##### Пример покороче
Те, кто внимательно следил за Васиным бизнесом, мог сразу вспомнить новостные рассылки. Действительно, мы можем оставить свой адрес электронной почты на любимом ресурсе и получать ~~спам~~ важные и интересные новости без необходимости каждый день посещать соответствующую веб-страницу. Как и в случае со Светой, мы всегда (по факту, если повезет) можем от рассылки отписаться.
##### Определение
###### Банда Четырех
* Название: **Наблюдатель.**
* Классификация: Паттерн поведения.
* Назначение:
> Определяет зависимость типа *один ко многим* между объектами таким образом, что при изменении состояния одного объекта все зависящие от него оповещаются об этом и автоматически обновляются.
###### Комментарии
Итак, паттерн наблюдатель определяет зависимость один ко многим. При этом объект, который сообщает о своих изменениях, называется **субъектом**, а те объекты, которым он о них сообщает — **наблюдателями**.
Стоит отметить важную особенность паттерна наблюдатель: субъект может не знать о наблюдателях практически ничего. Так, Вася не видел никакой разницы между девушками и футболистами.
###### Структура
#### Наблюдатель для iOS разработчика
Давайте перейдем к программированию. Сначала мы разберем собственную реализацию паттерна наблюдатель на конкретном примере, а потом разберем механизм оповещений, реализованный в Cocoa.
##### Собственная реализация
Допустим, мы разрабатываем совершенно новую игру, которая непременно взорвет App Store. После прохождения очередного уровня нам нужно сделать две вещи:
1. Показать поздравительный экран.
2. Открыть доступ к новым уровням.
Стоит отметить, что первое и второе действия никак между собой не связаны. Мы можем выполнять их в произвольном порядке. Также мы подозреваем, что в скором времени понадобится расширить число таких действий (например, мы захотим посылать какие-то данные на свой сервер или проверить, не заработал ли пользователь достижение в Game Center).
Применим изученный паттерн наблюдателя. Начнем с протокола наблюдателя.
> @protocol GameStateObserver
>
>
>
> - (void)completedLevel:(Level \*)level withScore:(NSUInteger)score;
>
>
>
> @end
Здесь все довольно прозрачно: наблюдатели будут реализовывать протокол `GameStateObserver`. Разберемся с субъектом.
> @protocol GameStateSubject
>
>
>
> - (void)addObserver:(id)observer;
>
> - (void)removeObserver:(id)observer;
>
> - (void)notifyObservers;
>
>
>
> @end
Перейдем к интересующим нас классам. Пусть состояние текущей игры хранится в объекте класса `GameState`. Тогда его определение будет выглядеть примерно так:
> @interface GameState : NSObject {
>
> …
>
> NSMutableSet \*observerCollection;
>
> }
>
>
>
> @property (readonly) Level \*level;
>
> @property (readonly) NSUInteger score;
>
>
>
> …
>
> - (void)updateState;
>
>
>
> @end
При этом мы считаем, что метод `updateState` вызывается каждый раз, как в игре происходят существенные изменения. Приведем часть реализации `GameState`:
> @implementation GameState
>
>
>
> …
>
> - (void)addObserver:(id)observer {
>
> [observerCollection addObject:observer];
>
> }
>
>
>
> - (void)removeObserver:(id)observer {
>
> [observerCollection removeObject:observer];
>
> }
>
>
>
> - (void)notifyObservers {
>
> for (id observer in observerCollection) {
>
> [observer completedLevel:self.level withScore:self.score];
>
> }
>
> }
>
>
>
> - (void)updateState {
>
> …
>
> if (levelCompleted) {
>
> [self notifyObservers];
>
> }
>
> }
>
>
>
> @end
Теперь всякому объекту, которому необходимо знать об успешном проходжении уровня, достаточно реализовать протокол `GameStateObserver` и подписаться на оповещение об успешном завершении. Соотвествующий код будет выглядеть примерно так:
> GameState \*gameState = [[GameState alloc] init];
>
> [gameState addObserver:levelManager];
>
> [gameState addObserver:levelViewController];
Здесь `levelViewController` — контроллер, отвечающий за интерфейс игрового процесса, а `levelManager` — объект модели, отвечающий уровни.
##### Обсуждение
Мы рассмотрели довольно примитивный пример, который, однако, встречается повсеместно. Сразу же видно, что решение достаточно гибкое. Стоит отметить, что в оповещении мы решили передавать в качестве параметров некоторые данные. У такой реализации есть как свои плюсы, так и минусы. Может оказаться удобным использовать следующий вариант протокола `GameStateObserver`:
> @protocol GameStateObserver
>
>
>
> - (void)levelCompleted:(id)subject;
>
>
>
> @end
Соответствующий вариант `GameStateSubject` выглядел бы так:
> @protocol GameStateSubject
>
>
>
> - (void)addObserver:(id)observer;
>
> - (void)removeObserver:(id)observer;
>
> - (void)notifyObservers;
>
>
>
> @property (readonly) Level \*level;
>
> @property (readonly) NSUInteger score;
>
>
>
> @end
##### Наблюдатель в Cocoa: Notifications
Оказывается, в Cocoa есть механизм, позволяющий реализовать паттерн наблюдателя. Если быть совсем точным, таких механизмов два. В данный момент мы остановимся на механизме оповещений, а второй оставим на будущее. Далее мы не будем вдаваться во все тонкости, а лишь опишем базовую функциональность.
Неформально, механизм оповещений позволяет делать две вещи: подписываться/отписываться от оповещения и разослать оповещение всем подписчикам. Оповещение представляет из себя экземпляр класса [`NSNotification`](http://developer.apple.com/library/ios/#documentation/Cocoa/Reference/Foundation/Classes/NSNotification_Class/Reference/Reference.html#//apple_ref/occ/cl/NSNotification). Оповещения задаются своим строковым именем `name` типа `NSString`. Помимо имени, оповещение содержит также субъект `object` и дополнительные данные `userInfo` типа `NSDictionary`.
За подписки и доставку оповещений отвечает [`NSNotificationCenter`](http://developer.apple.com/library/ios/#documentation/Cocoa/Reference/Foundation/Classes/NSNotificationCenter_Class/Reference/Reference.html#//apple_ref/occ/cl/NSNotificationCenter). Чтобы получить к нему доступ, в большинстве случаев достаточно вызвать классовый метод `defaultCenter`.
Чтобы подписаться на сообщение, у центра оповещений имеется метод `addObserver:selector:name:object:`. Первым параметром выступает наблюдатель, вторым — селектор, который будет вызываться при оповещении. Он должен иметь сигнатуру `- (void)methodName:(NSNotification *)`. Третий параметр — имя оповещения, четвертый — субъект. Если в качестве субъекта передать `nil`, то оповещение будет доставляться от произвольного отправителся (при условии совпадения имени). С использованием оповещений код подписки выглядел бы так:
> GameState \*gameState = [[GameState alloc] init];
>
> [[NSNotificationCenter defaultCenter] addObserver:levelManager
>
> selector:@selector(levelCompleted:)
>
> name:@"LevelCompletedNotification" object:gameState];
>
> [[NSNotificationCenter defaultCenter] addObserver:levelViewController
>
> selector:@selector(levelCompleted:)
>
> name:@"LevelCompletedNotification" object:gameState];
Примерный вид метода `levelCompleted:`
> - (void)levelCompleted:(NSNotification \*)notification {
>
> id subject = [notification object];
>
> Level \*level = subject.level;
>
> NSUInteger score = subject.score;
>
> }
Вообще говоря, от протокола `GameStateSubject` можно избавиться и использовать напрямую `GameState`.
Чтобы отписаться от оповещений, нужно вызвать один из методов `removeObserver:` или `removeObserver:name:object:`.
Отправка оповещения — процесс еще более простой. На то имеются методы `postNotificationName:object:` и `postNotificationName:object:userInfo:`. Первый выставляет значение `userInfo` нулевым `nil`. Новая реализация метода `notifyObservers` следует.
> - (void)notifyObservers {
>
> [[NSNotificationCenter defaultCenter]
>
> postNotificationName:@"LevelCompletedNotification" object:self];
>
> }
###### Комментарии
Механизм посылки оповещений умеет гораздо больше, чем мы описали. Например, весь приведенный код — синхронный. Для асинхронной отправки оповещений нужно использовать очереди оповещений [`NSNotificationQueue`](http://developer.apple.com/library/ios/#documentation/Cocoa/Reference/Foundation/Classes/NSNotificationQueue_Class/Reference/Reference.html#//apple_ref/occ/cl/NSNotificationQueue).
Также стоит отметить, что все описанное работает как для Cocoa, так и для Cocoa Touch. В дальнейшем мы все же будем использовать некоторые особенности платформы iOS.
#### Вместо послесловия
Давайте подведем некоторый итог тому, что мы рассмотрели и узнали. Итак, мы:
* изучили паттерн проектирования **наблюдатель**;
* использовали его собственную реализацию в часто встречающейся ситуации;
* научились делать то же самое с помощью механизма оповещений в Cocoa;
* узнали, что паттерны проектирования — это не страшно, не сложно и не громоздко;
* осознали, что паттерны берутся не с потолка, а из реальной жизни (вспомним ~~сутенера~~ *промоутера* Васю)!
Во второй части мы узнаем про механизм Key-Value Observing, который также реализует паттерн наблюдатель. Впереди еще много паттернов!
#### Полезные источники
* *Э. Гамма, Р. Хелм, Р. Джонсон, Дж. Влиссидес* Приемы объектно-ориентированного проектирования. Паттерны проектирования = Design Patterns: Elements of Reusable Object-Oriented Software. — СПб: «Питер», 2007. — С. 366. — ISBN 978-5-469-01136-1 (также ISBN 5-272-00355-1)
* *Э. Фримен, Э. Фримен, К. Сьерра, Б. Бейтс* Паттерны проектирования = Head First Design Patterns — СПб: «Питер», 2011. — С. 656. — ISBN 978-5-459-00435-9
* [Notification Programming Topics](http://developer.apple.com/library/ios/#documentation/Cocoa/Conceptual/Notifications/Introduction/introNotifications.html#//apple_ref/doc/uid/10000043-SW1) — iOS Developer Library | https://habr.com/ru/post/126968/ | null | ru | null |
# Беда “войти в айти” или курсы тестировщика отзывы: 5-минутный тест на перспективы в QA
В телеграм-канале для желающих стать тестировщиками автор опубликовал следующий пост, но дальше ситуация чуть вышла из-под контроля.
> *Как вы относитесь к различным психологическим тестам? Скорее всего, так же как и я - отрицательно. Сидишь отвечаешь на кучу вопросов, некоторые из них очень странные. При поступлении в вуз на военного программиста автор часов пять сидел заполнял тесты, в которых с завидным постоянством в разных вариациях встречался вопрос “Часто ли у вас бывают запоры?”. А потом явно не очень ментально здоровые люди, которые это все составляли, дают вердикт про твое психологическое здоровье. При этом в случае входного тестирования на работу тебе еще и результатов не скажут, только сделают у себя какие-то пометки.*
>
> *Но как работодатель, просматривающий ежегодно тысячи резюме и проводящий под сотню собеседований, я таки-даю один простой и замечательный тест.*
>
> *Он замечателен тем, что он достаточно короткий, на него нет неправильных ответов и он дает самый важный ответ - какую роль этот человек лучше всего будет играть в команде.*
>
> *Компактней* [*википедии*](https://ru.wikipedia.org/wiki/%D0%9C%D0%BE%D0%B4%D0%B5%D0%BB%D1%8C_%D0%BA%D0%BE%D0%BC%D0%B0%D0%BD%D0%B4%D0%BD%D1%8B%D1%85_%D1%80%D0%BE%D0%BB%D0%B5%D0%B9_%D0%91%D0%B5%D0%BB%D0%B1%D0%B8%D0%BD%D0%B0) *про этот тест сложно сказать*
>
> `С точки зрения Р. Белбина, команда наиболее эффективна в тех случаях, когда она неоднородна и состоит из людей, обладающих различными способностями, способами мышления и поведения. При этом необходимо, чтобы члены команды не просто различались, а дополняли друг друга и благодаря своим особенностям могли выполнять различные функции в команде.`
>
> *Что очевидно, для разных должностей в команде - руководитель проекта, владелец продукта, разработчик, тестировщик, тестлид, требуются разные качества.*
>
> *Плохие работники и неудачные жизни случаются не из-за того, что кто-то действительно плох, а из-за то, что он оказался не на своем месте, и его истинный талант не раскрылся.*
>
> *Как сказал Эйнтшейн - “Все мы гении. Но если вы будете судить рыбу по её способности взбираться на дерево, она проживёт всю жизнь, считая себя дурой.”*
>
> *Собственно, где ваше место, тест Белбина и позволяет понять.*
>
> *Пройдите тест, получите ответ, какая из 8 ролей у вас наиболее выражена и, если хотите, сбросьте результат в комментарии.*
>
> [*https://psiholocator.com/proforientaciya/test-belbina-na-vash-komandnuyu-rol*](https://psiholocator.com/proforientaciya/test-belbina-na-vash-komandnuyu-rol)
>
> *А завтра я дам ответ, какая из ролей в какой степени соотносится с работой тестировщика.*
>
>
Ситуация вышла из-под контроля, потому что на следующий день автор понял, что одной короткой заметкой в телеге на такой значимый вопрос не отделаться и нужно давать чуть более развернутый ответ. Вот он.
Белбин делит роли в команде на восемь типов. Председатель, Формирователь, Мыслитель, Оценщик, Исполнитель, Разведчик, Коллективист, Доводчик. На самом деле существует несколько версий типизации. В некоторых даны другие названия, но мы будем пользоваться этой как самой распространенной.
После прохождения этого действительно короткого теста будет дан результат вроде такого:
Доводчик - 22.9% (16 баллов)
Мыслитель - 15.7% (11 баллов)
Председатель - 12.9% (9 баллов)
Оценщик - 11.4% (8 баллов)
Разведчик - 10% (7 баллов)
Исполнитель - 10% (7 баллов)
Коллективист - 8.6% (6 баллов)
Формирователь - 8.6% (6 баллов)
Начнем с самого очевидного:
Исполнитель
-----------
> *Основным качеством Исполнителей является дисциплинированность; другие же природные способности или интеллект почти всегда в их случае вторичны. Стиль исполнителя в команде — организация работ. Исполнители надежны, консервативны и эффективны. Они обладают внутренней стабильностью и низким уровнем беспокойства. Работают преимущественно на команду, а не ради удовлетворения собственных интересов. Умеют реализовать идеи в практических действиях.
>
> Исполнители принимают поставленные перед ними цели, которые становятся частью их морального кодекса, и придерживаются их при выполнении работ. Они систематически составляют планы и выполняют их. Очень эффективные организаторы и администраторы. Они могут иметь недостаток гибкости и не любят непроверенные идеи.
>
> В крупных, хорошо структурированных организациях карьера таких людей обычно складывается очень успешно. Успех и признание приходят к Исполнителям со временем в результате того, что они систематически делают ту работу, которую необходимо делать, даже если она не отвечает их внутренним интересам или не приносит удовольствия.*
>
>
Как несложно понять, из Исполнителя может получиться очень крепкий, надежный ручной или автоматизированный тестировщик, который, в принципе, может выполнять любые задачи, особенно требующие усидчивости и точности. Регресс, покрытие тестами непокрытой функциональности, доведения до ума тестового фреймворка - причем выполнять хорошо и в срок. Значительная часть работы проекты держится на Исполнителе и делается его руками.
Минусы Исполнителя - медленно реагирует на нестандартные ситуации, поэтому задачи более творческие у него получаются хуже.
В [другой статье на Хабре про Белбина](https://habr.com/ru/post/433856/) чистых Исполнителей раскритиковали менеджеры. Мол, не сообщают про проблемы, привыкли работать в комфортном окружении с понятными задачами. Но если бы Исполнителей в том числе и в IT-среде не было бы так много, то и число менеджеров уменьшилось бы раз в десять.
К счастью, в непредвиденной ситуации, которую так не любит Исполнитель, к нему на помощь устремляется QA-Доводчик.
Доводчик
--------
> *Старателен и добросовестен. Ищет ошибки и упущения. Контролирует сроки выполнения поручений. Как правило, об успехе команды судят по окончательным результатам ее работы. При этом многие люди почти патологически не могут довести начатое ими до конца, и умение завершать начатое является достаточно редким качеством. Доводчики — это люди обладающие этим даром в полной мере. Их отличает внимание к деталям и умение держать в голове запланированное, обеспечивая чтобы ничего не упускалось и все детали плана были доведены до завершения. Они предпочитают постоянные усилия, согласованность и последовательность действий «кавалерийским атакам». Они ориентированы на выполнение обязательств и меньше интересуются эффектным и громким успехом. Склонность к достижению совершенства во всем, за что они берутся, и непреклонность в достижении намеченного — их непременные качества. К их слабым сторонам следует отнести недостаточную гибкость, в результате чего они порой тратят слишком много сил на достижение поставленных целей, которые при изменившихся обстоятельствах оказываются недостижимыми.*
>
>
QA-Исполнитель просто крутит педали и идет по тест-плану. Если что-то блочит релиз, то он спокойно ждет когда это всё порешают, и он сможет продолжить работу.
QA-Доводчик же умеет разруливать. Он держит в голове, что там обязательно должно быть сделано в этом спринте. И он помнит, что есть тот плавающий дефект, который может поставить релиз под угрозу. И что на следующем митинге надо обязательно поднять этот вопрос. Если же реализуется самый негативный сценарий, он может предложить как это всё решить. В общем расставляет “точки над i”.
У QA-Доводчика есть такая особенность, что он имеет тенденцию напрасно беспокоиться. Впрочем, для тестировщика это качество не отнесешь же к недостаткам?
Но он не любит делегировать полномочия. Для линейного сотрудника это опять же нормально, но такая особенность может стать препятствием к последующему QA-лидству Доводчика.
Поэтому хорошо, если в какой-то пропорции у него представлены и качества Председателя.
Председатель
------------
> *Поощряющий и поддерживающий тип. Склонен доверять людям и принимать их такими, какие они есть, без проявления ревности или подозрительности. Председатель — это сильное доминирование и преданность групповым целям. Стиль руководства командой Председателя — радушно принимать вносимые вклады в деятельность команды и оценивать их в соответствии с целями команды. Зрелый, уверенный, самодисциплинированный. Спокойный, несуетливый. Умеет четко формулировать цели, продвигает решения, делегирует полномочия. Организует работу команды и использование ресурсов в соответствии с групповыми целями. Имеет ясное представление о сильных и слабых сторонах команды и максимально использует потенциал каждого члена команды. Председатель может не обладать блестящим интеллектом, но он хорошо руководит людьми. Идеальный Председатель выглядит как хороший менеджер, то есть человек, знающий как использовать ресурсы, исключительно адаптивный при общении с людьми, но в то же время никогда не теряющий своего контроля над ситуацией и своей способности принимать самостоятельные решения, основанные на собственной оценке того, что необходимо на практике. Председатель — это хороший лидер для сбалансированной по своему составу команды, перед которой стоят сложные и многогранные проблемы, требующие эффективного распределения ролей внутри команды.*
>
>
Исходя из вышесказанного определения, здесь сложно что-либо добавить. Из Председателя получится замечательный QA-лид, затем менеджер проекта и так далее. Это бюрократ в самом хорошем смысле этого слова - он все раскладывает по полочкам, дает всем необходимые полномочия,к Исполнителю минимизирует хаос на проекте и создает для всех прогнозируемую рабочую среду без авралов.
При этом нужно понимать что в самом старте карьеры, работая рядовым тестировщиком, председатель может совершенно не блистать.
**Что с остальными ролями, им что-то светит в QA?**
Оценщик
-------
> *Рассудителен, проницателен, обладает стратегическим мышлением. Видит все альтернативы, все взвешивает — инспектор. Оценщик объективен при анализе проблем и оценке идей. Редко охваченный энтузиазмом, он защищает команду от принятия импульсивных, отчаянных решений. Представители этой роли ярко не проявляют себя в команде до тех пор, пока не приходит время принятия важных решений. При этом члены команды, предлагающие идеи (Мыслитель и Разведчик) редко являются теми людьми, которые способны оценить выгоду от своих идей и их последствия. Представители этой роли отличаются высоким интеллектуальным уровнем, высокими показателями критичности мышления, особенно это касается их способности выдвигать контраргументы. Оценщики достаточно медлительны в своих рассуждениях и всегда предпочитают все тщательно обдумывать. Оценщикам может не хватать вдохновения или способности мотивировать других. Окружающими они могут восприниматься как сухие, несколько занудные и порой чересчур критичные люди. Многие даже удивляются, как представители этой категории вообще становятся менеджерами. Тем не менее Оценщики нередко занимают высокие стратегические посты в организациях.*
>
>
В общем перед нам пример замечательного QA-сеньора. В будущем, возможно, бизнес-аналитика, дата-сайнтиста и так далее по [дереву IT-профессий](https://youtu.be/nNWNt4ItwdQ?t=1306).
Если на проекте кто-то лучше всех разбирается с требованиями заказчика - то это Оценщик. Находит системные противоречия, логические неувязки. Умеет прогнозировать и предсказывать неприятности за пару месяцев.
Оценщик не особо любит работать с людьми, поэтому в дальнейшем для него подойдет или горизонтальный рост или чисто техническое руководство с минимальным пересечением с заказчиками.
Мыслитель
---------
> *Интровертивный тип генератора идей. Изобретателен, обладает богатым воображением — человек с идеями, умеющий решать нестандартные проблемы. Как правило, Мыслители действуют в одиночку, сидя в своем углу и обдумывая различные варианты. Обладают высоким интеллектуальным уровнем и очень высоким показателем креативности. Это яркие представители интеллектуалов-одиночек, и они часто воспринимаются членами команды как не слишком коммуникабельные. Им свойственна прямота и честность в общении. Стиль Мыслителя — привносить инновационные идеи в работу команды и ее цели. Он склонен «витать в облаках» и игнорировать детали или протокол. Чем более успешно Мыслители осуществляют свою роль в команде, тем меньше их поведение похоже на привычную модель поведения менеджера. В мире организаций Мыслители не слишком процветают, и их менеджерская карьера редко бывает блестящей. Как правило, они очень способны и умелы, что приводит к тому, что в большинстве случаев они становятся техническими специалистами, а не занимают высокие управленческие посты. Мыслители чаще встречаются в новых, только формирующихся компаниях, поскольку по складу своему они скорее предприниматели, чем менеджеры.*
>
>
Еще один интровертный тип. Если кто-то навернул нестандартную автоматизацию на проекте, подтянул только что вышедший и еще не обкатанный тул - это Мыслитель. Иногда его уносит в совсем оторванные от реальности и текущих нужд проекта дали, поэтому такой тестировщик будет эффективен на проекте, если лид периодически направляет его в нужную сторону и напоминает про сроки и приоритеты. Но если это происходит, то привнесенные им подходы начинают потом использоваться на других проектах или даже в других компаниях.
Формирователь
-------------
> *Предпринимательский тип. Формирователи всегда выступают как побудители к действию, и если команда склонна к бездействию или самодовольству, то присутствие Формирователя выведет ее из этого состояния. Такой лидер — динамичный, бросает вызов, оказывает давление. Стиль руководства Формирователя — оспаривать, мотивировать, достигать. Это более индивидуалистичный, чем Председатель тип лидера, который подталкивает людей к действиям и, увлекая их за собой, столь же часто приводит команду к неудаче, как и к успеху. Его мужество и энергия позволяют преодолевать трудности.
>
> Формирователи по многим параметрам являются антиподами Коллективистов. Ненавидят проигрыши, склонны к провокациям, раздражению и нетерпению. Характеризуются высокой самооценкой, склонностью к фрустрации, общительностью и подозрительным отношением к людям. Это экстраверты, побуждаемые к действиям требованиями внешней среды. Как лидеры они хороши для уже сработанной команды, которая в своей работе столкнулась со сложным, внешним, либо внутренним препятствием. Как менеджеры Формирователи процветают в ситуациях, характеризующихся «политической сложностью», сдерживающей движение вперед.*
>
>
Здесь у нас то что называется “неформальный лидер”. Если у вас Формирователь - это основная роль по Белбину, то для вас или QA будет лишь одним из этапов карьеры или же вы впишетесь в какой-нибудь стартап. В жесткой корпоративной структуре через какое-то время вам станет слишком тесно, не будет хватать драйва, простора для творчества и так далее. А учитывая что в стартапах действует принцип “бери ответственности сколько сможешь”, то там вы получите полное удовольствие. Потом, возможно, запустите и свой стартап. В общем сидеться на месте вам не будет.
**Следующие два типа казалось бы вообще далеки от QA. Хотя это не совсем так.**
Разведчик
---------
> *Экстравертивный тип генератора идей. Энтузиаст, общителен. Это еще один член команды, ориентированный на предложение новых идей. Однако, способ генерации идей Разведчиками и сам характер предлагаемых ими идей отличны от мыслителей. Они склонны не столько сами предлагать оригинальные идеи, сколько «подбирать» фрагменты идей окружающих и развивать их. Разведчики особо искусны в изучении ресурсов за пределами команды. Стиль построения команды разведчика — создать сеть и собирать полезные ресурсы для команды. При средних показателях интеллектуального уровня и креативности, они общительны, любознательны и социально ориентированы. Благодаря этим качествам и умению использовать ресурсы Разведчики легче, чем Мыслители интегрируются в команду. При умелом руководстве лидера команды Мыслитель и Разведчик могут успешно сосуществовать вместе, не покушаясь на территорию друг друга и внося каждый свой вклад в предложение новых идей.*
>
>
Экстраверт, которому не сидится на месте и который часто теряет интерес по мере угасания первоначального энтузиазма - этот-то что забыл в IT?
Автор уже лет 15 наблюдает перед собой такого человека. Это наш QA-эксперт, она же QA-менеджер из одной из [предыдущих статей](https://habr.com/ru/post/588376/) с общим стажем тестирования 20 лет. Не всегда глубоко погружается в детали конкретной функциональности, но незаменима на больших проектах, когда приходится сводить воедино функциональность нескольких распределенных команд, а также в работе по передаче знаний из команды в команду.
Опять же из Разведчиков в дальнейшем получаются отличные QA-преподаватели.
Коллективист
------------
> *Мягкий, восприимчивый, дипломатичный. Умеет слушать, предотвращает трения членов команды — чувствителен по отношению и к индивидам, и к ситуациям. Коллективист играет ориентированную на отношения, поддерживающую роль в команде. Если в команде есть сложные в общении люди, то Коллективисты способны оказать мягкое воздействие на ситуацию и предотвратить потенциальные конфликты, тем самым оказывая помощь формальному лидеру команды в выполнении поставленной задачи. Коллективист может быть нерешителен в момент кризиса.
>
> Представители этого типа нередко встречаются среди высшего руководства организаций. Из них получаются отличные наставники молодых менеджеров.*
>
>
Однажды один предприниматель сказал “я бы не хотел жить в обществе, где нет чиновников”. Почему? Ведь вроде бы чиновник - главный враг предпринимателя. Но представьте общество, где только одни предприниматели (то есть Формирователи). Которые всегда действуют напролом, не признают правил и не слишком ориентируются на чувства других. Что в общем то не очень комфортно для остальных.
Поэтому дипломатичный, смягчающий ситуации Коллективист нужен на любом проекте. С одной стороны он не хватает звезд с неба, скажем, в той же автоматизации. Но зато когда на сложном проекте вырастет уровень стресса и команда начинает выгорать, этот человек может снять напряжение. Понятно что “хороший парень” - это не должность и не профессия - роль Коллективиста должна дополняться Исполнителем, Доводчиком.
Выводы
------
### Однозначно в IT
* Исполнитель, Доводчик - вы нужны в QA. Ведь собственно вы делаете почти всю работу.
* Оценщик, Мыслитель - ждут ли высокоинтеллектуальных интровертов в IT? Ответ очевиден.
### Неоднозначно
* Председатель (но с выраженными техническими навыками!) в дальнейшем станет отличным QA-лидом.
* Формирователь - если у вас это ярко выраженная роль по Белбину, попробуйте выяснить свою мотивацию. Почему именно IT? Как мне кажется, для Формирователя будущее в IT - “или пан или пропал”. Или он попадет в компанию где активно приветствуются инновации (или сам создаст такую среду под себя) и станет там звездой или IT превратится лишь в одну из многочисленных строчек в его биографии. Если у вас Формирователь - основная роль, и вы хотите в QA или уже тестировщик, [напишите мне](https://t.me/I00chukQA). Интересно пообщаться.
* Разведчик, Коллективист - у вас должна быть еще какая-то поддерживающая, зажигающая роль или мотивация - чтобы ваша жизнь в IT была взаимовыгодной. Попробуйте понять чем вас еще привлекает IT кроме зарплаты? Если это общение с интересными высокоинтеллектуальным людьми (в случае Разведчика) или важность отсутствия высокотоксичных личностей (в случае Коллективиста), то в совокупности с базовыми техническими навыками вы можете себя найти.
Было бы глупо не добавить что:
а) Любые тесты, а психологические тем более - вещь относительная. Они могут дать какой-то срез для анализа и размышлений, не более того.
б) Чистых психологических типов не бывает. Каждый из нас - смесь иногда совершенно противоречивых качеств. Саморефлексируйте, пытайтесь понять какая из присутствующих у вас командных ролей назначена главной вам самим принудительно, а какая, что более важно, на самом деле приносит удовольствие.
QAsmokeQA
---------
**Если не хотите пропустить следующий материал автора, что-то новое в QA курсах или нюансы QA-собеседований, тогда подпишитесь на** [**http://t.me/QAsmokeQA**](http://t.me/QAsmokeQA)
***P.S.*** Из действующих лиц ситкома “Кремниевая долина” не использовалась фотография только одного, причем главного. Почему? Потому что, очевидно, он оказался не в своей командной роли и не на своем месте.
***P.P.S.***
Если вы сейчас как студент проходите курс по QA, заинтересованы в получении максимально качественного образования и готовы делиться удовлетворенностью о ходе обучения, напишите в ЛС. В ответ при возникновении брешей в учебе или сложностей с трудоустройством автор поможет путем бесплатного подключения знакомых топовых менторов.
Если вы в своей компании отвечаете за QA-ресурсы, накопили статистику по приходящим с курсов джунам или просто не удовлетворены входным потоком кандидатов - в том числе и выпускниками образовательных курсов, напишите в ЛС. В ответ автор предоставит детализированную статистику.
Если вы в своем учебном центре выпустили новый QA-курс или обновление существующего, напишите в ЛС. Но только если уверены в его качестве.
Не зарегистрированным на Хабре добро пожаловать<https://t.me/I00chukQA> | https://habr.com/ru/post/598481/ | null | ru | null |
# Улучшаем процесс ведения проекта в Git
Привет! Я давно заметил, что процесс добавления нового кода в проект в большинстве команд может быть не всегда стандартизирован. Из-за этого могут возникнуть сложности в коммуникации разработчиков как на уровне описания добавленного кода, так и понимания, какое влияние несет новый функционал на сам проект. Кроме того, команде аналитиков, разработчиков и заказчикам проекта важно иметь описание хронологии изменений проекта в читабельном виде.
Поэтому решил написать статью, в которой хотелось бы затронуть тему стандартизации процесса, используя конвенции и различные инструменты, позволяющие соблюсти правильное и понятное развитие кода проекта, что и применяется в нашей компании. Статья может быть полезна всем тем, кто ведет проекты в git.
Стандартная процедура добавления нового функционала в проект выглядит так:
1. Разработчик делает клонирование проекта из центрального хранилища на локальную машину.
2. Создает новую ветку и вносит новый commit на локальном репозитории.
3. Делает `push` ветки в центральное хранилище.
4. Делает `merge request` данной ветки в *main*(or *master*).
5. Происходит новый релиз проекта.
Source: https://www.atlassian.com/cs/git/tutorials/using-branches/git-mergeВ процедуре возникает ряд вопросов:
* как сделать автопроверку добавления некорректного описанного commit-а(commit-message) локально, чтобы впоследствии он не был добавлен в удаленное централизованное хранилище кода;
* каким образом описывать commit, чтобы иметь понимание его влияния на проект;
* как фиксировать автоматически новый релиз проекта, а также иметь описание хронологии изменений кода в истории.
Ответить на эти вопросы могут конвенции и инструменты, о которых я расскажу ниже.
Pre-commit hooks
----------------
[Commitlint](https://commitlint.js.org/) — это инструмент, который проверяет сообщения commit-ов на соответствие общепринятым стандартам их описаний. Введение таких стандартов описаний сообщений в общую практику было необходимо, чтобы не засорять проект commit-ами, имеющими хаотичную структуру описания. Такие commit-ы не всегда могут быть понятными как с точки зрения тематики, так и с точки зрения их степени влияния на проект.
В случае, если вы пытаетесь произвести commit с сообщением(commit-message), не соответствующим стандарту (только если вы не внесли дополнительные изменения в файл конфигурации), инструмент *сommitlint* его блокирует. Теперь commit не может быть внесен на локальный репозиторий, либо на удаленный GitLab instance-сервер, что позволяет исключить человеческий фактор некорректного заполнения commit-сообщений, структурное и полное написание которых зачастую игнорируются.
Напомню, что некорректное заполнение commit-сообщений может привести к сложностям для понимания и поддержки проекта не только другими разработчиками, но и автору проекта, ввиду того, что внесенные изменения со временем могут забываться.
Запускается инструмент *commitlint* как *husky pre-commit hook*, то есть локально на сервере, с которого автор хочет произвести отправку сommit-а на удаленный gitlab-сервер.
Структура составления сообщения в commit-е должна выглядеть следующим образом:
[optio`nal scope]:
[optional body]
[optional footer(s)]`
Так выглядит пример commit-сообщения в соответствии с конвенцией описания:
`feat(model): Add new OCR model which shows better performance on validation set`
Ниже представлена таблица с описанием того, какие типы (название в конвенции выше) использовать в случае добавления нового commit-а:
| | |
| --- | --- |
| **Type** | **Description** |
| feat | A new feature |
| fix | A bug fix |
| docs | Documentation only changes |
| style | Changes that do not affect the meaning of the code (white-space, formatting etc) |
| refactor | A code change that neither fixes a bug nor adds a feature |
| perf | A code change that improves performance |
| test | Adding missing tests or correcting existing tests |
| build | Changes that affect the build system or external dependencies |
| ci | Changes to our CI configuration files and scripts |
| chore | Other changes that don't modify src or test files |
| revert | Reverts a previous commit |
Pre-commit hooks в действии
---------------------------
Теперь покажу на примере, каким образом срабатывают *pre-commit hooks*. Для этого создадим проект под названием ***semantic-versioning***, в котором помимо ветки ***main*** будет создана дочерняя ветка с названием ***feature/add-new-file*.**
* Для примера добавил в эту ветку новый файл с названием ***test.txt*:**
* Попытаемся сделать commit-message, не проходящий по конвенции наименования типов, описанных ранее в таблице:
Видно, что наш commit не проходит из-за несоответствия конвенции названия типа внутри commit-message. Вместо указанного типа ***manual\_test*** внутри commit-сообщения необходимо указать один из следующих: [*feat, fix, refactor, config, ci, perf, test, docs, chore*].
* Теперь исправим название типа внутри сообщения на конвенциональные
(***manual\_test -> feat***)):
Видим, что добавление нового commit-а прошло без ошибок.
* Сделаем `git-push` в соответствующую названию remote ветку на gitlab server:
Semantic versioning
-------------------
Теперь представим, что вы хотите обновлять теги в проекте автоматически. При этом фиксировать новое состояние проекта (релиз) в зависимости от типов сделанных commit-ов. Это очень удобно, так как не нужно каждый раз при новом commit-е прописывать отдельно команду `git push` нового тега, и при этом думать еще и о соблюдении последовательности нумерации тегов в проекте. Такой функционал мне кажется крайне необходимым, особенно когда в команде много разработчиков, работающих над одним проектом.
**Semantic versioning** — это способ автоматического версионирования проекта в зависимости от описания commit-message. Для того, чтобы проделать такое версионирование задействуется менеджер автоверсионирования проекта ***semantic-release***, который использует знания о типе совершённых commit-ов исходя из commit-message для определения степени влияния внесенных изменений в проект.
**Semantic-version** проекта — это *tag* (snapshot, фиксированное состояние) проекта, который характеризуется тремя числами, разделенными через точку:
При внесении новых commit-ов в проект возможно изменение его semantic-version.
Степень влияния таких изменений может влиять на тег проекта следующим образом:
* **MAJOR-число** увеличивается, когда в проект вносятся глобальные изменения (breaking change);
* **MINOR-число** увеличивается, когда происходит добавление новой фичи или функционала в проект;
* **PATCH-число** увеличивается, когда происходят изменения в проекте вроде исправления ошибок (bug fixes).
Инструмент ***semantic-release*** помогает автоматически определять следующий tag проекта (то есть его semantic-version), генерирует обновленный changelog (файл с описанием хронологических изменений в проекте) и публикует новый релиз проекта.
Попробую продемонстрировать пример семантического версионирования проекта.
1. Смотрим на последний commit, который был сделан в ветке ***feature/add-new-file*:**
2. На gitlab-сервере смотрим на имеющиеся ветки и теги и видим, что **последний тег проекта равен v.1.1.0** :
3. Попробуем сделать слияние (merge-request) *feature/add-new-file* ветки c *main*-веткой. Мы видим, что изменения в данном commit-е касаются только добавления нового файла ***test.txt*** в проект:
4. Делаем merge-request с *main*-веткой:
5. После этого автоматически проходит заготовленный заранее нами сценарий pipeline(его мы разберем позже), который состоит только из одного шага: публикации (publishing) нового релиза проекта:
6. Видим, что pipeline пробежал:
7. Открываем главную страницу проекта и **видим, что** **появился новый tag с номером v1.2.0:**
Можно заметить, что в *main*-ветке будет храниться состояние проекта, соответствующее **новому tag с версией v1.2.0:**
Также посмотрим на сгенерированный [*CHANGELOG.md*](http://CHANGELOG.md) файл, который хранит хронологически упорядоченный список изменений, внесенных в проект:
В итоге мы видим, что после выполнения всех шагов **появилась новая версия проекта с тегом v1.2.0 и описанием того, какие изменения были сделаны в проект в контексте данного тега(внутри *CHANGELOG.md*-файла).** Так как в нашем случае commit-message содержал описание типа добавления новой фичи (“`feat: …`”), что считается по конвенции минорным изменением проекта (MINOR changes), **тег проекта автоматически увеличился с v1.1.0 -> v1.2.0.**
Реализация semantic versioning
------------------------------
Чтобы запустить семантическое версионирование проекта используем node.js-плагины, которые указываем в файле **package.json** для скачивания:
`"devDependencies": {
"@semantic-release/changelog": "^5.0.1",
"@semantic-release/commit-analyzer": "^8.0.1",
"@semantic-release/git": "^9.0.0",
"@semantic-release/gitlab": "^6.0.4",
"@semantic-release/release-notes-generator": "^9.0.1",
"semantic-release": "^17.0.7"}`
Для того, чтобы установить необходимые пакеты в пайплайне, который состоит только из одного stage с наименованием “publishing”, нужно запустить команду `npm install` в корне проекта, где должен лежать файл package.json.
Следующий шаг — запуск команды `npx semantic-release`, которая и выполняет автоверсионирование проекта. Сценарий pipeline-а, который указан ниже должен быть описан в файле **.gitlab-ci.yml**:
`stages:
- publishing
publishing:
stage: publishing
script:
- npm install
- npx semantic-release -b $CI_COMMIT_REF_NAME
only:
- main`
Обратите внимание, что генерация и публикация тега новой версии проекта происходит только на *main*-ветке.
Для конфигурации релиза проекта нужно добавить файл **releaserc.json** в корне проекта, в котором можно кастомизировать настройки релиза.
Ради интереса можно взглянуть на логи stage-а публикации (publishing) внутри нашего pipeline после слияния веток. Там видно, что commit определился как минорный тип изменений для проекта:
Происходит вычисление нового тега в связи с данным commit-ом:
и, соответственно, его создание локально на gitlab-runner-е и последующая публикация на gitlab-сервере:
Заключение
----------
В статье я рассмотрел best practices организации ведения кода в проекте: конвенции описания commit-сообщений, инструмент автопроверки нестандартных описаний коммитов commitlint и способ автоверсионирования проекта semantic versioning. Надеюсь, это будет полезно вам и позволит организовать удобное ведение изменений кода в проектах. | https://habr.com/ru/post/664190/ | null | ru | null |
# Пример создания простой 2D игры для Android с использованием игрового движка Unity
Введение
========
Прежде всего, хочу сразу отметить, что я не являюсь профессиональным разработчиком. В этой статье я постараюсь изложить свой опыт создания игры «Feel Speed Racing». Данный материал, скорее всего не будет интересен тем, кто уже имеет большой опыт в разработке игр, но начинающим разработчикам, которые хоть немного работали с Unity думаю, будет интересно.
Дизайн
======
Концепция игры заключается в том, что автомобиль должен пройти, как можно большее расстояние при этом на дороге динамически появляются препятствия их надо объезжать мимо иначе «игра окончена» еще нужно следить за шкалой топлива и собирать на дороге топливные баки, по истечению которой игра тоже останавливается.
Разработка
==========
Игра состоит из 2-х сцен: главное меню и сама игровая сцена:
Где «menu» это главное меню а «1» это игровая сцена.
#### Главное меню
Для создания столь незамысловатого меню нам потребуется элемент управления GUI, который является стандартным в Unity.
В качестве фона я использовал спрайт с именем «background» заполненный серым цветом. Вы же можете выбрать что угодно.
Далее создаем скрипт «menu.cs»(Щелкаем правой кнопкой->выбираем Create-> C# Script) и вешаем его на background.
Содержимое скрипта:
```
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
public class menu : MonoBehaviour {
public GUIStyle mystyle; //объявляется для того чтобы изменять начертание GUI компонентов(шрифт, размер и.т.п.)
string score; //переменная для хранения пройденной дистанции
void Start ()
{
StreamReader scoredata = new StreamReader (Application.persistentDataPath + "/score.gd"); //создание файловой переменной
score = scoredata.ReadLine (); //чтение строки
scoredata.Close (); //закрытие файловой переменной
}
void Update () {
}
void OnGUI(){
GUI.Box (new Rect (Screen.width*0.15f, Screen.height*0.8f, Screen.width*0.7f, Screen.height*0.1f), "MAX DISTANCE:"+score,mystyle); //создаем небольшое окошко для показа пройденного расстояния
if (GUI.Button (new Rect (Screen.width*0.15f, Screen.height*0.25f, Screen.width*0.7f, Screen.height*0.1f), "Start game",mystyle)) //создаем кнопку для запуска игровой сцены
{
Application.LoadLevel(1);//Загрузка игровой сцены
}
if (GUI.Button (new Rect (Screen.width*0.15f, Screen.height*0.4f, Screen.width*0.7f, Screen.height*0.1f), "Exit",mystyle)) //создаем кнопку для выхода из игры
{
Application.Quit();//Выход из игры
}
}
}
```
В результате должно получиться примерно вот так:
Шрифт, цвет и размер GUI элементов вы можете изменить с помощью MyStyle.
#### Создание игровой сцены
Основными на этой сцене элементами является дорога, автомобиль и шкала топлива.
1. Дорога:
Ввиду того что гонка является бесконечной и останавливается только когда машина попадет в препятствие или закончится бензин, дорога является двигающейся. То есть автомобиль может перемещаться влево или вправо, а иллюзию движения по прямой создает дорога.
Кидаем спрайт с дорогой на игровую сцену и подгоняем по размерам камеры.
Затем добавляем как дочерние объекты внутрь дороги 4 блока с препятствиями, топливный бак и не забываем добавить к ним Box Collider 2D.Еще надо отметить Is Triger для пересечения с автомобилем.
Теперь создаем скрипт moveroad.cs и вешаем его на нашу дорогу.
Добавляем в него следующий код:
```
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
public class moveroad : MonoBehaviour {
public GUIStyle mystyle;//создание стиля
int f,fuelst;
float score=0,speed=-0.2f,data,fuelpos;// переменные для хранения расстояния, скорости и рекорда
public GameObject block;// игровой объект для размещения блока
public GameObject block1;
public GameObject block2;
public GameObject block3;
public GameObject fuel;
bool turbotriger=false;
void Start ()
{
StreamReader scoredata = new StreamReader (Application.persistentDataPath + "/score.gd");
data = float.Parse(scoredata.ReadLine ());//чтение с файла информации о рекорде
scoredata.Close ();
}
void Update ()
{
transform.Translate (new Vector3 (0f,speed,0f));//движение дороги с заданной выше скоростью
score = score + (speed*-10);// подсчет расстояния
if (transform.position.y < -19f) // если дорога уходит за пределы камеры то она "теле портируется" вверх
{
transform.position=new Vector3(0f,33.4f,0f);//новая позиция дороги
block.transform.position=new Vector3(10.15f,block.transform.position.y,block.transform.position.z);
block1.transform.position=new Vector3(8.42f,block1.transform.position.y,block1.transform.position.z);
block2.transform.position=new Vector3(6.62f,block2.transform.position.y,block2.transform.position.z);
block3.transform.position=new Vector3(4.95f,block3.transform.position.y,block3.transform.position.z);
fuel.transform.position=new Vector3(11.86f,fuel.transform.position.y,fuel.transform.position.z);
//скрытие за пределы камеры всех препятствий(блоков)
f = Random.Range (0, 5);//случайное появление на дороге 1-го из 4-х блоков или канистры с бензином
switch (f)
{
case 0:block.transform.position=new Vector3(2.40f,block.transform.position.y,block.transform.position.z); break;
case 1:block1.transform.position=new Vector3(0.90f,block1.transform.position.y,block1.transform.position.z); break;
case 2:block2.transform.position=new Vector3(-0.80f,block2.transform.position.y,block2.transform.position.z); break;
case 3:block3.transform.position=new Vector3(-2.35f,block3.transform.position.y,block3.transform.position.z); break;
case 4:
fuelst=Random.Range(0,4);
if(fuelst==0){fuelpos=2.40f;}
if(fuelst==1){fuelpos=0.90f;}
if(fuelst==2){fuelpos=-0.80f;}
if(fuelst==3){fuelpos=-2.35f;}
fuel.transform.position=new Vector3(fuelpos,fuel.transform.position.y,fuel.transform.position.z);
break;
}
if (score>data)// если текущее пройденное расстояние превышает то что записано в файле рекорда то идет обновление данных
{
StreamWriter scoredata=new StreamWriter(Application.persistentDataPath + "/score.gd");//создаем файловую переменную для хранения пройденного расстояния
scoredata.WriteLine(score);//записываем новое значение в файл
scoredata.Close();//закрываем файловую переменную
}
}
}
void OnGUI(){
GUI.Box (new Rect (0, 0, Screen.width, Screen.height*0.05f), "Distance(m): " + score,mystyle);//создаем окно для подсчета расстояния
}
}
```
Должно получиться примерно вот так. Если все так оставить то после того как дорога пройдет до конца то будет оставаться пустое пространство и так будет по кругу, дорога будет исчезать.
Что бы решить эту проблему надо создать дубликат уже готовой дороги и немного изменить скрипт.
Должно получиться вот так.
2. Автомобиль:
Кидаем спрайт автомобиля на сцену и устанавливаем его в любое место на дороге. Затем создаем скрипт carcontroller.cs и вешаем его на автомобиль.
Содержимое carcontroller.cs:
```
using UnityEngine;
using System.Collections;
using UnityStandardAssets.CrossPlatformInput;
public class carconroller : MonoBehaviour
{
void Start ()
{
}
public void Update ()
{
if (transform.rotation.z !=0) //проверка столкновения коллайдера автомобиля и препятствия, при столкновении происходит загрузка меню
{
Application.LoadLevel (0);
}
}
}
public void OnGUI()
{
if (GUI.RepeatButton (new Rect (Screen.width*0.1f, Screen.height*0.9f, Screen.width*0.2f, Screen.height*0.08f), "L")) //создаем кнопку для движения влево
{
if (transform.position.x > -2.4f)
{
transform.Translate (new Vector3 (-0.05f, 0f, 0f));
}
}
if (GUI.RepeatButton (new Rect (Screen.width*0.7f, Screen.height*0.9f, Screen.width*0.2f, Screen.height*0.08f), "R")) //создаем кнопку для движения вправо
{
if (transform.position.x < 2.4f)
{
transform.Translate (new Vector3 (0.05f, 0f, 0f));
}
}
}
}
```
Теперь автомобиль может перемещаться.
3.Шкала топлива:
Для создания шкалы потребовалось 2 спрайта одинаковых размеров, но разных цветов (красный, зеленый). И сделать один из них дочерним (зеленый).
Далее создаем скрипт fuelscript.cs, вешаем его на fuel и добавляем в него код:
```
using UnityEngine;
using System.Collections;
public class fuelscript : MonoBehaviour {
public GameObject fuelall;
float mytimer=100f;// задание плавающего числа
// Use this for initialization
void Start ()
{
}
void Update ()
{
mytimer = 100f;
mytimer -= Time.deltaTime;//изменения числа с течением времени
if (mytimer/mytimer==1f) //проверка на период времени в 1 секунду
{
fuelall.transform.position=new Vector3(fuelall.transform.position.x-0.0011f,fuelall.transform.position.y,fuelall.transform.position.z);
fuelall.transform.localScale = new Vector3(fuelall.transform.localScale.x-0.001f, 1, 1);
//выше идет сдвижение влево и уменьшение по ширине зеленой полосы для имитации шкалы
}
if (fuelall.transform.localScale.x < 0) //если шкала исчезла то загрузка идет загрузка главного меню
{
Application.LoadLevel(0);
}
}
}
```
Дорога у меня это road183 и ее дубликат road183(1). В ее дочерний объект fueltrack нужно добавить скрипт для обнаружения пересечения с автомобилем и восполнения топлива.
Создаем скрипт triger.cs и вешаем его на fueltrack в обеих дорогах и отмечаем как Is Triger. Код:
```
using UnityEngine;
using System.Collections;
public class triger : MonoBehaviour {
public GameObject fuel;//добавляем сюда greenfuel
// Use this for initialization
void Start () {
}
// Update is called once per frame
void Update () {
}
void OnTriggerEnter2D(Collider2D col)
{
if (col.gameObject.name == "playercar") //проверка пересечения автомобиля и объекта fuel
{
fuel.transform.position=new Vector3(0,fuel.transform.position.y,fuel.transform.position.z);
fuel.transform.localScale = new Vector3(1, 1, 1);
//восстановление у объекта fuel стандартных значений
}
}
}
```
Итог
====
В момент выпуска игры на Google Play я особо не занимался ее продвижением ну и само собой закачек не набралось.
В отсутствие профессионального художника, с иконкой пришлось работать самостоятельно:
 | https://habr.com/ru/post/283186/ | null | ru | null |
# Про Flutter, кратко: Основы
После доклада [Юры Лучанинова](https://www.youtube.com/watch?v=Y3kk4Qu79Qc&list=PLnkLrCUX4Qh4RH-BltBk03Eet1UAF-S7S&index=19), я решил для себя попробовать Flutter. Чтобы мозг размять, и чтобы было о чем похоливарить с мужиками на кухне. Дело пошло. Я начал смотреть, потом читать, потом писать. И вроде все получается, приложения запускаются, и то что объясняют — понятно, все просто. Но не без “но” — объясняют не все. А поскольку платформа, ЯП, подходы и даже предметная область для меня новые, то подобное вызывает раздражение, ведь у тебя “не запускается”, а ты даже не знаешь что гуглить: Dart/Flutter/Window/Screen/Route/Widget?
Перечитывать всю документацию Dart, Flutter и его виджетов конечно же не хотелось, ведь времени у меня не много, и мне лишь хотелось присмотреться к Flutter. Вот было бы здорово, если бы был небольшой гайд, в котором описано все нужное, но не больше, для понимая и написания не слишком сложных приложений на Flutter!
Про гайд
--------
Большинство статей по этой теме хорошо написаны и не являются сложными. Проблема заключается в том, что большинство из них предполагают наличие знаний считающихся базовыми основами, которые, тем не менее, не упоминаются в других статьях описывающих основы. В данной серии статей я хочу исправить эту ситуацию. Начнем с нуля и, не оставляя ничего из упомянутого без внимания, запустим одно или несколько приложений. В процессе научимся пользоваться всеми **основными компонентами**, создавать **уникальный интерфейс**, работать с **нативными модулями**, и, конечно же, собирать свое **приложение под обе платформы**.
Писать я буду с перспективы веб-разработчика. Большинство из вас скорее всего знакомо со стэком веба, а аналогия со знакомой платформой лучше аналогии с постройкой домов или чего там еще, Animal, Dog, Foo, Bar…
Излагаться постараюсь кратко, чтобы не затягивать. А для самых любознательных буду оставлять полезные ссылки по обсуждаемым темам.
Про платформу
-------------
Flutter — молодая, но очень многообещающая платформа, уже привлекшая к себе внимание крупных компаний, которые [запустили свои приложения](https://flutter.io/showcase). Интересна эта платформа своей простотой сравнимой с разработкой веб-приложений, и скоростью работы на равне с нативными приложениями. Высокая производительность приложения и скорость разработки достигается за счет нескольких техник:
* В отличии от многих известных на сегодняшний день мобильных платформ, Flutter **не использует JavaScript** ни в каком виде. В качестве языка программирования для Flutter выбрали Dart, который компилируется в бинарный код, за счет чего достигается скорость выполнения операций сравнимая с Objective-C, Swift, Java, или Kotlin.
* Flutter **не использует нативные компоненты**, опять же, ни в каком виде, так что не приходится писать никаких прослоек для коммуникации с ними. Вместо этого, подобно игровым движкам (а вы ведь знаете что у игр очень динамичный UI), он отрисовывает весь интерфейс самостоятельно. Кнопки, текст, медиа-элементы, фон — все это отрисовывается внутри графического движка в самом Flutter. После вышесказанного стоит отметить, что “Hello World” приложение на Flutter занимает совсем немного места: iOS ≈ 2.5Mb и Android ≈ 4Mb.
* Для построения UI во Flutter **используется декларативный подход**, вдохновленный веб-фреймворком ReactJS, на основе виджетов (в мире веба именуемых компонентами). Для еще большего прироста в скорости работы интерфейса **виджеты перерисовываются по необходимости** — только когда в них что-то изменилось (подобно тому как это делает Virtual DOM в мире веб-фронтенда).
* В дополнение ко всему, в фреймворк **встроен** [**Hot-reload**](https://flutter.io/docs/development/tools/hot-reload), такой привычный для веба, и до сих пор отсутствовавший в нативных платформах.
О практической пользе этих факторов я очень рекомендую прочитать [статью Android разработчика](https://proandroiddev.com/why-flutter-will-change-mobile-development-for-the-best-c249f71fa63c), который переписал свое приложение с Java на Dart и поделившегося своими впечатлениями. Сюда я лишь вынесу названное им количество файлов/строк кода до (написанное на Java) — 179/12176, и после (переписанное на Dart) — 31/1735. В документации можно найти подробное описание [технических особенностей платформы](https://flutter.io/docs/resources/inside-flutter). А вот ещё ссылка, если интересно посмотреть другие [примеры работающих приложений](https://itsallwidgets.com/).
Про Dart
--------
Dart — язык программирования на котором нам предстоит писать приложения под Flutter. Он очень прост, и если у вас есть опыт работы с Java или JavaScript, вы быстро его освоите.
Я пытался написать обзорную статью о Dart, стремясь описать лишь необходимый минимум для изучения Flutter. Но в этом языке столько нюансов, что несмотря на несколько попыток написать такую статью, у меня так и не удалось сделать ее достаточно полной и в то же время короткой. С другой стороны, авторы [A Tour of the Dart Language](https://www.dartlang.org/guides/language/language-tour) отлично справились с этой задачей.
Про подготовку
--------------
Эта тема, как и Dart, очень хорошо описана в официальном гайде. Я мог бы разве что скопировать ее сюда, но делать этого не стану.
Ничего не дожидаясь, идем на страницу [гайда по установке](https://flutter.io/docs/get-started/install), выбираем платформу и по шагам выполняем инструкцию для установки платформы на нашу систему. В своем редакторе **обязательно** подключаем плагины. В том же гайде есть инструкция по настройке [VS Code](https://flutter.io/docs/get-started/editor?ide=vscode) и [IntelliJ](https://flutter.io/docs/get-started/editor?ide=androidstudio). Для вашего редактора тоже найдутся плагины для Dart и Flutter (обычно нужно ставить два). [Запускаем приложение и проверяем его работоспособность](https://flutter.io/docs/get-started/test-drive?ide=vscode).
Подсказка для пользователей OSX. Мне жалко места занимаемого нарисованными рамками телефона в эмуляторе iOS, поэтому я их отключил и переключился на iPhone 8 (он не такой “длинный”):
* `Hardware → Device → iOS # → iPhone 8`
* `Window → Show Device Bezels`
Без кнопок жить можно, ведь есть хоткеи: `Shift + Cmd + H` — это домой, `Cmd + Right` — а это перевернуть телефон, остальное можно найти в меню `Hardware`. А вот экранную клавиатуру я советую включить, ведь важно понимать можно ли работать с приложением когда половина экрана регулярно перекрывается клавиатурой: `Cmd + K` (работает когда фокус находится на каком-то поле ввода).
**iPhone 8 & iPhone X с рамками**
**iPhone 8 & iPhone X без рамок**
Про структуру
-------------
Зайдем в папку со сгенерированным приложением и разберемся что у нас там есть. Не со всем, но с нужным:
* `lib/` — По принципам [pub](https://www.dartlang.org/guides/libraries/create-library-packages) (менеджер пакетов Dart’а) весь код лежит в этой подпапке;
* `pubspec.yml` — сюда записываются зависимости приложения, которые нужно установить для его запуска, точно как `package.json`, но есть нюанс, устанавливать их нужно не через стандартную утилиту Dart’а, о которой говорилось выше, а через команду Flutter’а: `flutter pub get` ;
* `test/` — вы ведь знаете что там? Запустить их можно вызвав `flutter test`;
* `ios/` & `android/` — папки с настройками для каждой из платформ, там указывается какие права нужны для запуска приложения (доступ к локации, bluetooth), иконочки и все что специфично для платформы.
Со структурой разобрались, заходим в папку `lib/` где нас ждет `main.dart` файл. Это, как вы можете догадаться, тот самый файл в котором мы должны запускать наше приложение. А запускается оно подобно как в языке C (и еще тонны других) вызовом функции `main()`.
Про виджеты (Hello World здесь)
-------------------------------
Во Flutter’е все построено на [Widget](https://flutter.io/docs/development/ui/widgets-intro)’ах: тут и вьюшки, и стили с темами, и состояние в виджетах хранится. Есть два основных типа виджетов: со стейтом и без, но пока не об этом. Давайте с простого.
Удаляем все из **main.dart**. Вставляем следующий код внимательно вчитываясь в комментарии:
```
import 'package:flutter/widgets.dart'; // подключаем базовый набор виджетов
// Когда Dart запускает приложение он вызывает функцию main()
main() => runApp( // а функция runApp запускает Flutter
Text( // этот виджет, он отрисовывает текст, такой себе
'Hello, World!!!', // первый аргумент — текст который нужно отобразить
textDirection: TextDirection.ltr, // а здесь мы указываем направление текста
),
);
```
[`runApp(…)`](https://docs.flutter.io/flutter/widgets/runApp.html) принимает единственный аргумент — виджет, который будет корневым для всего проекта. Кстати, его изменения Hot-reload подхватить не может, так что нужно будет перезапускать приложение.
[`Text(…)`](https://docs.flutter.io/flutter/widgets/Text-class.html) — Flutter не может просто отобразить строку на экране. Для вывода текста необходимо указать `Text`. `textDirection`. И это не выравнивание текста вроде [`text-align`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-align), если сравнивать с вебом, то это аналог [`direction`](https://developer.mozilla.org/en-US/docs/Web/CSS/direction). Часть API для интернационализации приложения. `Text` не заработает, пока не будет знать направление, но указывать его везде не придется — дальше мы разберем как настроить направление текста для всего приложения.
Уже запустили приложение? “Hello, World!” вывелся! Вроде бы… Да? Но что-то явно пошло не так.
Текст перекрыт системной информацией. В нашем распоряжении все пространство экрана, и мы вывели виджет в самом его начале, где в том числе выводится системная информация. Давайте попробуем куда-то подвинуть наш текст.
```
import 'package:flutter/widgets.dart';
main() => runApp(
Center( // виджет, который выравнивает содержимое по центру
child: Text(
'Hello, World!',
textDirection: TextDirection.ltr,
),
),
);
```
[`Center(…)`](https://docs.flutter.io/flutter/widgets/Center-class.html) — это виджет который позволяет разместить другой виджет, переданный в аргументе `child`, в центре по горизонтали и вертикали. Вы часто будете встречать `child` и `children` в приложениях Flutter, так как практически все виджеты используют эти имена для передачи виджетов, которые должны быть отрисованы внутри вызываемого виджета.
Композиции виджетов используются в Flutter для отрисовки UI, изменения внешнего вида, и даже для передачи данных. К примеру виджет [`Directionality(…)`](https://docs.flutter.io/flutter/widgets/Directionality-class.html) задает направление текста для всех дочерних виджетов:
```
import 'package:flutter/widgets.dart';
main() => runApp(
Directionality(
textDirection: TextDirection.ltr,
child: Center(
child: Text('Hello, World!'),
),
),
);
```
Посмотрим на еще один очень важный виджет и заодно преобразим внешний вид нашего приложения:
```
import 'package:flutter/widgets.dart';
main() => runApp(
Directionality(
textDirection: TextDirection.ltr,
child: Container( // новый виджет! в мире Flutter'а
// Для виджета Container свойство color означает цвет фона
color: Color(0xFF444444),
child: Center(
child: Text(
'Hello, World!',
style: TextStyle( // а у текста появился виджет, который его стилизует
color: Color(0xFFFD620A), // задаем ему цвет текста
fontSize: 32.0, // и размер шрифта
),
),
),
),
),
);
```
[`Color(…)`](https://docs.flutter.io/flutter/dart-ui/Color-class.html) — цвет. В документации указаны разные способы его задания, но основным является просто передача числа в конструктор класса. В примере выше мы передаем конструктору число, записанное в шестнадцетиричной форме, что очень похоже на HEX, только вначале у нас добавилось еще два знака, означающих степень прозрачности цвета, где 0x00 — это абсолютно прозрачный, а 0xFF — это совсем не прозрачный.
[`TextStyle(…)`](https://docs.flutter.io/flutter/dart-ui/TextStyle/TextStyle.html) — еще более интересный виджет, с его помощью можно задать цвет, размер, толщину, межстрочный интервал, добавить подчеркивание и прочее.
Приложение на Flutter написано, дело сделано! В доках можно почитать как его собрать под [Android](https://flutter.io/docs/deployment/android) и [iOS](https://flutter.io/docs/deployment/ios), там же есть ссылочки чтобы вы узнали как его отправить в нужный Store. Кому этого мало, я ниже накидал еще пару строк про Flutter, может больше…
Про Stateless виджеты
---------------------
Как использовать виджеты — мы разобрались, давайте теперь разбираться как их создавать. Выше уже упоминалось, что есть виджеты у которых есть состояние, и у которых его нет. До сих пор мы использовали только виджеты без состояния. Это не значит, что у них его совсем нет, ведь виджеты это просто классы, и их свойства могут быть изменены. Просто после того, как виджет будет отрисован — изменения его состояния не приведет к обновлению этого виджета в UI. К примеру, если нам нужно поменять текст на экране, нужно будет сгенерировать другой виджет `Text` и указать новое содержимое которое мы хотим отобразить. Такие виджеты можно назвать константными, если вы понимаете о чем я. И они простые, поэтому с них и начнем.
Чтобы создать Stateless виджет, нужно:
1. Придумать красивое имя для нового класса;
2. Унаследовать класс от `StatelessWidget`;
3. Реализовать метод `build()`, который принимает `BuildContext` в качестве аргумента и возвращает какой-нибудь `Widget`.
```
import 'package:flutter/widgets.dart';
main() => runApp(
Directionality(
textDirection: TextDirection.ltr,
child: Center(
child: MyStatelessWidget()
),
),
);
class MyStatelessWidget extends StatelessWidget {
// аннотация @override нужна для оптимизации, используя ее мы говорим,
// что переопределенный метод из родительского класса мы использовать
// не будем, так что компилятор может его выбросить
@override
Widget build(BuildContext context) { // [context] будет описан позже
return Text('Hello!');
}
}
```
Пример виджета с одним аргументом:
```
// …
class MyStatelessWidget extends StatelessWidget {
// Все свойства Stateless виджета должны быть объявлены с final, или с const
final String name; // обычное свойство
MyStatelessWidget(this.name); // обычный конструктор
@override
Widget build(BuildContext context) { // [context] будет описан еще ниже
return Text('Hello, $name!');
}
}
```
Про Stateless больше и добавить нечего…
Про Hot Reload
--------------
Обратите внимание, что при изменении содержимого нашего виджета приложение будет автоматически перерисовываться. После того, как мы вынесли виджет из функции `main()` Hot-reload стал нам помогать.
Важно также понимать, что из-за запущенного модуля для горячей замены приложение работает на порядок медленнее.
Про GestureDetector
-------------------
В следующей секции мы будем разбираться с `StatefulWidget` (с виджетами которые изменяются при изменении их состояния). Для того чтобы это было интересно, нам нужно это состояние как-то изменять, согласны? Мы будем изменять состояние виджета реагируя на касания по экрану. Для этого мы будем использовать [`GestureDetector(…)`](https://docs.flutter.io/flutter/widgets/GestureDetector-class.html) — виджет, который ничего не отрисовывает, но следит за касаниями на экране смартфона и сообщает об этом вызывая переданные ему функции.
Создадим кнопку в центре экрана, при нажатии на которую в консоль будет выводиться сообщение:
```
import 'package:flutter/widgets.dart';
main() => runApp(
Directionality(
textDirection: TextDirection.ltr,
child: Container(
color: Color(0xFFFFFFFF),
child: App(),
),
),
);
class App extends StatelessWidget {
@override
Widget build(BuildContext context) {
return Center(
child: GestureDetector( // используется как обычный виджет
onTap: () { // одно из свойств GestureDetector
// Этот метод будет вызван, когда дочерний элемент будет нажат
print('You pressed me');
},
child: Container( // нашей кнопкой будет контейнер
decoration: BoxDecoration( // стилизуем контейнер
shape: BoxShape.circle, // зададим ему круглую форму
color: Color(0xFF17A2B8), // и покрасим его в синий
),
width: 80.0,
height: 80.0,
),
),
);
}
}
```
Нажимаем на синюю кнопку и видим сообщение в консоли. Нажимаем еще раз и снова видим сообщение в консоли. Еще раз… Ладно, хватит залипать.
Про Stateful виджеты
--------------------
`StatefulWidget` — простые, даже проще чем `StatelessWidget`'ы. Но есть нюанс: они не существуют сами по себе, для их работы нужен еще один класс который будет хранить состояние этого виджета. При этом, его визуальная часть (виджеты из которых он состоит) также становятся его состоянием.
Для начала, посмотрим на класс виджета:
```
// …
class Counter extends StatefulWidget {
// Изменяемое состояние хранится не в виджете, а внутри объекта особого класса,
// создаваемого методом createState()
@override
State createState() => \_CounterState();
// Результатом функции является не просто объект класса State,
// а обязательно State<ИмяНашегоВиджета>
}
```
Выше мы создали “пустой” виджет, который реализовал очень простой метод `createState()`. Такое разделение презентации и состояния позволяет Flutter’у сильно оптимизировать работу приложения.
Объект состояния совершенно не сложный. Более того, он практически идентичен `StatelessWidget`'ам написанным нами выше. Его основное отличие — родительский класс.
```
// …
class _CounterState extends State {
// Внутри него мы наконец-то можем объявить динамические переменные,
// в которых мы будем хранить состояние.
// В данном случае, это счетчик количества нажатий
int counter = 0;
// А дальше все очень просто, мы имплементируем точно такой же метод
// для отрисовки виджетов, который мы использовали в классе Stateless виджета.
@override
Widget build(BuildContext context) {
// И тут практически ничего не изменилось с нашего последнего примера,
// а то что изменилось — я прокомментировал:
return Center(
child: GestureDetector(
onTap: () {
// В момент, когда кнопка нажата, мы увеличиваем значение
// перменной counter.
setState(() {
// setState() необходим для того, чтобы вызвать методы
// жизненного цикла виджета и сказать ему, что пора обновиться
++counter;
});
},
child: Container(
decoration: BoxDecoration(
shape: BoxShape.circle,
color: Color(0xFF17A2B8),
),
width: 80.0,
child: Center(
child: Text( // выводим значение свойства counter
'$counter', // чтобы следить за его изменением
style: TextStyle(fontSize: 30.0),
),
),
),
),
);
}
}
```
Обратите внимание, что имя класса начинается с нижнего подчеркивания. В Dart’е все имена начинающиеся с нижнего подчеркивания идентифицируют приватные значения. А состояние виджетов, в Flutter’е, принято оставлять приватными, хотя это не обязательно.
Какое замечательное приложение мы с вами сделали! Это отличный результат. Но перед тем как закончить эту часть курса, давайте рассмотрим еще пару интересных виджетов. Только в этот раз мы напишем больше кода, просто, чтобы было интереснее. Большая часть приложения должна быть вам знакома, а остальное вы уже должны были научиться понимать:
```
import 'package:flutter/widgets.dart';
main() => runApp(App());
class App extends StatelessWidget {
@override
Widget build(BuildContext context) {
return Directionality(
textDirection: TextDirection.ltr,
child: Container(
padding: EdgeInsets.symmetric(
vertical: 60.0,
horizontal: 20.0,
),
color: Color(0xFFFFFFFF),
child: Content(),
),
);
}
}
class Content extends StatelessWidget {
@override
Widget build(BuildContext context) {
return Column(
children: [
Counter('Manchester United'),
Counter('Juventus'),
],
);
}
}
class Counter extends StatefulWidget {
final String _name;
Counter(this._name);
@override
State createState() => \_CounterState();
}
class \_CounterState extends State {
int count = 0;
@override
Widget build(BuildContext context) {
return Container(
margin: EdgeInsets.only(bottom: 10.0),
padding: EdgeInsets.all(4.0),
decoration: BoxDecoration(
border: Border.all(color: Color(0xFFFD6A02)),
borderRadius: BorderRadius.circular(4.0),
),
child: Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
// widget — это свойство класса State, в котором хранится
// ссылка на объект создавший текущий стейт, то есть на наш виджет
\_CounterLabel(widget.\_name),
\_CounterButton(
count,
onPressed: () {
setState(() {
++count;
});
},
),
],
),
);
}
}
class \_CounterLabel extends StatelessWidget {
static const textStyle = TextStyle(
color: Color(0xFF000000),
fontSize: 26.0,
);
final String \_label;
\_CounterLabel(this.\_label);
@override
Widget build(BuildContext context) {
return Text(
\_label,
style: \_CounterLabel.textStyle,
);
}
}
class \_CounterButton extends StatelessWidget {
final \_count;
final \_onPressed;
\_CounterButton(this.\_count, {@required this.\_onPressed});
@override
Widget build(BuildContext context) {
return GestureDetector(
onTap: () {
\_onPressed();
},
child: Container(
padding: EdgeInsets.symmetric(horizontal: 6.0),
decoration: BoxDecoration(
color: Color(0xFFFD6A02),
borderRadius: BorderRadius.circular(4.0),
),
child: Center(
child: Text(
'$\_count',
style: TextStyle(fontSize: 20.0),
),
),
),
);
}
}
```
У нас появилось два новых виджета: [`Column()`](https://docs.flutter.io/flutter/widgets/Column-class.html) и [`Row()`](https://docs.flutter.io/flutter/widgets/Row-class.html). Попробуйте сами догадаться, что они делают. А в следующей статье мы рассмотрим их подробнее, а также посмотрим еще не один виджет позволяющий компоновать вместе другие виджеты, и создадим симпатичное приложение используя Flutter библиотеку называющуюся Material.
Про домашнее задание
--------------------
Если вам хочется почитать что-нибудь еще на досуге, вот список интересных ссылок:
* <https://flutter.io/docs/get-started/flutter-for/web-devs>
* Работа с кодом из [VS Code](https://flutter.io/docs/development/tools/ide/vs-code) и из [InteliJ](https://flutter.io/docs/development/tools/ide/android-studio)
* [Подробнее о виджетах](https://flutter.io/docs/development/ui/widgets-intro)
* Про [Hot reload](https://flutter.io/docs/development/tools/hot-reload) тоже нужно почитать, чтобы понимать когда код может не перезагрузится | https://habr.com/ru/post/430918/ | null | ru | null |
# Как мы внедряли INDE в наше Android приложение
Применение готовых библиотек в приложениях освобождает программистов от непроизводительного труда по изобретению велосипедов, сокращает время выхода приложения на рынок и благотворно сказывается на его функциональности. Все эти тезисы мы можем проиллюстрировать на своем собственном примере. В этой статье мы опишем процесс внедрения библиотеки Intel INDE ([Integrated Native Developer Experience](https://software.intel.com/en-us/intel-inde)) для работы с видео в Android в наше существующее приложение Together Video Camera, приведем примеры реализации функционала в соответствии с конкретными нуждами приложения и опишем сложности разработки до и после INDE.
#### Предыстория
Приложение Together мы начали делать в далеком 2012 году. Проект был в каком-то роде корпоративным хобби, так как большую часть времени мы работали на проектах наших клиентов, разрабатывая различные видео сервисы и приложения. Together задумывался как простой и удобный видео редактор с возможностями по организации видео библиотеки (все видео вместе с удобным доступом). Возможности по редактированию должны были быть максимально простыми, чтобы пользователям, незнакомым с концепциями видео редакторов, было удобно создавать короткометражные фильмы в кратчайшие сроки.
#### Разработка до внедрения INDE
В то время средств для работы с видео под Андроид практически ничего не было, а для чуть более интеллектуальной обработки видео требовалось погружение в C код. Всю обработку видео мы делали на основе ПО с открытым исходным кодом ffmpeg. Данный подход потребовал значительных инвестиций времени и сил разработчиков. После запуска мы узнали, что наша лаборатория тестовых устройств из дюжины девайсов крайне скудна, от пользователей приходили сотни разнообразных плохо документированных ошибок различных платформ. Развитие собственного клиентского видео SDK отнимало все больше времени от основного продукта, от улучшения User Experience. Надо было что-то делать.
#### Внедрение INDE
Новость об инструментарии INDE очень сильно нас заинтересовала. Мы случайно услышали о нем на конференции Droidcon 2014. Прежде всего, для нас были важны следующие возможности платформы:
* Транскодинг видео с различными параметрами
* Подрезка видео по заданному интервалу
* Склейка нескольких видео в одно
* Наложение аудио и видео эффектов
Даже эти несколько пунктов перекрывали с лихвой результаты нашей собственной разработки. С этого момента коренным образом изменился подход к проектированию функциональности нашего приложения. Теперь мы отталкивались не от того, **что мы можем дать пользователю**, а от того, **что бы пользователь хотел**.
Нам хватило нескольких дней, чтобы перевести уже существующий функционал на работу с библиотекой INDE. К примеру, для обрезки видеозаписи достаточно добавить сегмент при компоновке MediaComposer-а:
```
private void setTranscodeParameters(MediaComposer composer) throws IOException
{
composer.addSourceFile(inputFile);
composer.setTargetFile(outputFile);
configureVideoEncoder(composer, videoWidthOut, videoHeightOut);
configureAudioEncoder(composer);
MediaFile mediaFile = mediaComposer.getSourceFiles().get(0);
mediaFile.addSegment(new Pair((long)startCutTime, (long)endCutTime));
configureRotateEffect(composer);
}
```
Чтобы уменьшить видео перед отправкой на сервер, достаточно задать нужные размеры в параметрах MediaComposera перед началом транскодинга. Причем, даже если размеры будут не пропорциональны исходному видео, оно без проблем впишется в заданный прямоугольник:
```
private void configureVideoEncoder(MediaComposer composer, int outWidth, int outHeight)
{
VideoFormatAndroid videoFormat = new VideoFormatAndroid(videoMimeType, outWidth, outHeight);
videoFormat.setVideoBitRateInKBytes(videoBitRateInKBytes);
videoFormat.setVideoFrameRate(videoFrameRate);
videoFormat.setVideoIFrameInterval(videoIFrameInterval);
mediaComposer.setTargetVideoFormat(videoFormat);
}
```
Непростая в нашем понимании операция разворота видео с учетом мета-даты источника в терминологии INDE и вовсе значилась всего лишь как видео-эффект.
```
private void configureRotateEffect(MediaComposer composer)
{
if (rotation == 0) return;
IVideoEffect effect = new RotateEffect(rotation, factory.getEglUtil());
// добавляем эффект на всю длину видео
effect.setSegment(new Pair(0L, 0L));
composer.addVideoEffect(effect);
}
```
То есть, при желании в процессе транскодинга можно перевернуть только часть видео, так как эффект накладывается на определенный временной отрезок. Сложно представить, где это может пригодиться, но сама возможность почему-то радует.
Этими нескольким строчками кода мы перевели весь предыдущий функционал по работе с видео на библиотеку INDE. А дальше мы замахнулись на то, о чем раньше и мечтать не могли, а именно, создание целостного видеофайла альбома на устройстве пользователя.
Чтобы понимать о чем идет речь, альбом в Together — это набор пользовательских видео и фотографий, порядок которых легко настраивается на экране редактирования. Там же можно выбрать подходящий саундтрек и наложить его поверх всего видео ряда. Для особо важных видео-моментов мы оставили возможность сохранения оригинального звука с основным саундтреком на заднем фоне. Пример можно посмотреть [тут](https://www.2gzr.com/album/pg1Bx0).
Основное предназначение альбомов — это создание видео истории и быстрый шаринг в социальные сети. Так как для этого все равно нужно было бы залить видео в сеть, то еще на ранних этапах разработки было принято решение транскодить альбомы в облаке. Таким образом достигается единообразие процесса транскодинга и экономятся ресурсы девайса пользователя. Но затем мы обнаружили некоторые проблемы:
* Во-первых, не удавалось добиться плавного воспроизведения альбома на устройстве, пока он еще не был оттранскодирован. Приходилось составлять плейлист из отдельных видео-элементов и воспроизводить их последовательно. Причем каждый элемент требовал соблюдения workflow работы с MediaPlayer. Так, время необходимое на prepare() негативно сказывалось на общем впечатлении от видео, поскольку были заметны небольшие остановки между частями альбома. Кроме того, нужно учитывать, что работа MediaPlayer существенно различается в зависимости от устройства.
* Во-вторых, пользователям было тяжело подстраивать видеоряд под музыку. Если на устройстве удавалось добиться идеального результата, то на сервере после транскодинга смена элементов плейлиста происходила быстрее и музыка уже не ложилась так, как это задумывалось.
* В-третьих, было проблемно воспроизводить изображения. Приходилось просто отображать статичную картинку определенной длительности поверх MediaPlayer. Опять же это не соотносилось с финальным видео на сервере после транскодинга, так как там еще добавлялась анимация.
Соответственно, если дополнительно транскодить альбом на устройстве при каждом изменении порядка видео, это решило бы все проблемы, и пользователь смог бы видеть если не абсолютно точный, то очень близкий вариант итогового фильма. Эта возможность бывает особенно полезной, если составление и редактирование альбома полностью происходит в offline, когда просто невозможно зайти на сайт и увидеть результат. Решить подобную задачу при помощи ffmpeg и, главное, добиться одинаково работающего результата на всех устройствах было бы очень тредоемко и затратно по времени. С INDE на это потребовалось не больше одной человеко-недели.
#### Транскодинг альбомов
Несмотря на то, что процесс инициализации MediaComposer довольно гибкий и простой, в нашем случае потребовались некоторые предварительные действия. В частности, до склеивания альбома необходимо преобразовать все изображения в видео. Для этого по совету разработчиков из INDE мы добавили в приложение 30ти секундный “пустой” видео-файл (80 kb), на который накладывали JpegSubstitudeEffect и обрезали до нужной длительности. Если необходимо не просто статично отображать фотографию несколько секунд, то можно наследовать JpegSubstitudeEffect и преобразовывать координаты фотографии в каждом фрейме так, чтобы получалась некоторая кастомная анимация.
Неприятной неожиданностью стал тот факт, что оказалось невозможно запустить несколько команд проеобразования фото в видео в параллельных потоках одновременно. Существет ограничение на количество одновременных инстансов MediaComposer-a, и для каждого устройства оно свое. К примеру, на устройствах Samsung не удавалось запустить более 3х инстансов. В связи с этим, пришлось преобразовывать изображения последовательно, что довольно продолжительно по времени.
Точно такую же подготовительную работу придется совершать для любых видео/аудио эффектов, а также если необходимо обрезать какие-то видео до склейки. Соответственно, все это нужно заранее архитектурно продумать. После того, как подготовительная работа закончена, сама склейка происходит очень просто:
```
@Override
protected void setTranscodeParameters() throws IOException
{
String firstPath = playlist.get(0).localPath;
Uri firstMediaUri = new Uri(firstPath);
mediaComposer.addSourceFile(firstMediaUri);
mediaComposer.setTargetFile(dstMediaPath);
configureVideoEncoder(mediaComposer, videoWidthOut, videoHeightOut);
configureAudioEncoder(mediaComposer);
// add source files in cycle
Uri nextUri = null;
for (int i = 1; i < playlist.size(); i++)
{
nextUri = new Uri(playlist.get(i).localPath);
mediaComposer.addSourceFile(nextUri);
}
}
```
#### Чего не удалось добиться
Чтобы полностью повторить на устройстве результат транскодинга альбомов в облаке следовало бы также иметь возможность добавлять саундтрек поверх склеенного видео. В текущей версии библиотеки этого сделать пока не удалось из-за некоторых проблем с SubstituteAudioEffect, которые сейчас активно обсуждаются с разработчиками. Поэтому пока что звуковая дорожка в приложении реализована отдельным плеером, синхронизированным с видео дорожкой по времени.
Как следствие, есть еще один функционал, который мы пока не можем релизовать — это эффект оригинального аудио для некоторых видео в альбоме. Это должно выглядеть следующим образом: несколько видео роликов в альбоме воспроизводятся с наложенным саундтреком и звука самого видео не слышно, а затем саундтрек затихает и становится слышно, к примеру, о чем говорят люди на видео, затем саундтрек снова включается на полную громкость и продолжается воспроизведение. Опять же ждем с нетерпением обновления, чтобы поиграть с этим функционалом.
#### Производительность
Перед тем как решиться транскодить видео на устройстве перед нами встал основной вопрос: насколько это будет затратно для пользователей по ресурсам. Мы провели несколько тестов на имеющихся устройствах, измеряя время, необходимое на операцию, и затраты батарейки. Результаты приведены ниже.
#### В итоге, если кратко
Процесс обработки видео на устройстве до и после внедрения INDE отличается как небо и земля. Обычно при переходе с инструментов более низкого уровня на более высокого программист оказывается ограничен теми возможностями, которые ему предоставляет высокоуровневая библиотека. В случае с INDE все совсем не так, напротив, возможностей стало больше и для их реализации требуется существенно меньше времени. Для разработчика остается только самая приятная часть — продумывать архитектуру, улучшать UI и кастомизировать видео или аудио эффекты. Больше никакого погружения в С код, работы с муксерами и демуксерами и неожиданных результатов в зависимости от конкретного устройства.
Конечно остаются некоторые моменты, которые хотелось бы улучшить и исправить, но надо отдать должное разработчикам Intel, они с удовольствием выслушивают такие пожелания и оперативно вносят поправки.
#### Полезные источники
В статье специально показаны очень короткие примеры, так как на сайте Intel вы можете найти полноценные и понятные исходники. [software.intel.com/en-us/articles/intel-inde-media-pack-for-android-tutorials](https://software.intel.com/en-us/articles/intel-inde-media-pack-for-android-tutorials) | https://habr.com/ru/post/236833/ | null | ru | null |
# HMI на основе Node-red и Scadavis.io
В связи с ростом популярности концепции IoT и развитием сопутствующих технологий многие производители программного обеспечения для промышленной автоматизации используют эти подходы в своих продуктах. Доступ к SCADA-системам через web-интерфейс — идея не новая. Еще лет 10 назад Citect SCADA позволяла это делать с помощью веб-браузера IE. Но идея IoT — это не только доступ к ресурсам через web, но также возможность агрегировать целый ряд сетевых проводных и беспроводных интерфейсов, совмещать различные уровни архитектуры: field, edge, cloud. В поисках возможных решений использования совместной open-source IoT edge платформы и [SCADA](https://ru.wikipedia.org/wiki/SCADA) системы я наткнулся на интересную связку платформы Node-red и SCADA-фреймворк [scadavis.io](https://scadavis.io/)
### Scadavis.io
Начну описание scadavis с той информации, которая представлена в официальных источниках. На странице сайта [scadavis.io](https://scadavis.io/) указано: «Powerful SCADA-like visualization tools, free-form synoptic graphics for real-time data display. A pure HTML5 solution, mobile friendly, framework agnostic, with no special server requirements needed. All your data and graphics stay on your servers and clients.» (Мощные SCADA-подобные инструменты визуализации, сводные графики произвольной формы для отображения данных в реальном времени. Чистое решение HTML5, мобильное, независимое от фреймворка, без особых требований к серверу. Все ваши данные остаются на ваших серверах и клиентах.)
Далее представлены примеры страниц, которые можно спроектировать.
Затем идет информация о графическом редакторе построения экранных страниц SCADAvis.io Synoptic Editor, который можно преобрести в Microsoft Store.
Также на сайте представлена таблица с планами использования Scadavis.io. Их три: Basic, Pro, Enterprise. Основные характеристики Basic-плана: бесплатный, нет технической поддержки, исходный код расположен на SCADAvis.io.
Дисклеймер – в данном абзаце я хочу показать файловую структуру проекта, которую мне было любопытно увидеть. Это никоим образом не призывает нарушать лицензионные права данной системы. Тем более список файлов легко просматривается с помощью инструментов разработчика в консоли браузера.
**На момент исследования набор файлов был следующий:**
* Основной скрипт synopticapi.js, в котором орпеделена функция основного объекта для работы с svg страницами – находится на ресурсе scdavis.io.
* На этом же ресурсе расположены скрипты symbol\_webreflection.js, содержащий функции для работы с символами и их свойствами.
* А также, насколько я понимаю, две проприетарные обфусцированные библиотеки o1.js и o2.js. Детально разбираться в них я не стал, так как особо времени и желания не было.
* Фреймом для подключения библиотек и отображения визуализации служит synoptic.html файл, расположенный там же.
Подключение скрипта проекта, документация API и Synoptic Editor представлены на ресурсе [scadavis.io/learn.html](https://scadavis.io/learn.html)
**Далее проект содержит ряд open source библиотек для работы с svg, с различной визуализацией и графиками:**
* Vega-min.js, vega-lite.js — [vega.github.io/vega](https://vega.github.io/vega/) С помощью Vega вы можете описать внешний вид и интерактивное поведение визуализации в формате JSON, а также создавать веб-представления с использованием Canvas или SVG.
* snap.svg-min.js [snapsvg.io](http://snapsvg.io/) SVG – позволяет создавать интерактивную, независимую от разрешения векторную графику, которая будет отлично смотреться на экране любого размера.
* jquery.min.js [jquery.com](https://jquery.com/) jQuery — это быстрая, небольшая и многофункциональная библиотека JavaScript.
* d3.js — [d3js.org](https://d3js.org/) Сочетает мощные компоненты визуализации и управляемый данными подход к манипулированию DOM.
* chroma.min.js — [gka.github.io/chroma.js](https://gka.github.io/chroma.js/) Это небольшая библиотека JavaScript без внешних зависимостей для всех видов преобразования цветов и цветовых шкал.
### Node-red
Node-red – чрезвычайно популярная платформа. На просторах сети есть огромное количество статей и видеороликов о ней. На [wikihandbk.com](http://wikihandbk.com/) следующее определение: Node-RED – это инструмент визуального программирования для интернета вещей, позволяющий подключать друг к другу устройства, API и онлайн-сервисы. Сами авторы позиционируют Node-red как IoT edge платформу:
**Установка данной платформы также не составляет труда на различный операционных системах и состоит из двух шагов:**
* Установка Node.js: [nodejs.org](https://nodejs.org/)
* Установка Node-red: npm install -g --unsafe-perm node-red
В блоге [Ricardo Olsen](https://ricolsen1supervc.wordpress.com/)n показаны шаги по интеграции системы Scadavis.io и платформы Node-red, а также представлены исходные файлы экранных страниц формата svg. Автор рекомендует использовать плагин для Node-red — [node-red-contrib-uibuilder](https://flows.nodered.org/node/node-red-contrib-uibuilder), который позволяет создавать динамический веб-интерфейс с помощью различных js-библиотек, а также использовать веб-фреймворк VueJS.
Однако это не единственный способ, позволяющий построить пользовательский интерфейс на базе Node-red. Имеется достаточно популярный модуль, содержащий ряд нод для создания дашбордов в реальном времени от создателей самой платформы [node-red-dashboard](https://flows.nodered.org/node/node-red-dashboard).
Виджет Template может содержать любые допустимые директивы html и Angular/Angular-Material. Этот узел можно использовать для создания динамического элемента пользовательского интерфейса, который изменяет свой внешний вид на основе входящего сообщения и может отправлять сообщения обратно в Node-RED. С помощью ноды Template можно создать объект экранной страницы Scadavis, задать необходимые свойства, эмулировать поведение объекта и связать теги (переменные) экранной страницы с внешней средой
**Создание SCADA-страницы с помощью Template виджета**
```
var office = new scadavis({
container: "office", //Указание созданного ранее контейнера
iframeparams: 'frameborder="0" height="610" width="687"',
svgurl: "drawing.svg" //SVG страница
});
office.zoomTo(0.82); //Масштабирование изображения
//Эмуляция поведения тегов
setInterval(function () {
office.storeValue("TAG2", 100 + Math.random() \* 80);
office.storeValue("TAG3", 120 + Math.random() \* 60);
office.storeValue("TAG4", 150 + Math.random() \* 60);
office.storeValue("TAG5", 110 + Math.random() \* 30);
office.storeValue("TAG6", 200 + Math.random() \* 100);
office.storeValue("TAG7", 130 + Math.random() \* 40);
office.updateValues();
value = 130 + Math.random() \* 40;
}, 5000);
```
В статье [Node-RED Dashboard Template Examples (AngularJS)](https://it.knightnet.org.uk/kb/nr-qa/dashboard-template-examples/) хорошо показаны примеры взаимодействия ноды Template с другими нодами, которые обмениваются сообщениями msg в контексте Angular Scope.
Допустим, мы хотим в качестве свойства объекта msg.topic передавать имя тега, а в качестве значения msg.payload. И при каждом изменении объекта msg обновляем объект SCADA с помощью методов storeValue и updateValues
```
(function(scope) {
scope.$watch('msg', function(msg) {
if (msg)
office.storeValue(msg.topic, msg.payload);
office.updateValues();
}
});
})(scope);
```
**Также используя пример с ресурса https://scadavis.io/learn.html и функционал ноды Template можно обрабатывать различные события SCADA-объекта и передавать их другим нодам, например так:**
```
(function(scope) {
substationsynoptic.on("click", function (event, tag) {
var v = substationsynoptic.getValue(tag);
if (event.currentTarget.id === "TAPUP")
substationsynoptic.setValue(tag, v + 1, false, false);
else
if (event.currentTarget.id === "TAPDOWN")
substationsynoptic.setValue(tag, v - 1, false, false);
if (event.currentTarget.id === "XCBROPEN")
substationsynoptic.setValue(tag, false, false, false);
else
if (event.currentTarget.id === "XCBRCLOSE")
substationsynoptic.setValue(tag, true, false, false);
if (v === true)
substationsynoptic.setValue(tag, false, false, false);
else
if (v === false)
substationsynoptic.setValue(tag, true, false, false);
scope.send( {'payload':{ 'tag': tag, 'value': v }} );
});
})(scope);
```
### Графический редактор
Как уже упоминалось выше, на официальном сайте предлагается приобрести SCADAvis.io Synoptic Editor для построения визуальных страниц SCADA-системы. Однако это не единственный возможный вариант. Как известно из самого описания, редактор построен на базе Inkscape SVG Editor. Практически — это Inkscape с плагином позволяющий назначать теги (переменные) и другие свойства различным графическим компонентам svg файла. То есть для простого отображения в контексте scadavis странице достаточно иметь svg файл, который можно редактировать в любом удобном редакторе. Но это еще не все. Есть большое сходство между редактором компании ECAVA INTEGRAXOR [www.integraxor.com](https://www.integraxor.com/) Inkscape 0.91 SAGE 4.16, который распостраняют бесплатно (необходимо только зарегистрироваться на сайте) и Synoptic Editor. Как в итоге оказалось, действительно возможно создавать и редактировать svg файлы для Scadavis, используя Inkscape 0.91 SAGE 4.16. Разница наблюдается при проектировании скриптовой анимации и некоторых других специфических вещах, которые отсутствуют в Object properties редактора SAGE.
Согласно описанию [SCADAvis.io Synoptic Editor](https://scadavis.io/scadaviseditor.docx.html#h.v5p3jxw8bpsa), для того чтобы назначить цвет объектов по условию включения, необходимо в колонке Limit указать цифру 2:
* 0 – not initialized state
* 1 – false (off) state
* 2 – true (on) state
* 129 – false (off) state plus failed value
* 130 – true (on) state plus failed value
### Плагин для работы с PLC Siemens
В арсенале Node-red имеется плагин для работы с PLC Siemens — [node-red-contrib-s7](https://flows.nodered.org/node/node-red-contrib-s7), основанный на фреймворке [nodeS7](https://github.com/plcpeople/nodeS7). Плагин достаточно прост и интуитивно понятен. Он содержит три ноды: S7 in, S7 out, S7 control. В основном используются первые две ноды для чтения и записи тегов в PLC. Один нюанс, который нужно учитывать при работе с S7-1200, описан в документации к плагину. Я с этим сталкнулся ранее, когда использовал библиотеку [Snap7](http://snap7.sourceforge.net/)
Необходимы некоторые дополнительные шаги настройки в ПЛК:
**«Optimized block access» должен быть отключен для тех DB блоков, к которым мы хотим получить доступ**
**В разделе «Защита» свойств ЦП установите флажок «Разрешить доступ с помощью PUT / GET»**
### Краткое заключение
Преимущества использования Node-red в качестве Web-SCADA подобной системы очевидны. Node-red – популярная open-source IoT платформа, имеющая огромное сообщество, множество различных плагинов и решений, возможность интегрировать различные протоколы. На ресурсе [support.industry.siemens](https://support.industry.siemens.com/tf/ww/en/posts/s7-communication-with-node-red/159131/?page=0&pageSize=10) также есть мануал по использованию Node-red и обсуждение использования платформы. SCADA-фреймворк типа [scadavis.io](https://scadavis.io/) является удачным примером интеграции хорошо известного среди специалистов подхода визуализации — SCADA-систем и IoT edge платформы. | https://habr.com/ru/post/507748/ | null | ru | null |
# Эволюция конфигурации .NET
Каждый программист представлял — ну или может хочет представить — себя пилотом самолета, когда у тебя есть огромный проект, к нему огромная панель датчиков, метрик и переключателей, с помощью которых можно легко настроить всё как надо. Ну, по крайней мере, не бежать самому поднимать шасси вручную. И метрики, и графики — это всё хорошо, но сегодня хочу рассказать про те самые тумблерочки и кнопочки, которые могут менять параметры поведения самолета, конфигурировать его.
Важность конфигураций сложно недооценить. Все используют те или иные подходы в конфигурировании своих приложений, и в принципе ничего сложного в этом нет, но так ли всё просто? Предлагаю посмотреть на «до» и «после» в конфигурации и разобраться в деталях: как что работает, какие новые возможности у нас есть и как ими пользоваться в полной мере. Кто не знаком с конфигурированием в .NET Core — получат основы, а кто знаком — получат пищу для обдумывания и использования новых подходов в своей ежедневной работе.
Конфигурация до .NET Core
-------------------------
В 2002 году был представлен .NET Framework, и так как это было время хайпа XML, разработчики из Microsoft решили «а давайте он будет везде», и как результат — мы получили XML-конфигурации, которые живы и сейчас. Во главе стола у нас статический класс ConfigurationManager, через который мы получаем строковые представления значений параметров. Сама же конфигурация выглядела примерно вот так:
```
xml version="1.0" encoding="utf-8" ?
```
Задача была решена, разработчики получили вариант настройки, при этом лучше, чем INI файлы, но со своими особенностями. Так, для примера, поддержка разных значений настроек для разных видов окружений приложения реализуется с помощью XSLT-трансформаций файла конфигурации. Мы можем определять свои XML-схемы для элементов и атрибутов, если хотим что-то более сложное в плане группировки данных. Пары ключ-значение имеют строго строковый тип, и если нам необходимо число либо дата, то «тут давай как-то сам»:
```
string title = ConfigurationManager.AppSettings["Title"];
int maxPage = int.Parse(ConfigurationManager.AppSettings["MaxPage"]);
```
В 2005 году добавили [секции конфигураций](https://docs.microsoft.com/en-us/dotnet/framework/configure-apps/file-schema/sectiongroup-element-for-configsections), они позволяли группировать параметры, строить свои схемы, избежать конфликтов именования. Также представили \*.settings файлы и специальный дизайнер для них.
Появилась возможность получать сгенерированный, строго типизированный класс, который представляет данные конфигурации. Дизайнер позволяет удобно редактировать значения, доступна сортировка по колонкам редактора. Получение данных происходит с помощью свойства Default сгенерированного класса, которое предоставляет Singleton объект конфигурации.
```
DateTime date = Properties.Settings.Default.CustomDate;
int displayItems = Properties.Settings.Default.MaxDisplayItems;
string name = Properties.Settings.Default.ApplicationName;
```
Также добавили области применения значений параметров конфигурации. Область User отвечает за данные пользователя, которые могут быть им изменены и сохранены во время исполнения программы. Сохранение происходит в отдельный файл по пути %AppData%\\*Название приложения\*. Область Application позволяет получать значения параметров без возможности переопределения пользователем.
Несмотря на благие намерения, всё в целом стало словно сложнее.
* По факту это те же XML-файлы, которые стали быстрее разрастаться в объемах и, как следствие, их стало неудобно читать.
* Конфигурация читается из XML-файла один раз, и для применения изменений данных конфигурации нам необходимо перезагружать приложение.
* Классы, сгенерированные из \*.settings-файлов, помечались модификатором sealed, поэтому нельзя было унаследовать этот класс. Кроме того, этот файл можно было изменить, но если происходит перегенерация — мы теряем всё, что писали сами.
* Работа с данными только по схеме ключ-значение. Для получения структурного подхода в работе с конфигурациями нам необходимо дополнительно реализовывать это самостоятельно.
* Источником данных может быть только файл, внешние провайдеры не поддерживаются.
* Плюс, мы имеем человеческий фактор — приватные параметры попадают в систему контроля версий и становятся раскрытыми.
Все эти проблемы остаются в .NET Framework и по сей день.
Конфигурация в .NET Core
------------------------
В .NET Core конфигурирование переосмыслили и создали всё с нуля, убрали статический класс ConfigurationManager и решили множество проблем, что были «до». Что же мы получили нового? Как и было ранее — этап формирования данных конфигурации и этап потребления этих данных, но с более гибким и расширенным жизненным циклом.
### Настройка и наполнение данными конфигурации
Так, для этапа формирования данных мы можем использовать множество источников, не ограничивая себя только файлами. Настройка конфигурации происходит через IConfgurationBuilder — основу, в которую мы можем добавлять источники данных. Доступны NuGet пакеты для различных типов источников:
| | | |
| --- | --- | --- |
| Формат | Метод расширения для добавления в IConfigurationBuilder источника | NuGet пакет |
| JSON | AddJsonFile | [Microsoft.Extensions.Configuration.Json](https://www.nuget.org/packages/Microsoft.Extensions.Configuration.Json) |
| XML | AddXmlFile | [Microsoft.Extensions.Configuration.Xml](https://www.nuget.org/packages/Microsoft.Extensions.Configuration.Xml) |
| INI | AddIniFile | [Microsoft.Extensions.Configuration.Ini](https://www.nuget.org/packages/Microsoft.Extensions.Configuration.Ini) |
| Аргументы командной строки | AddCommandLine | [Microsoft.Extensions.Configuration.CommandLine](https://www.nuget.org/packages/Microsoft.Extensions.Configuration.CommandLine) |
| Переменные окружения | AddEnvironmentVariables | [Microsoft.Extensions.Configuration.EnvironmentVariables](https://www.nuget.org/packages/Microsoft.Extensions.Configuration.EnvironmentVariables) |
| Пользователь- ские секреты | AddUserSecrets | [Microsoft.Extensions.Configuration.UserSecrets](https://www.nuget.org/packages/Microsoft.Extensions.Configuration.UserSecrets) |
| KeyPerFile | AddKeyPerFile | [Microsoft.Extensions.Configuration.KeyPerFile](https://www.nuget.org/packages/Microsoft.Extensions.Configuration.KeyPerFile) |
| Azure KeyVault | AddAzureKeyVault | [Microsoft.Extensions.Configuration.AzureKeyVault](https://www.nuget.org/packages/Microsoft.Extensions.Configuration.AzureKeyVault) |
Каждый источник добавляется как новый слой и переопределяет параметры по совпадающим ключам. Вот пример Program.cs, который идет по умолчанию в шаблоне ASP.NET Core приложения (версия 3.1).
```
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args).ConfigureWebHostDefaults(webBuilder =>
{ webBuilder.UseStartup(); });
```
Основной фокус хочу обратить на [CreateDefaultBuilder](https://github.com/dotnet/aspnetcore/blob/5f7e1a0004a8215b1c5b5bfb0f7fac5335f9b942/src/DefaultBuilder/src/WebHost.cs#L156). Внутри метода мы увидим, как происходит первоначальная настройка источников.
```
public static IWebHostBuilder CreateDefaultBuilder(string[] args)
{
var builder = new WebHostBuilder();
...
builder.ConfigureAppConfiguration((hostingContext, config) =>
{
IHostingEnvironment env = hostingContext.HostingEnvironment;
config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
if (env.IsDevelopment())
{
Assembly appAssembly = Assembly.Load(new AssemblyName(env.ApplicationName));
if (appAssembly != null)
{
config.AddUserSecrets(appAssembly, optional: true);
}
}
config.AddEnvironmentVariables();
if (args != null)
{
config.AddCommandLine(args);
}
})
...
return builder;
}
```
Так мы получаем, что базой для всей конфигурации будет appsettings.json файл; дальше, если имеется файл для конкретного окружения, то он будет иметь более высокий приоритет, и тем самым переопределит совпадающие значения базового. И так с каждым последующим источником. Порядок добавления влияет на финальное значение. Визуально всё выглядит вот так:
Если вы хотите использовать свой порядок, то его можно просто очистить и определить, как нужно вам.
```
Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(webBuilder => { webBuilder.UseStartup(); })
.ConfigureAppConfiguration((context,
builder) =>
{
builder.Sources.Clear();
//Свой порядок источников
});
```
Каждый источник конфигурации состоит из двух частей:
* Реализация IConfigurationSource. Предоставляет источник значений конфигурации.
* Реализация IConfigurationProvider. Конвертирует исходные данные в результирующие ключ-значение.
Реализовав эти компоненты, мы можем получить собственный источник данных для конфигурации. Вот [пример](https://gist.github.com/d2funlife/fce02e3898755da5339668a0b53192ba) того, как можно реализовать получение параметров из базы данных через Entity Framework.
### Как использовать и получать данные
Теперь, когда всё ясно с настройкой и наполнением данными конфигурации, предлагаю взглянуть, как мы можем использовать эти данные и как удобнее их получать. В новом подходе конфигурирования проектов делается большой уклон на популярный формат JSON, и это не удивительно, ведь с его помощью мы можем строить любые структуры данных, группировать данные и иметь при этом удобочитаемый файл. Возьмем для примера файл конфигурации следующего вида:
```
{
"Features" : {
"Dashboard" : {
"Title" : "Default dashboard",
"EnableCurrencyRates" : true
},
"Monitoring" : {
"EnableRPSLog" : false,
"EnableStorageStatistic" : true,
"StartTime": "09:00"
}
}
}
```
Все данные формируют словарь ключ-значение плоского вида, ключ конфигурации формируется из всей иерархии ключей файла для каждого значения. Подобная структура будет иметь следующий набор данных:
| | |
| --- | --- |
| Features:Dashboard:Title | Default dashboard |
| Features:Dashboard:EnableCurrencyRates | true |
| Features:Monitoring:EnableRPSLog | false |
| Features:Monitoring:EnableStorageStatistic | true |
| Features:Monitoring:StartTime | 09:00 |
Получить значение мы можем с помощью объекта [IСonfiguration](https://docs.microsoft.com/ru-ru/dotnet/api/microsoft.extensions.configuration.iconfiguration). Для примера, вот как мы можем получить параметры:
```
string title = Configuration["Features:Dashboard:Title"];
string title1 = Configuration.GetValue("Features:Dashboard:Title");
bool currencyRates = Configuration.GetValue("Features:Dashboard:EnableCurrencyRates");
bool enableRPSLog = Configuration.GetValue("Features:Monitoring:EnableRPSLog");
bool enableStorageStatistic = Configuration.GetValue("Features:Monitoring:EnableStorageStatistic");
TimeSpan startTime = Configuration.GetValue("Features:Monitoring:StartTime");
```
И это уже неплохо, у нас есть хороший способ получить данные, которые приведены к необходимому типу данных, но как-то не так круто, как хотелось бы. Если получать данные, как приведено выше, то мы в итоге будем иметь повторяющийся код, допускать ошибки в названии ключей. Вместо отдельных значений можно собрать полноценный объект конфигурации. В этом нам поможет привязка данных к объекту через метод Bind. Пример класса и получения данных:
```
public class MonitoringConfig
{
public bool EnableRPSLog { get; set; }
public bool EnableStorageStatistic { get; set; }
public TimeSpan StartTime { get; set; }
}
var monitorConfiguration = new MonitoringConfig();
Configuration.Bind("Features:Monitoring", monitorConfiguration);
var monitorConfiguration1 = new MonitoringConfig();
IConfigurationSection configurationSection = Configuration.GetSection("Features:Monitoring");
configurationSection.Bind(monitorConfiguration1);
```
В первом случае мы привязываем по названию секции, а во втором получаем секцию и привязываем уже из нее. Секция позволяет работать с частичным представлением конфигурации — так можно контролировать набор данных, с которым мы работаем. Секции также используются в стандартных методах расширения — так, получение строки подключения использует секцию «ConnectionStrings».
```
string connectionString = Configuration.GetConnectionString("Default");
public static string GetConnectionString(this IConfiguration configuration, string name)
{
return configuration?.GetSection("ConnectionStrings")?[name];
}
```
### Options — типизированное представление конфигурации
Создание объекта конфигурации вручную и привязка к данным — непрактично, но есть решение в виде использования [Options](https://docs.microsoft.com/ru-ru/aspnet/core/fundamentals/configuration/options). Options служат для получения строго типизированного представления конфигурации. Класс представления должен быть публичным с конструктором без параметров и публичными свойствами для присвоения значения, объект наполняется через рефлексию. Подробнее можно рассмотреть в [исходниках](https://github.com/dotnet/runtime/blob/master/src/libraries/Microsoft.Extensions.Configuration.Binder/src/ConfigurationBinder.cs#L179).
Для начала использования Options нам необходимо зарегистрировать тип конфигурации с использованием метода расширения Configure для IServiceCollection с указанием секции, которую мы будем проецировать на наш класс.
```
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
services.Configure(Configuration.GetSection("Features:Monitoring"));
}
```
После этого мы можем получать конфигурации посредством внедрения зависимости на интерфейсы IOptions, IOptionsMonitor, IOptionsSnapshot. Сам объект MonitoringConfig мы можем получить у интерфейса IOptions через свойство Value.
```
public class ExampleService
{
private IOptions \_configuration;
public ExampleService(IOptions configuration)
{
\_configuration = configuration;
}
public void Run()
{
TimeSpan timeSpan = \_configuration.Value.StartTime; // 09:00
}
}
```
Особенностью интерфейса IOptions является то, что в контейнере внедрения зависимостей конфигурация регистрируется как объект с жизненным циклом Singleton. При первом запросе значения по свойству Value инициализируется объект с данными, которые существуют, пока существует этот объект. IOptions не поддерживает обновление данных. Для поддержки обновлений есть интерфейсы IOptionsSnapshot и IOptionsMonitor.
IOptionsSnapshot в контейнере внедрения зависимостей регистрируется с жизненным циклом Scoped, что дает уже возможность получать новый объект конфигурации на запрос с новой областью контейнера. Для примера, в течение одного веб-запроса мы будем получать один и тот же объект, но для нового запроса мы получим уже новый объект с обновлёнными данными.
IOptionsMonitor регистрируется как Singleton, только с той разницей, что каждое получение конфигурации происходит с актуальными данными на момент запроса. Помимо этого, IOptionsMonitor позволяет зарегистрировать обработчик события изменения конфигурации, если необходимо реагировать на само событие изменения данных.
```
public class ExampleService
{
private IOptionsMonitor \_configuration;
public ExampleService(IOptionsMonitor configuration)
{
\_configuration = configuration;
configuration.OnChange(config =>
{
Console.WriteLine("Конфигурация изменилась");
});
}
public void Run()
{
TimeSpan timeSpan = \_configuration.CurrentValue.StartTime; // 09:00
}
}
```
Также есть возможность получать IOptionsSnapshot и IOptionsMontitor по имени — это необходимо, если у вас одному классу может соответствовать несколько секций конфигурации, и вы хотите получить конкретную. Для примера, у нас есть вот такие данные:
```
{
"Cache": {
"Main": {
"Type": "global",
"Interval": "10:00"
},
"Partial": {
"Type": "personal",
"Interval": "01:30"
}
}
}
```
Тип, который будет использоваться для проекции:
```
public class CachePolicy
{
public string Type { get; set; }
public TimeSpan Interval { get; set; }
}
```
Регистрируем конфигурации с указанием конкретного имени:
```
services.Configure("Main", Configuration.GetSection("Cache:Main"));
services.Configure("Partial", Configuration.GetSection("Cache:Partial"));
```
Получать значения мы можем следующим образом:
```
public class ExampleService
{
public ExampleService(IOptionsSnapshot configuration)
{
CachePolicy main = configuration.Get("Main");
TimeSpan mainInterval = main.Interval; // 10:00
CachePolicy partial = configuration.Get("Partial");
TimeSpan partialInterval = partial.Interval; // 01:30
}
}
```
Если посмотреть в исходники метода расширения, которым мы регистрируем тип конфигурации, то можно увидеть, что по умолчанию используется имя Options.Default, которое является пустой строкой. Так что неявно мы всегда передаем имя для конфигураций.
```
public static IServiceCollection Configure(this IServiceCollection services, IConfiguration config) where TOptions : class
=> services.Configure(Options.Options.DefaultName, config);
```
Поскольку конфигурация может быть представлена классом, мы также можем добавить валидацию значений параметров — для этого надо разметить свойства с помощью атрибутов валидации из пространства имен System.ComponentModel.DataAnnotations. Например, укажем, что значение для свойства Type должно быть обязательным. Но также нам необходимо указать при регистрации конфигурации, что валидация должна происходить в принципе. Для этого есть метод расширения ValidateDataAnnotations.
```
public class CachePolicy
{
[Required]
public string Type { get; set; }
public TimeSpan Interval { get; set; }
}
services.AddOptions()
.Bind(Configuration.GetSection("Cache:Main"))
.ValidateDataAnnotations();
```
Особенность такой валидации в том, что она произойдет только в момент получения объекта конфигурации. Это затрудняет возможность понять, что конфигурация не валидна при старте приложения. Для этой проблемы существует [задача на GitHub](https://github.com/dotnet/runtime/issues/36391). Одним из решений подобной проблемы может послужить подход, представленный в статье [Adding validation to strongly typed configuration objects in ASP.NET Core.](https://andrewlock.net/adding-validation-to-strongly-typed-configuration-objects-in-asp-net-core/)
### Недостатки Options и как их обойти
Конфигурация через Options также имеет свои недостатки. Для использования нам необходимо добавлять зависимость, и каждый раз для получения объекта значения нам необходимо обращаться к свойству Value/CurrentValue. Добиться более чистого кода можно посредством получения чистого объекта конфигурации без обертки Options. Самым простым вариантом решения проблемы может быть дополнительная регистрация в контейнере зависимости чистого типа конфигурации.
```
services.Configure(Configuration.GetSection("Features:Monitoring"));
services.AddScoped(provider => provider.GetRequiredService>().Value);
```
Решение прямолинейное, мы не заставляем конечный код знать про IOptions, но мы теряем гибкость для дополнительных действий с конфигурацией, если таковые нам необходимы. Для решения этой проблемы мы можем использовать паттерн «Мост», который позволит нам получить дополнительный слой, в котором мы можем производить дополнительные действия перед получением объекта.
Для достижения цели нам необходимо отрефакторить текущий код примера. Так как класс конфигурации имеет ограничение в виде конструктора без параметров, передать в конструктор объект IOptions / IOptionsSnapshot / IOptionsMontitor мы не можем, для этого мы отделим чтение конфигурации от финального представления.
Для примера представим, что мы хотим указать свойство StartTime класса MonitoringConfig строковым представлением минут со значением «09», которое не подходит под стандартный формат.
```
public class MonitoringConfigReader
{
public bool EnableRPSLog { get; set; }
public bool EnableStorageStatistic { get; set; }
public string StartTime { get; set; }
}
public interface IMonitoringConfig
{
bool EnableRPSLog { get; }
bool EnableStorageStatistic { get; }
TimeSpan StartTime { get; }
}
public class MonitoringConfig : IMonitoringConfig
{
public MonitoringConfig(IOptionsMonitor option)
{
MonitoringConfigReader reader = option.Value;
EnableRPSLog = reader.EnableRPSLog;
EnableStorageStatistic = reader.EnableStorageStatistic;
StartTime = GetTimeSpanValue(reader.StartTime);
}
public bool EnableRPSLog { get; }
public bool EnableStorageStatistic { get; }
public TimeSpan StartTime { get; }
private static TimeSpan GetTimeSpanValue(string value) => TimeSpan.ParseExact(value, "mm", CultureInfo.InvariantCulture);
}
```
Для возможности получить чистую конфигурацию нам необходимо зарегистрировать ее в контейнере внедрения зависимостей.
```
services.Configure(Configuration.GetSection("Features:Monitoring"));
services.AddTransient();
```
Такой подход позволяет создать полностью отдельный жизненный цикл для формирования объекта конфигурации. Есть возможность добавить свою валидацию данных, либо дополнительно внедрить этап расшифровки данных, если получать их в зашифрованном виде.
### Обеспечение безопасности данных
Немаловажной задачей конфигурации является обеспечение безопасности данных. Файловые конфигурации небезопасны, поскольку данные хранятся в открытом виде, который легко прочитать; зачастую файлы находятся в той же директории, что и приложение. По ошибке можно закоммитить значения в систему контроля версий, что может рассекретить данные, а представьте, если это публичный код! Ситуация настолько распространена, что есть даже готовый инструмент для поиска подобных утечек — [Gitleaks](https://github.com/zricethezav/gitleaks). Есть отдельная [статья](https://www.zdnet.com/article/over-100000-github-repos-have-leaked-api-or-cryptographic-keys/), которая приводит статистику и разнообразие раскрытых данных.
Часто проект должен иметь отдельные параметры для различных сред окружения (Release/Debug и др.). Для примера, как один из вариантов решения, можно использовать подстановку финальных значений с помощью инструментов непрерывной интеграции и доставки, но этот вариант никак не защитит данные во время разработки. Защитить разработчика призван инструмент [User Secrets](https://docs.microsoft.com/ru-ru/aspnet/core/security/app-secrets?view=aspnetcore-3.1&tabs=windows#secret-manager). Он входит в пакет SDK для .NET Core (начиная с 3.0.100). В чем же основной принцип работы этого инструмента? Для начала мы должны инициализировать наш проект для работы командой init.
```
dotnet user-secrets init
```
Команда добавляет элемент UserSecretsId в .csproj файл проекта. Имея этот параметр, мы получаем приватное хранилище, которое будет хранить обычный JSON файл. Отличие в том, что он не находится в директории вашего проекта, поэтому доступен будет только на текущем компьютере. Путь для Windows %APPDATA%\Microsoft\UserSecrets\\secrets.json, а для Linux и MacOS ~/.microsoft/usersecrets//secrets.json. Мы можем добавить значение из примера выше с помощью команды set:
```
dotnet user-secrets set "Features:Monitoring:StartTime" "09:00"
```
Полный список доступных команд можно посмотреть в документации.
Безопасность данных в продакшене лучше всего обеспечить с использованием специализированного хранилища, как например: AWS Secrets Manager, Azure Key Vault, HashiСorp Vault, Consul, ZooKeeper. Для подключения некоторых уже есть готовые NuGet пакеты, а для некоторых их легко реализовать самостоятельно, поскольку есть доступ к REST API.
Заключение
----------
Современные проблемы требуют современных решений. Вместе с уходом от монолитов к динамическим инфраструктурам, подходы в конфигурации тоже претерпели изменения. Появилась необходимость в независимости от расположения и типа источников данных конфигурации, необходимость в оперативном реагировании на изменение данных. Вместе с .NET Core мы получили хороший инструмент для реализации всевозможных сценариев конфигурирования приложений. | https://habr.com/ru/post/514652/ | null | ru | null |
# Обзор выделенных серверов Kimsufi и SoYouStart
Год назад вышла [статья](http://habrahabr.ru/post/167117/), которая подвигла меня приобрести сервер в [Kimsufi](http://www.kimsufi.com/) – это подразделение крупного французского хостера [OVH](http://www.ovh.com/), специализирующееся на дешёвых серверах, зачастую на старом железе (есть процессоры ’08-09-х годов). Сервер оказался неплохим, недорого стоил, и вообще мне всё понравилось. Примерно в то же время на хабре было несколько статей про Proxmox, и именно его я туда и поставил (благо что Proxmox был в стандартном выборе хостера при установке), чем весьма доволен. Но сегодняшняя статья не про это.
После нескольких месяцев использования заказанного сервера, я порекомендовал Kimsufi своему другу, и с удивлением обнаружил, что, по обновлённому соглашению, пользоваться серверами могут только граждане Евросоюза.
И вот, с нового года, OVH запустил новый сайт для продаж дешёвых выделенных серверов – [SoYouStart.com](http://www.soyoustart.com/), а также снова открыл возможность всем регистрироваться на [Kimsufi.com](http://www.kimsufi.com/), да к тому же, последний стал доступен на [русском языке](http://www.kimsufi.com/ru/)!
Под катом – обзор новых предложений серверов от OVH –новый SoYouStart и обновлённый Kimsufi – **выделенные серверы от 8 евро в месяц**.
Итак, два новых предложения от OVH — [Kimsufi](http://www.kimsufi.com/ru/) и [SoYouStart](http://www.soyoustart.com/offres.xml).
**Серверы Kimsufi** – маломощные, но дешёвые серверы. Линейка от 8 евро в месяц за сервер PS-1 с одноядерным Celeron® 220и двумя гигабайтами памяти до 30 евро за сервер PS-31 на 4-х ядерном Xeon E3-1225 v2 и 16-ю гигабайтами памяти и 500 ГБ диска в раид-1. Неплохо!
Все сервера Kimsufi имеют диск на 500 ГБ, причём, начиная с сервера PS-5 за 12 евро – два диска в софт раид-1. Также предоставляется 100-мегабитная сеть, один ipv4-адрес и один ipv6-адрес (/128). Разовая установочная плата за серверы Kimsufi составляет 10 евро.
**Серверы SoYouStart** продолжают линейку и начинают от сервера SYS-E32-1 с тем же процессором Xeon E3-1225v2, но с 32 ГБ памяти и 2 ТБ диском – за 35 евро. Заканчивается линейка сервером SYS-W35-3 с процессором Xeon-W3565 (старенький Bloomfield) и 48 ГБ памяти за 48 евро. Более мощные серверы доступны на основном сайте OVH.com (от 82 евро).
Все сервера SoYouStart имеют диск на 2 ТБ (софт раид-1), а два сервера – SSD диск на 120 ГБ (также в софт раид-1, но два сервера имеют хард раид). Подключены к гигабитной сети с гарантированной полосой 200 Мбит, также даётся один ipv4-адрес и /64 подсеть ipv6. Разовая установочная плата за серверы Kimsufi составляет 50 евро.
Серверы Kimsufi доступны только во Франции, а серверы SoYouStart доступны в одном из трёх французских датацентров, а также в датацентре в Канаде. К сожалению, не все серверы доступны в любом из предложенных датацентров, а из всей линейки серверов Kimsufi (31 позиция в линейке) доступны для заказа только 13 (по крайней мере, на момент написания статьи).
В следующей таблице приведены основные параметры серверов линеек Kimsufi и SoYouStart. Для комплекта добавил в таблицу один самый дешёвый сервер основной линейки OVH и один самый дешёвый сервер Hetzner. В таблице представлены только доступные для заказа серверы Kimsufi ([полная таблица](http://habrastorage.org/storage4/435/6f0/d5d/4356f0d5d91644e2a780fc9cbc430de8.png)).
В колонке «Вирт.» указано, поддерживает ли процессор виртуализацию.
В колонке «Рейтинг CPU bench» приведены рейтинги процессоров по сайту [www.cpubenchmark.net](http://www.cpubenchmark.net/).
Колонки «Мощность» показывают условную мощность сервера и учитывает процессор и память. Вычисляются по формуле:
Мощность по рейтингу CPU bench:
`(мощность) = (рейтинг CPU bench) / 1000 + Корень(гигабайт ОЗУ)`
Мощность по частотной формуле:
`(мощность) = (частота в ГГц) x (кол-во потоков) + Корень(гигабайт ОЗУ)`
> Резкий рост памяти не всегда даёт столь же резкий рост производительности (естественно, кроме определённых требовательных по памяти задач), поэтому я учитываю влияние подсистемы памяти как корень от гигабайт ОЗУ.
Совокупная мощность — это средняя арифметическая от двух предыдущих колонок. Эта колонка учитывает как вычислительный потенциал, основанный на частоте, так и зависящую от технологии величину, определяемую по независимому рейтингу cpubenchmark.
В колонке «Удельный рейтинг» я вывел «удельную стоимость» сервера – разделил получившуюся совокупную мощность на стоимость сервера в месяц.
Все данные сведены [в таблице](https://docs.google.com/spreadsheet/ccc?key=0Atxnwb8-C24HdGw0WkNKd1Q5M0RMMWVVaWFvclM0S0E&usp=sharing) на Google Docs. К сожалению, Google Spreadsheet не умеет расцвечивать колонки так же удобно, как MS Excel.
Понятно, что предложенная формула расчёта мощности далека от идеала, но примерное соотношение она показывает. Если кто-то предложит более грамотную оценку мощности сервера, я добавлю предложенный метод в таблицу.
##### Итоги
На мой взгляд, серверы Kimsufi – достаточно интересное предложение. Если кому-то нужен выделенный сервер и VPS не устраивает, но денег на популярный Hetzner не хватает, или просто не требуется мощный сервер, то это предложение для вас. В конце концов, многие отечественные хостеры предлагают менее мощные VPS за гораздо большие деньги.
Серверы SoYouStart оказались по цене сопоставимы с самым дешёвым сервером Hetzner, но имеют, в основном, более старое железо, что и привело к меньшему удельному рейтингу. | https://habr.com/ru/post/210992/ | null | ru | null |
# Анимация в MooTools. Основы и не только.
В данном топике я собираюсь свести все свои знания об анимации в MooTools воедино и рассмотреть темы, более углубленные, чем просто примеры использования плагинов. Теоретическая информация справедлива не только для MooTools, но и для других фреймворков. Начинающим будет интересно ознакомиться с возможностями фреймворка, а продолжающим — понять, как все это работает :). В статье приведено много примеров, есть довольно оригинальные, вот некоторые из них: [1](http://cray.net84.net/store/habrahabr/mootools/animation/caterpillar/), [2](http://cray.net84.net/store/habrahabr/mootools/animation/heart/), [3](http://cray.net84.net/store/habrahabr/mootools/animation/menu1/). Приятного вам чтения.
#### Анимация в MooTools.
##### Основные принципы. Класс Fx.
Итак, сегодня мы займемся анимацией. Для начала необходимо понять, как реализованы принципы анимации в MooTools. Анимация в MooTools — это изменение какого-либо свойства какого-либо элемента во времени (переход), например, изменение CSS-свойства left — это движение по горизонтали, а background-color — плавное изменение цвета заливки.
Для создания анимационных эффектов в MooTools используется класс Fx. Все классы, реализующие какую-либо анимацию наследуются от Fx. В этом классе определены вспомогательные методы для анимации:
* **start** — этот метод запускает переход.
* **set** — изменяет значение анимируемого параметра. Вызывается на каждом шаге перехода. По смыслу это абстрактный метод, если его можно так назвать, т.е. каждая реализация анимационного плагина должна переопределить set по-своему.
* **cancel** — отменяет текущую анимацию.
* **pause** — приостанавливает текущую анимацию.
* **resume** — возобновляет приостановленную анимацию.
Конструктор принимает следующие опции:
* **fps** — количество кадров в секунду для анимации. Характеризует, если можно так сказать, «плавность» анимации — чем он больше, тем «плавнее».
* **unit** — единица измерения, например «em», «px», «%». Используется для преобразований CSS-свойств.
* **link** — опция, характеризующая поведение анимации, когда во время перехода был вызван start. Может принимать следующие значения ([пример с разными значениями link](http://cray.net84.net/store/habrahabr/mootools/animation/link/)):
+ **'ignore'** — все вызовы start во время анимации игнорируются. Используется по умолчанию.
+ **'cancel'** — текущая анимация будет остановлена и начата новая с параметрами, пришедшими в start.
+ **'chain'** — все вызовы start во время анимации будут добавлены в цепь и их анимация начнется сразу после того, как закончится текущая.
* **duration** — длительность анимации.
* **transition** — уравнение перехода. Подробнее уравнения переходов будут рассмотрены ниже.
Работает Fx следующим образом. В вызов метода start передаются начальное и конечное значения изменяемого параметра, затем запускается таймер, который периодически (период равен 1 / fps) вызывает метод step, где на каждом шаге анимации вычисляется значение анимируемого параметра. А вычисляется оно так:
1. Время, прошедшее со старта перехода до текущего момента делится на duration, таким образом получается число от 0 до 1 характеризующее прогресс анимации. Назовем его progress.
2. Это число передается в функцию перехода (будет рассмотрено ниже). Результат вычисления функции перехода назовем delta.
3. Значение же анимируемого параметра вычисляется так: param = (to − from) × delta + from, где from — начальное значение параметра, to — конечное значение параметра. Очевидно, что при delta равном 0 мы получаем начальное значение параметра, а при 1 — конечное.
После вычисления значения параметра, в методе set происходит уже непосредственная визуализация анимации (например, изменение CSS-свойства left).
Стоит подчеркнуть, что сам по себе класс Fx является абстрактным, то есть ничего сам не анимирует, он оперирует только общими данными для реализации принципов анимации. Непосредственной анимацией занимаются наследники Fx. В основном для анимации элементов на HTML-страницах используются классы, которые анимируют различные CSS-свойства элементов. Об этих классах мы поговорим, а также рассмотрим случай с созданием своего класса, который реализует анимацию не-CSS-свойств.
##### Уравнения переходов. Написание собственного уравнения.
Согласитесь, не очень красиво бы смотрелась анимация перемещения элемента на странице, если бы он резко стартовал и так же резко останавливался в конце пути. Так происходит, если приращение delta (которое упоминалось выше) на протяжении всего времени остается постоянным. Это называется — линейный переход, его уравнение delta = progress. Если взять последовательно несколько значений progress от 0 до 1 и подставить в уравнение, то получим обычную прямую, которая резко начинается в значении 0 и резко заканчивается в 1.
Надеюсь, из предыдущего абзаца стало примерно понятно, что такое уравнение перехода — это закон, по которому следует вычислять приращение delta. Благо, в MooTools есть целый набор таких законов, которые позволят сделать анимацию плавной, резкой, затухающей, прыгающей и т.д., но нам этого окажется мало — мы напишем еще и свое уравнение. Но об этом позже. Сейчас же посмотрим, какие бывают стандартные уравнения:
* **Linear** — прямая (delta = progress).
* **Quad** — квадратичная функция (delta = progress2).
* **Cubic** — кубическая функция (delta = progress3).
* **Quart** — delta = progress4.
* **Quint** — delta = progress5.
* **Pow** — общая степенная функция delta = progressx (по умолчанию степень равна 6).
* **Expo** — экспоненциальная функция (delta = 2(progress − 1) × 8).
* **Circ** — четверть окружности (delta = 1 − sin(acos(progress))).
* **Sine** — кусок синусоиды (delta = 1 − sin((1 − progress) × π / 2)).
* **Back** — сначала оттягивает delta в минус, а потом плавно доводит до 1.
* **Bounce** — прыгающий переход.
* **Elastic** — эластичный переход (единственная ассоциация — резинка :).
Все эти уравнения доступны в классе Fx.Transitions. Они используются в качестве значения опции transition конструктора Fx. Помимо прямого использования этих уравнений можно еще применять к ним модификаторы:
* **easeIn** — используется по умолчанию и ничего не меняет.
* **easeOut** — вычисляет значение delta по формуле 1 − transition(1 − progress), таким образом разворачивая кривую перехода.
* **easeInOut** — до середины перехода вычисляет delta по формуле transtition(2 × progress), а после — по (2 − transition(2 × progress)) / 2, совмещая в одном переходе две кривых: прямую и развернутую.
Для наглядности привожу кривые некоторых наиболее интересных уравнений.
  
А вот и та самая прыгающая анимация.
  
Четверть окружности.
  
Резинка.
  
Экспоненциальная функция.
  
Пятая степень.
  
Кусок синусоиды.
  
Примерчик, показывающий использование различных уравнений переходов в анимации смотреть [тут](http://cray.net84.net/store/habrahabr/mootools/animation/transitions/).
А вдруг среди всего разнообразия встроенных уравнений не окажется нужного? Не проблема, всегда можно написать свое, чем мы сейчас и займемся. В идеале уравнение должно быть таким, чтобы при аргументе, равном нулю возвращало 0, а при единице — 1. В этом случае в начале и в конце анимации не будет скачков анимируемого параметра.
В качестве примера мне захотелось написать уравнение, имитирующее колебания на электрокардиограмме. Конечно можно было бы снять с чьей-нибудь кардиограммы точки и интерполировать их в полином, например (для такого даже прогу на третьем курсе писал :), но это было бы не так точно и ресурсоемко (на больших порядках) при конечном использовании. Поэтому функция получилась сложная. Вся условная область определения (от 0 до 1) разделена на интервалы, на каждом из которых определена своя маленькая функция. В итоге получилось следующее:
Как видно, на первом промежутке определена «квадро-функция» для плавного подъема из нуля, далее набор из прямых с разными наклонами и длинами, и в конце четверть окружности для плавного подъема в единицу. Вот как это выглядит в виде кривых:
  
Добавим эту функцию в объект Fx.Transitions следующим образом:
> `Fx.Transitions.extend({
>
> Heartbeat: function(x){
>
> if (x < 0.3)
>
> return Math.pow(x, 4) \* 49.4;
>
>
>
> if (x < 0.4)
>
> return 9 \* x - 2.3;
>
>
>
> if (x < 0.5)
>
> return -13 \* x + 6.5;
>
>
>
> if (x < 0.6)
>
> return 4 \* x - 2;
>
>
>
> if (x < 0.7)
>
> return 0.4;
>
>
>
> if (x < 0.75)
>
> return 4 \* x - 2.4;
>
>
>
> if (x < 0.8)
>
> return -4 \* x + 3.6;
>
>
>
> if (x >= 0.8)
>
> return 1 - Math.sin(Math.acos(x));
>
> }
>
> });`
Теперь можно им воспользоваться, передав в качестве опции transition (замечание: в примере используется плагин Fx.Morph, который будет рассмотрен ниже, а пока его можно просто считать наследником Fx, понимающем в конструкторе все опции, что понимает Fx):
> `var fx = new Fx.Morph($('Heart'), { transition: Fx.Transitions.Heartbeat, duration: 900, link: 'chain' });
>
>
>
> // Производим анимацию 10 раз.
>
> for (var i = 0; i < 10; i++){
>
> // Увеличиваем сердце.
>
> fx.start({
>
> 'width': 265,
>
> 'height': 238,
>
> 'margin-left': -20,
>
> 'margin-top': -20
>
> });
>
>
>
> // Уменьшаем сердце.
>
> fx.start({
>
> 'width': 225,
>
> 'height': 198,
>
> 'margin-left': 0,
>
> 'margin-top': 0
>
> });
>
> }`
В HTML-коде присутствует всего лишь один элемент:
> ``
Живой пример лежит [тут](http://cray.net84.net/store/habrahabr/mootools/animation/heart/). Интересный эффект: во время тестирования скрипта я слушал Drum’n’Bass и казалось, что биение этого сердечка происходит очень в такт музыке (попробуйте сами).
Ok, может мы и не добились идеальной человеческой кардиограммы, но свою функцию все же написали. Как оказалось, это не так сложно :).
##### Цепочки. Сцепление анимационных преобразований.
Очень часто бывает нужно задать несколько последовательных преобразований так, чтобы каждое следующее осуществлялось после окончания предыдущего. Если просто вызвать их последовательно, то по умолчанию каждый следующий вызов будет игнорироваться (смотрим опцию link класса Fx). Если же указать link равным 'chain', то все последующие вызовы добавятся в цепочку и будут выполнены последовательно.
Однако, существует и специальный синтаксис для создания цепочек. Реализуются они в классе Chain. Он содержит аж целых три метода:
* **chain** — дописывает функцию в конец цепочки.
* **callChain** — вызывает следующую в цепочке функцию и удаляет ее из цепочки.
* **clearChain** — очищает цепочку.
На основании Chain напишем класс, который будет упралять зеленой гусеницей и будет поддерживать цепочки вызовов. С помощью цепочки вызовов мы заставим гусеницу проползти по восьмерке.
Сама гусеница представляет собой обычный div, у которого изменяются CSS-свойства left, top, width и height создавая эффект движения (ах, да, еще изменяется его цвет для реалистичности). Шаг гусеницы будет состоять из двух этапов: первый — передвижение ее головы в нужное место, а второй — подтягивание хвоста к голове. В примере использован Fx.Morph, позволяющий анимировать одновременно несколько CSS-свойств, который будет рассмотрен подробнее ниже.
> `var CaterpillarController = new Class({
>
> // Реализуем методы Chain в классе.
>
> Implements: Chain,
>
>
>
> // Максимальный и минимальный размеры гусеницы.
>
> largeSize: 200,
>
> smallSize: 10,
>
>
>
> // Конструктор.
>
> initialize: function(caterpillar){
>
> this.caterpillar = $(caterpillar);
>
>
>
> // Создаем для элемента гусеницы экземпляр Fx.Morph со сцеплением последующих вызовов start.
>
> this.fx = new Fx.Morph(this.caterpillar, { duration: 900, transition: Fx.Transitions.Expo.easeOut, link: 'chain' });
>
>
>
> // Как только завершается анимация второго этапа шага гусеницы вызываем следующую функцию в нашей цепи.
>
> this.fx.addEvent('chainComplete', this.callChain.bind(this));
>
>
>
> return this;
>
> },
>
>
>
> // Этот метод отвечает за один шаг гусеницы.
>
> // На вход передается измерение (dimension: горизонтальное — true, вертикальное — false)
>
> // и направление (direction: положительное — true, отрицательное — false).
>
> move: function(dimension, direction){
>
> var dimensions = this.caterpillar.getCoordinates();
>
> var options1, options2;
>
>
>
> // Формируем объекты с опциями для двух этапов шага гусеницы.
>
> if (dimension){
>
> // Движение по горизонтали.
>
> if (direction){
>
> options1 = { 'width': dimensions.width + this.largeSize };
>
> options2 = { 'left': dimensions.left + this.largeSize, 'width': this.smallSize };
>
> } else {
>
> options1 = { 'left': dimensions.left - this.largeSize, 'width': this.largeSize + this.smallSize };
>
> options2 = { 'width': this.smallSize };
>
> }
>
> } else {
>
> // Движение по вертикали.
>
> if (direction){
>
> options1 = { 'height': dimensions.height + this.largeSize };
>
> options2 = { 'top': dimensions.top + this.largeSize, 'height': this.smallSize };
>
> } else {
>
> options1 = { 'top': dimensions.top - this.largeSize, 'height': this.largeSize + this.smallSize };
>
> options2 = { 'height': this.smallSize };
>
> }
>
> }
>
>
>
> // Расширим объекты добавив в них свойство для изменения цвета (для пущей реалистичности).
>
> $extend(options1, { 'background-color': '#7CCB26' });
>
> $extend(options2, { 'background-color': '#4C9004' });
>
>
>
> // Стартуем два этапа шага
>
> // (второй этап начнется после окончания первого, вспоминаем link равный 'chain').
>
> this.fx.start(options1);
>
> this.fx.start(options2);
>
>
>
> return this;
>
> }
>
> });
>
>
>
> window.addEvent('domready', function(){
>
> // Следующая последовательность вызовов move опишет восьмерку.
>
> new CaterpillarController('Caterpillar').move(true, true).
>
> chain(function() { this.move(false, true); }).
>
> chain(function() { this.move(true, false); }).
>
> chain(function() { this.move(false, true); }).
>
> chain(function() { this.move(true, true); }).
>
> chain(function() { this.move(false, false); }).
>
> chain(function() { this.move(true, false); }).
>
> chain(function() { this.move(false, false); });
>
> });`
Живой пример [тут](http://cray.net84.net/store/habrahabr/mootools/animation/caterpillar/). А [тут](http://cray.net84.net/store/habrahabr/mootools/animation/chasing.caterpillar/) уже пример никак к цепочкам не относящийся — просто полет фантазии, но прикольный.
##### Анимация собственных переменных.
До сих пор мы использовали анимацию различных CSS-свойств. Но, как я указывал в начале статьи, класс Fx можно использовать для анимации чего угодно. Поэтому было бы неплохо попробовать написать своего наследника Fx. За основу возьмем улучшеный вариант скрипта реостата, о котором я писал в [этом топике](http://habrahabr.ru/blogs/mootools/41894/). Что же в нем можно анимировать? Например, угол поворота индикатора. Вспомним, что если сделать одиночный клик на реостате, то индикатор сразу же оказывается в месте нажатия. А что если анимировать этот переход? Было бы забавно, да и написать-то надо всего несколько строк :). Итак, что же нужно для создания полноценного наследника Fx:
* добавить в описание класса **Extends: Fx** для наследования.
* передать опции в базовый конструктор.
* переопределить метод **set** для применения значения анимируемого параметра к «физике» параметра, в данном случае повернуть индикатор на значение угла.
* вызвать **start** для начала анимации.
Код метода set:
> `set: function(now){
>
> // now — текущее значение угла во время анимации.
>
> this.oldMouseAngle = this.mouseAngle = this.angle = now;
>
> this.updateIndicatorPosition();
>
> }`
Метод, который реагировал на клик мыши вместо мгновенного изменения угла теперь вызывает метод start и передает в него текущее значение угла поворота индикатора и значение угла, на который он должен быть повернуть после окончания анимации:
> `captureMouse: function(e){
>
> this.captured = true;
>
>
>
> var mouseAngle = this.getMouseAngle(e);
>
> if ((mouseAngle >= this.options.minAngle) && (mouseAngle <= this.options.maxAngle))
>
> // Стартуем анимацию перехода индикатора в место клика.
>
> this.start(this.angle, mouseAngle);
>
> }`
Вот и все, у нас появился анимированный переход, лицезреть который можно [здесь](http://cray.net84.net/store/habrahabr/mootools/animation/rheostat/).
#### Стандартные анимационные плагины.
##### Fx.Tween.
Этот класс является простейшим классом, анимирующим любое CSS-свойство элемента. Для работы ему нужна ссылка на анимируемый элемент, имя анимируемого CSS-свойства и диапазон значений. Пример создания:
> `var myFx = new Fx.Tween(element, [, options]);`
На этом классе основан [пример с применением различных уравнений переходов](http://cray.net84.net/store/habrahabr/mootools/animation/transitions/):
> `// Здесь мы будем менять CSS-свойство top у элемента с идентификатором 'Ball'.
>
> var fx = new Fx.Tween('Ball', { property: 'top', duration: 900, link: 'cancel' });
>
> var transitionSelect = $('Transition');
>
> var modifierSelect = $('Modifier');
>
> var test = $('Test');
>
>
>
> // При возникновении одного из следующих событий запустить анимацию.
>
> modifierSelect.addEvent('change', startAnimation);
>
> transitionSelect.addEvent('change', startAnimation);
>
> test.addEvent('click', startAnimation);
>
>
>
> function startAnimation(){
>
> // Получаем имя перехода в виде 'sine:in'.
>
> fx.options.transition = transitionSelect.value + modifierSelect.value;
>
>
>
> // Двигаем шарик с выбранным переходом.
>
> fx.start(60, 400);
>
> }`
В HTML-коде примера два выпадающих списка, анимируемый шарик и кнопка на всякий пожарный.
##### Fx.Morph.
Используется чаще, чем Fx.Tween потому что может одновременно анимировать несколько CSS-свойств элемента. Конструктор почти такой же как и у Fx.Tween за исключением отсутствия опции property, вместо нее в метод start передается объект, описывающий, какие CSS-свойства необходимо анимировать и в каких диапазонах. Например:
> `morph.start({
>
> 'margin-left': [0, 10],
>
> 'background-color': ['#EEE', '#555']
>
> });`
означает, что анимироваться будут два CSS-свойства: margin-left (от 0 до 10) и background-color (от '#EEE' до '#555'). Диапазоны значений можно и не указывать, а только указать конечное значение, тогда в качестве начального будет взято текущее значение, указанное в стиле элемента. В качестве примера можно привести использование Fx.Morph для создания анимированного меню:
> `var menuHeadItems = $$('#Menu .MenuHeadItem');
>
>
>
> menuHeadItems.each(function(item, i){
>
> var morph = new Fx.Morph(item, { duration: 900, transition: Fx.Transitions.Elastic.easeOut, link: 'cancel' });
>
>
>
> // Для каждого пункта меню стартуем анимацию с прогрессивной задержкой 100i ms.
>
> // Анимируется два параметра: opacity и margin-left. Таким образом элемент "выезжает"
>
> // слева одновременно с изменением прозрачности до 1.
>
> morph.start.delay(i \* 100, morph, {
>
> 'opacity': [0, 1],
>
> 'margin-left': 0
>
> });
>
>
>
> item.addEvents({
>
> // При наведении курсора мыши отодвигаем элемент и делаем его темнее.
>
> 'mouseenter': function(){
>
> morph.start({
>
> 'margin-left': 8,
>
> 'background-color': '#DDD'
>
> });
>
> },
>
> // При уведении курсора мыши возвращаем элемент в исходное состояние.
>
> 'mouseleave': function(){
>
> morph.start({
>
> 'margin-left': 0,
>
> 'background-color': '#EEE'
>
> });
>
> }
>
> });
>
> });`
А также менюшку можно [посмотреть](http://cray.net84.net/store/habrahabr/mootools/animation/menu3/).
[Официальный пример](http://demos111.mootools.net/Fx.Morph).
##### Fx.Slide.
Довольно полезный класс, когда нужно чтобы что-то откуда-то выехало или заехало. Конструктор очень похож на все предыдущие, поэтому особо останавливаться на нем не буду. Скажу только, что он понимает еще несколько опций, самая важная их которых — это mode, определяющая направление «выезжания»: вертикальное или горизонтальное. На основе этого класса сделаны еще два примера с анимированными меню: [первый](http://cray.net84.net/store/habrahabr/mootools/animation/menu1/) и [второй](http://cray.net84.net/store/habrahabr/mootools/animation/menu2/).
[Официальный пример](http://demos.mootools.net/Fx.Slide).
##### Fx.Elements.
Позволяет удобно анимировать любое количество CSS-свойств для любого количества элементов одновременно. В его конструктор передается массив элементов, над которыми будут осуществляться преобразования. А вся прелесть заложена в методе start — туда передается массив объектов для преобразования. Получается, каждому элементу из массива, переданного в конструкторе соответствует элемент объект из массива, переданного в start. Таким образом осуществляется массовая анимация элементов.
В примере ниже изменяется прозрачность массива элементов при наведении на них курсора, причем чем ближе элемент к тому, что в данный момент под курсором, тем меньше его прозрачность, а чем дальше — тем больше:
> `var elements = $$('#ElementsContainer .Element');
>
> var elementsFx = new Fx.Elements(elements, { duration: 500, link: 'cancel' });
>
>
>
> elements.each(function(element, i){
>
> // При наведении курсора на элемент пересчитываем прозрачность соседей.
>
> element.addEvent('mouseenter', function(){
>
> var arg = {};
>
>
>
> // Для всех соседних элементов вычисляем значение их прозрачности
>
> // на основании их удаленности от текущего.
>
> elements.each(function(element, j){
>
> arg[j] = { opacity: 1 - Math.min(Math.abs(i - j), 5) / 8 };
>
> });
>
>
>
> // Стартуем изменение прозрачности.
>
> elementsFx.start(arg);
>
> });
>
> });`
[Живой пример](http://cray.net84.net/store/habrahabr/mootools/animation/elements/).
[Интересный вариант меню от MooTools](http://demos111.mootools.net/Fx.Elements).
Надеюсь, что читателям было интересно закопаться поглубже в реализацию анимации в MooTools. Большинство из описанного здесь должно быть применимо и к другим фреймворкам.
Спасибо за внимание. | https://habr.com/ru/post/43379/ | null | ru | null |
# Как сэкономить на спотовых инстансах EC2 с помощью Scylla
Спотовые инстансы могут сэкономить вам много денег. Но что если вы работаете с сервисами с сохранением состояния, например, базами данных NoSQL? Основная проблема заключается в том, что в таком случае каждая нода в кластере должна сохранять некоторые параметры — IP, данные и другие конфигурации. В этом посте мы расскажем об опенсорсной NoSQL БД Scylla и о том, как ее можно использовать в спотовых инстансах EС2 для непрерывной работы — с помощью предиктивной технологии SpotInst, а также расширенной функциональности сохранения состояния.
Что Такое Scylla?
-----------------
Scylla — это база данных NoSQL, распространяемая по opensource-модели. Она была разработана с учетом совместимости с Apache Cassandra, обеспечивая при этом значительно более высокую пропускную способность и меньшие задержки. Она поддерживает те же протоколы и форматы файлов, что и Apache Cassandra. Однако Scylla написана полностью C++, а не на Java, как Apache Cassandra. Кроме того, Scylla была построена с использованием фреймворка Seastar, который представляет собой асинхронную библиотеку, заменяющую потоки выполнения, разделяемую память, сопоставленные файлы и другие классические техники программирования Linux. У Scylla также есть свой уникальный дисковый планировщик, который помогает повысить производительность.
Тесты, проведенные как инженерами ScyllaDB, так и сторонними компаниями, продемонстрировали, что Scylla превосходит Apache Cassandra в 10 раз.
Как Scylla реплицирует свои данные между нодами
-----------------------------------------------
Scylla обеспечивает доступность в режиме AlwaysOn. Автоматический переход на резервную систему, репликация между несколькими узлами и центрами обработки данных обеспечивают отказоустойчивость.
Scylla, как и Cassandra, использует gossip-протокол для обмена метаданными для идентификации нод в кластере и определения того, активны ли они. Нет единой точки отказа — не может быть и единого реестра состояния нод, поэтому они должны обмениваться информацией между собой.
Как запустить Scylla на Spotinst
--------------------------------
При создании нового кластера Scylla вряд ли возникнет желание сразу прибегать к спотовым инстансам из-за их нестабильного поведения. Не в их пользу говорит и тот факт, что эти инстансы можно отключить в течение 2 минут. Поэтому Elastigroup — это стандартный выбор для такого окружения.
Elastigroup с показателем 100% доступности является лидером Spot Market. Выбор правильной ставки для правильного спота, анализ истории данных в реальном времени — все это помогает выбрать спотовые инстансы с наименьшей ценой и наибольшим сроком работы. Изменения в Spot Market прогнозируются на 15 минут вперед, что позволяет заменять спот без прерывания работы.
Теперь о сохранении состояния. Elastigroup умеет сохранять тома данных. Для любого тома EBS, который подключен к инстансу, во время работы будут непрерывно выполняться снапшоты, а после замены он будет использован для сопоставления блоков.
Чтобы ваша машина продолжила работать в случае сбоя, нужно помнить о нескольких вещах:
1. **Частный IP-адрес.** — убедитесь, что новый компьютер имеет тот же IP-адрес, чтобы gossip-протокол мог продолжить взаимодействие с машиной.
2. **Том**. Нода должна быть подключена к тому же хранилищу и должна иметь тот же том, что и раньше. Если нет, сервис будет недоступен.
3. **Config-файл** — scylla.yaml по умолчанию находится по адресу /etc/scylla/scylla.yaml. Его необходимо отредактировать так, чтобы узлы имели информацию о своей конфигурации. Вот ключевые параметры, которые нужно настроить:
* *Cluster\_name* — имя кластера. Этот параметр разделяет ноды разных логических кластеров. Для всех узлов в пределах одного кластера должно быть установлено одинаковое значение;
* *Listen\_interface* — интерфейс, который Scylla назначает для подключения к другим узлам;
* *Seeds* — сид-ноды используются во время запуска для начальной загрузки gossip-процесса и присоединения к кластеру;
* *Rpc\_address* — IP-адрес интерфейса для клиентских соединений (Thrift, CQL);
* *Broadcast\_address* — IP-адрес интерфейса для соединений между нодами, то как он будет виден внутри кластера.
Выбор стоек
-----------
Для повышения доступности ваших данных рекомендуется распределить узлы между A-Z. Сконфигурировать это можно с помощью значения `Ec2Snitch` в файлах `scylla.yaml` и `cassandra-rackdc.properties`.
Предположим, что у вас есть кластер, созданный в регионе `us-east-1`. Если нода 1 находится в `us-east-1a`, а нода 2 — в `us-east-1b`, Scylla будет считать, что они находятся в двух разных стойках в одном дата-центре. Узел 1 будет считаться стойкой 1a, а узел 2 — стойкой 1b.
Теперь мы покажем, как развернуть кластер из шести нод. Каждый дата-центр будет состоять из трех обычных нод и двух сидов. IP-адреса выглядят так:
**US US-DC1**
`Node# Private IP
Node1 192.168.1.1 (seed)
Node2 192.168.1.2 (seed)
Node3 192.168.1.3`
**US US-DC2**
`Node# Private IP
Node4 192.168.1.4 (seed)
Node5 192.168.1.5 (seed)
Node6 192.168.1.6`
На каждой ноде Scylla нужно отредактировать файл scylla.yaml. Вот еще один пример, для одной ноды в каждом дата-центре:
**US Data-center 1 – 192.168.1.1**
`cluster_name: 'ScyllaDB_Cluster'
seeds: "192.168.1.1,192.168.1.2,192.168.1.4,192.168.1.5"
endpoint_snitch: Ec2Snitch
rpc_address: "192.168.1.201"
listen_address: "192.168.1.201"`
**US Data-center 2 — 192.168.1.4**
`cluster_name: 'ScyllaDB_Cluster'
seeds: "192.168.1.1,192.168.1.2,192.168.1.4,192.168.1.5"
endpoint_snitch: Ec2Snitch
rpc_address: "192.168.1.4"
listen_address: "192.168.1.4"`
На каждой ноде Scylla нужно отредактировать файл cassandra-rackdc.properties, указав соответствующую информацию о стойке и дата-центре:
**Nodes 1-3**
`dc=us-east-1a
rack=RACK1`
**Nodes 4-6**
`dc=us-east-1b
rack=RACK2`
Настройка Spotinst Console
--------------------------
При настройке Elastigroup важно включить функцию сохранения состояния — это необходимо, чтобы сохранить данные и сетевую конфигурацию при замене инстанса из-за отключении спота. Откройте вкладку Compute, дойдите до функции stateful и отметьте опции, как показано на скриншоте ниже.
Также рекомендуем воспользоваться командой «nodetool drain» shutdown script, чтобы очистить commit log и прекратить прием новых соединений. Описание есть в разделе [shutdown script](https://help.spotinst.com/hc/en-us/articles/115003069869-Shutdown-Script).
Как же это работает?
--------------------
На анимации ниже — вы видите кластер Scylla с тремя инстансами. Все ноды работают на спотовых инстансах, с настроенным сохранением состояния.
Когда один из инстансов отключается, наша функция сохранения состояния создает инстанс с томами Private IP и Root/Data. И, как вы можете видеть ниже, инстанс возвращаются в кластер.
Так с помощью Scylla и Spotinst вы можете увеличить производительность и при этом снизить затраты.
Если хотите посмотреть и протестировать решение, можете обратиться к нам через [форму на сайте](http://www.globaldots.com/speak-with-a-specialist?utm_source=habrahabr&utm_medium=article&utm_campaign=spotinst), в комментариях к посту, по почте [ru@globaldots.com](mailto:ru@globaldots.com) или по телефону +7-495-762-45-85. | https://habr.com/ru/post/345480/ | null | ru | null |
# SQL и XPath против РосРеестра
Уже несколько лет РосРеестр выдаёт данные в формате XML, а с недавних пор – только в XML. И это замечательно! Ведь это удобный, человек-читаемый и машино-читаемый формат, для работы с которым существует огромное количество инструментов. Но Кадастровым Инженерам почему то, подавай данные в таких древних форматах как .tab и .shp – ведь только с этими форматами они умеют работать в своих ГИС. Для решения этой проблемы подключилась куча корыстных и [бескорыстных людей](http://geodesist.ru/forum/threads/konverter-iz-rosreestrovskogo-xml-v-esri-shape-ili-mid-mif.27718/) – и в результате КИ получили кучу конвертеров в свои любимые программы. Но есть маленькая проблема – РосРеестр имеет привычку [менять xml-схемы](http://forum-rosreestr.ru/messages/forum25/topic540/message10461/#message10461), [молча и без предупреждения](https://gosmonitor.ru/mob/234/feedback/318900). В результате [работа КИ парализуется](http://www.pkzo.ru/forum/51985/), ведь они не способны работать с XML!
Лично я предпочитаю работать с данными в СУБД, используя SQL. Я буду использовать Microsoft SQL Server и SQL Server Management Studio.
Создаём таблицу:
```
CREATE TABLE [dbo].[T1](
[IntCol] [int] IDENTITY(1,1) NOT NULL,
[XmlCol] [xml] NULL)
```
Загружаем данные:
```
INSERT INTO T1(XmlCol)
SELECT * FROM OPENROWSET(BULK 'C:\work1\doc8652442.xml', SINGLE_BLOB) AS x;
```
Получаем таблицу координат:
```
DECLARE @Xdoc xml;
SET @Xdoc = (select [XmlCol] FROM [test1].[dbo].[T1]);
WITH XMLNAMESPACES (DEFAULT 'urn://x-artefacts-rosreestr-ru/outgoing/kpt/10.0.1',
'urn://x-artefacts-rosreestr-ru/commons/complex-types/entity-spatial/5.0.1' as ns3)
SELECT Parcel.value('@CadastralNumber', 'nvarchar(50)')as data,
Ordinate.value('@X', 'nvarchar(50)') as X,Ordinate.value('@Y', 'nvarchar(50)') as Y
FROM @Xdoc.nodes('//Parcel') col(Parcel)
CROSS APPLY Parcel.nodes('//ns3:Ordinate') tab(Ordinate)
```
Всё! Теперь мы можем делать с данными что угодно. Например нам хочется получить геометрию участков (Parcel). Геометрия хранится в элементе EntitySpatial, он может содержать несколько контуров SpatialElement – участок может быть полигоном с дырками или даже мультиплигоном. Попробуем получит SpatialElement как LineString, для этого нам понадобится несколько функций
SpatialElement=>LineString
```
CREATE FUNCTION [dbo].[SpatialElementToLineString](@wXml xml)
RETURNS geometry
AS
BEGIN
DECLARE @BuildString NVARCHAR(MAX);
WITH XMLNAMESPACES ('urn://x-artefacts-rosreestr-ru/commons/complex-types/entity-spatial/5.0.1' as ns3)
SELECT @BuildString = COALESCE(@BuildString + ',', '')
+ Ordinate.value('@Y', 'NVARCHAR(50)') + ' '
+ Ordinate.value('@X', 'NVARCHAR(50)')
FROM @wXml.nodes('//ns3:Ordinate') col(Ordinate);
SET @BuildString = 'LineString(' + @BuildString + ')';
return geometry::STGeomFromText(@BuildString, 0);
END
```
Получение всех контуров участка:
```
CREATE FUNCTION [dbo].[ParcelToLineString](@Xdoc xml)
RETURNS @Tbl TABLE
(
CadastralNumber nvarchar(max),
Geom geometry
)
AS
begin
WITH XMLNAMESPACES (DEFAULT 'urn://x-artefacts-rosreestr-ru/outgoing/kpt/10.0.1',
'urn://x-artefacts-rosreestr-ru/commons/complex-types/entity-spatial/5.0.1' as ns3)
insert into @Tbl(CadastralNumber, Geom)
SELECT @Xdoc.value('/*[1]/@CadastralNumber', 'nvarchar(max)') as CadastralNumber,
[dbo].[SpatialElementToLineString](Parcel.query('.')) as geom
FROM @Xdoc.nodes('//ns3:SpatialElement') col(Parcel);
RETURN;
end
```
Теперь создадим таблицу для хранения геометрии:
```
CREATE TABLE [dbo].[CadastrTbl](
[id] [int] IDENTITY(1,1) NOT NULL,
[CadastralNumber] [nvarchar](255) NULL,
[geom] [geometry] NULL
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
```
И заполним её
```
DECLARE @Xdoc xml;
SET @Xdoc = (select [XmlCol] FROM [test1].[dbo].[T1]);
DECLARE @CURSOR CURSOR
SET @CURSOR = CURSOR SCROLL
FOR
WITH XMLNAMESPACES (DEFAULT 'urn://x-artefacts-rosreestr-ru/outgoing/kpt/10.0.1')
SELECT Parcel.query('.') FROM @Xdoc.nodes('//Parcel') col(Parcel);
DECLARE @Parcel xml;
OPEN @CURSOR
FETCH NEXT FROM @CURSOR INTO @Parcel
WHILE @@FETCH_STATUS = 0
BEGIN
insert into [test1].[dbo].[CadastrTbl]([CadastralNumber],[geom])
select * from dbo.ParcelToLineString(@Parcel);
FETCH NEXT FROM @CURSOR INTO @Parcel
END
CLOSE @CURSOR
```
Теперь у нас есть геометрия, которую можно открыть в ГИС ([например QGIS](https://youtu.be/yUomIFR0FQA?t=1m20s))
В QGIS мы можем [сохранить наш слой](https://youtu.be/0EKv9EGEORg?t=57s) в любом удобном формате, например в kml и посмотреть данные в GE:
Теперь нам не надо ждать, когда нас спасут, и мы можем взять свою жизнь в свои руки! И всё благодаря SQL. | https://habr.com/ru/post/307294/ | null | ru | null |
# MAC-адреса бывают разные
*Эпиграф: Если у человека нет чувства юмора, у него по крайней мере должно быть чувство, что у него нет чувства юмора.*
Не далее как сегодня с коллегами вычисляли неблагополучно подключенное устройство с целью отключить порт на коммутаторе в воспитательных целях.
В нашем случае мы физически видели железку, но, к нашему несчастью, дёрганье патчкорда из неё так и не положило порт на коммутаторе — спасибо замурованным хабам и стихийно-историческому становлению СКС в этом помещении.
Созрел план вычисления железки по тотальному анализу вендоров оборудования по MAC (технически по [MAC OUI](https://ru.wikipedia.org/wiki/%D0%A3%D0%BD%D0%B8%D0%BA%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%B8%D0%B4%D0%B5%D0%BD%D1%82%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%82%D0%BE%D1%80_%D0%BE%D1%80%D0%B3%D0%B0%D0%BD%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B8), первым трём байтам mac-адреса).
Обмен информацией шёл через Lync, изумительно раскрасивший портянку с MAC-адресами смайликами.
Причина, конечно, банальна — 0E:01:3F:95:D1:68 превращается в 0E:01:3F:951:68 (Nortel, он их «так видит» *(с) художник-авангардист*, в отличии от Cisco Catalyst, например). Неожиданный юмор ситуации оказался в том, что ВСЕ адреса оказались «весёлыми».
После минутного позитива возникла идея ввести градацию «весёлых» и «грустных» mac-адресов.
По терверу, вероятность появления :D — 1/16 и позиций для возникновения весёлости — пять (первый байт не генерирует смайлик), что после недолгих набросков приводит к пониманию наличия порядка 27,6% весёлых адресов.
Нам стало интересно, наверняка есть вендоры, у которых OUI сами по себе весёлые. И сегодня мы представляем top10 оборудования с «весёлыми» MAC-адресами.
**Как актуализировать top10 (он, впрочем, вряд-ли скоро изменится) в shell**
```
wget http://standards-oui.ieee.org/oui.txt
cat oui.txt | grep "(hex)" | grep '^..\-D' > smileMACs
cat oui.txt | grep "(hex)" | grep '^..\-..\-D' >> smileMACs
cat smileMACs | cut -f3 | sort | uniq -c | sort -r | head -n5
```
Вот они!
> 75 Cisco Systems, Inc
>
> 55 Apple, Inc.
>
> 47 Samsung Electronics Co.,Ltd
>
> 39 HUAWEI TECHNOLOGIES CO.,LTD
>
> 27 ARRIS Group, Inc.
>
>
Но, как оказалось, нет. Cписок производителей железок с «грустными» MAC-адресами в верхней части аналогичен:
> 680 Cisco Systems, Inc
>
> 477 Apple, Inc.
>
> 366 Samsung Electronics Co.,Ltd
>
> 299 HUAWEI TECHNOLOGIES CO.,LTD
>
> 221 ARRIS Group, Inc.
>
>
Отчего бы не посчитать в процентовке? Давайте почувствуем себя британскими учёными! Отметим, сколько заведомо «весёлых» OUI (+) у венодора и сколько «грустных» (-) (в них, впрочем не всё потеряно — там тоже будет немного «весёлых» MAC-адресов. Отсечём тех, у которых есть хотя-бы 5 диапазонов адресов и получим:
| | | | |
| --- | --- | --- | --- |
| **вендор** | **+** | **—** | **± %** |
| «UNGERMANN-BASS INC.» | 16 | 1 | 1600% |
| «Hangzhou H3C Technologies Co., Limited» | 10 | 17 | 58.82% |
| «Amazon Technologies Inc.» | 6 | 12 | 50% |
| «AzureWave Technology Inc.» | 8 | 23 | 34.78% |
| «IEEE Registration Authority» | 22 | 72 | 30.55% |
| «ASKEY COMPUTER CORP» | 5 | 18 | 27.77% |
| «Liteon Technology Corporation» | 8 | 30 | 26.66% |
| «vivo Mobile Communication Co., Ltd.» | 5 | 21 | 23.80% |
| «Murata Manufacturing Co., Ltd.» | 6 | 28 | 21.42% |
| «D-Link International» | 6 | 33 | 18.18% |
| «Cisco SPVTG» | 6 | 35 | 17.14% |
UB — первое место с огромным отрывом (по ходу они знакомы с идеей!)
H3C — второе место (!).
Список явно затянулся, чтобы захватить хотя-бы ещё одного широко известного производителя сетевого оборудования массового сегмента (D-Link).
**Улыбайтесь чаще!**И быть, может, 1 апреля и чаща улыбнётся вам…
Отправлено с грустного MAC-адреса. | https://habr.com/ru/post/324200/ | null | ru | null |
# Адаптивные email'ы
Сегодня пользователи все чаще читают электронные письма на мобильных устройствах. Каково бывает просмотр большого HTML-email'а на телефоне? Приходится много масштабировать и скроллить, в целом читать становится очень неудобно. Поэтому и письма электронной почты следует делать адаптивными.
#### Подготовка
Прежде всего определим основные особенности адаптивных email'ов:
* **Чистый и лаконичный контент:** на маленьких экранах гораздо важнее эффективно использовать полезное пространство.
* **Одна колонка:** очевидно, что на экране телефона контент не должен разбиваться на несколько колонок.
* **Краткая тема письма:** письма с короткими заголовками выделяются среди множества других в inbox'е.
* **Большие «call to action» кнопки:** Apple iOS Human Interface Guidelines рекомендует делать кнопку не менее 44×44 px.
* **Правильный шрифт:** текст должен быть удобочитаем на любом устройстве.
* **Pre-header:** начальный текст письма должен максимально отражать содержание.
* **Выравнивание текста по левому краю:** Большинство пользователей уделяют больше внимания левой части экрана. Кроме того, некоторые ОС могут не полностью отображать письмо, поэтому контент должен выравниваться по левому краю.
* **Вертикальная иерархия:** наиболее важная информация, в том числе кнопки «call to action», должна располагаться в верхней части письма.
* **Минимум изображений:** пользователь не ожидает увидеть в письмах большие картинки. К тому же, у многих отключено отображение изображений.
#### Начало
HTML-письма своей структурой немного отличаются от обычных простых HTML-страниц. К примеру, CSS-стили должны быть прописаны непосредственно в разметке, кроме того, некоторые почтовые клиенты вовсе игнорируют любые CSS-стили внутри тега head. Для удобства можно использовать специальные шаблоны с грамотной разметкой HTML-письма. Например [HTML Email Boilerplate](http://htmlemailboilerplate.com/).
#### Doctype
Hotmail и Gmail принудительно добавляет в код XHTML 1.0 doctype.
```
```
#### Viewport и Media Queries
Для корректного отображения на мобильных устройствах, следует использовать метатег viewport. К сожалению, он не работает на Blackberry:
Также желательно определить content-type тег title. Многие почтовые клиенты это будут игнорировать, но не стоит забывать о «версии для браузера» письма. Еще можно добавить немного CSS, чтобы самим задать некоторые параметры отображения.
```
Email subject or title
.ExternalClass {width:100%;}
img {display: block;}
```
При добавлении Media Queries скрываем элементы с классом hide с помощью display:none, если ширина экрана меньше 600 px:
```
@media only screen and (max-width: 600px) {
table[class="hide"], img[class="hide"], td[class="hide"] {
display:none!important;
}
}
```
Это стандартный подход при верстке адаптивных email'ов: перезапись CSS в head с помощью !important. При этом GMail будет игнорировать стили в head. Поэтому необходимо следить за тем, чтобы контент везде корректно отображался. С помощью Media Queries можно также ограничить ширину блока с контентом:
```
@media only screen and (max-width: 600px) {
table[class="content_block"] {
width: 92%!important;
}
}
```
#### Кнопки
После прочтения письма пользователь, в идеале, должен совершить какое-то действие. Поэтому роль «call to action» элементов очень важна. Кнопки должны быть крупны, заметны и располагаться, по возможности, в верхней части письма.
К сожалению, не существует единого кроссплатформенного решения для кнопок в письмах. Один из вариантов:
```
@media only screen and (max-width:600) {
a[class="button"]{
display: block;
padding: 7px 8px 6px 8px;
-webkit-border-radius: 5px;
-moz-border-radius: 5px;
border-radius: 5px;
color: #fff!important;
background: #f46f62;
text-align: center;
text-decoration: none!important;
}
}
```
Ну совсем простой способ — обычная ссылка. Однако при этом страдает юзабилити на устройствах с тач-скрином:
```
[Click me!](#)
```
[Скачать пример](http://netdna.webdesignerdepot.com/uploads7/responsive-html-email-design/template.zip), описанный в статье.
#### «Резиновые» письма
Вместо адаптивной верстки писем, можно использовать обычную резиновую. Это намного проще, и email будет везде корректно отображаться. Однако в этом случае существует ряд недостатков. В первую очередь, будет сильно страдать юзабилити из-за того, что элементы письма нельзя перемещать в зависимости от ширины экрана устройства. Поэтому резиновая верстка — это не наш способ!
#### Примеры адаптивных email'ов
Вот пара хороших примеров того, как адаптивные письма должны отображаться на большом и мобильном экранах:
#### Заключение
По причине того, что существует большое количество видом платформ, устройств и экранов, очень сложно создать универсальное решение при верстке адаптивных email'ов. Если подвести итог всего вышесказанного, можно придти к одному простому правилу — «Простота — залог хорошего юзабилити писем».
##### Статьи по теме и использованный материал
* [How to design a responsive HTML email](http://www.webdesignerdepot.com/2013/06/responsive-html-email-design/)
* [Our Favorite Responsive and Mobile Email Resources](https://litmus.com/blog/our-favorite-responsive-and-mobile-email-resources)
* [Viewport Metatag Rendered Unusable](http://www.emailonacid.com/blog/details/C13/emailology_viewport_metatag_rendered_unusable)
* [Responsive & Scalable Email Design: What’s the Difference?](https://litmus.com/blog/responsive-scalable-email-design-whats-the-difference)
* [Multiscreen Maturation](http://www.silverpop.com/marketing-resources/white-papers/all/2013/Multiscreen-Maturation-Email-Design-Strategies-and-Tips-for-Connecting-Across-Devices/) | https://habr.com/ru/post/190814/ | null | ru | null |
# Тестирование производительности приложений как часть ежедневного цикла разработки
### Введение
Каждый продукт в какой-то момент приходит в ту точку, когда вопросы производительности начинают выходить на первый план, и возникает задача: внедрить решение для тестирования и отслеживания изменений.
Первый вопрос, с которым может столкнуться менеджер - в какой момент начинать тестирование? С самого начала цикла разработки, на стадии feature complete, перед отправкой в продакшн? С одной стороны, чем раньше приступить к тестированию, тем больше вероятность отсмотреть большее количество сценариев, с другой стороны - продукт в активной стадии разработки довольно быстро меняется и потребует от команд тестирования постоянно адаптировать тестовые сценарии под новые требования. Тестирование же продукта на стадиях “альфа” и “бета”(когда продукт уже больше приближен к тому, что пользователи увидят на продакшене) может привести к ситуации, когда не останется времени либо на исправление найденных проблем, либо на тестирование внесенных правок.
Дальше встает вопрос ресурсов. Сколько времени в цикле разработки нужно выделить не тестирование производительности? Какие команды должны быть задействованы?
На сегодняшний день Veeam Backup and Replication с точки зрения разработки - это более 200 разработчиков в двух основных офисах, кодовая база более 5 миллиона строк, несколько тысяч юнит тестов, десятки билд процессов, и т. п. И несколько лет назад перед нами также встали эти вопросы. Поэтому в своей статье я хотел бы рассказать о нашем решении для мониторинга влияния изменений кодовой базы на производительность запросов базы данных.
### Наша отправная точка
База данных - это один из основных компонентов нашего продукта. Сейчас это несколько сотен таблиц и представлений и порядка 5000 процедур и функций. В процессе разработки каждая команда постоянно вносит изменения в структуру базы, изменяя как свою зону ответственности, так и затрагивая общие компоненты. В активной фазе разработки каждый день может выполняться до нескольких десятков коммитов, связанных со схемой базы.
В какой-то момент мы столкнулись с такой проблемой: внесение изменений в хранимые процедуры стало приводить к просадке по времени выполнения, используемому процессорному времени и потреблению ресурсов. С одной стороны, за качество вносимых изменений отвечает разработчик, и, конечно, он проверяет на базовых сценариях производительность запроса. Но как быть в тех случаях, когда сценариев очень много и они не все известны? Например, были внесены изменения в представление, которое используется десятками хранимых процедур. Если в базовом сценарии джоин с какой-то абстрактной таблицей никак не повлияет на производительность, то в другом сценарии, где эта таблица может иметь несколько миллионов строк, могут возникнуть указанные сложности. Но проблема тут не в качестве кода, а скорее в том, что такие ошибки в разработке можно очень легко пропустить. По моему опыту, такие скрытые проблемы начинают проявляться не сразу, а спустя неделю, месяц и т.д. И для того, чтобы понять, что стало реальной причиной проблемы, иногда требуется довольно долго разбираться в коде, изучать историю изменений, искать авторов. Самое неприятное во всей этой истории -это то, что проблемы такого рода можем найти не мы, а пользователь.
### Автоматизация процесса
После некоторого опыта в решении таких проблем мы совместно с нашей командой нагрузочного тестирования пришли к пониманию, что нам нужен инструмент для автоматического отслеживания и оценивания того, как вносимые в SQL код изменения влияют на производительность запросов. В первом приближении данный инструмент должен уметь:
* получать статистику по выполнению выбранных нами наиболее критичных представлений и процедур,
* проверка должны выполняться на ежедневной основе в рамках ночного билда,
* заинтересованные люди должны получать краткий дайджест,
* а также должна быть возможность более детального анализа статистики за период всего релизного цикла.
В итоге совместными усилиями мы реализовали следующую систему.
Основным компонентом является кроссплатформенная утилита командной строки, которая выполняет набор SQL скриптов и сохраняет по ним статистику. На вход утилита получает:
* адрес сервера,
* наименование инстанса и базы, на которых будут выполняться тесты,
* а также координаты сервера и базы, куда будем сохранять результаты,
* путь до папки, содержащей файлы тестов,
* наименование продукта и номер билда
* и прочую служебную информацию.
На выходе мы получаем структурированную информацию по выполненным тестам, а также статистику по запросам.
В качестве тестовых стендов мы используем набор максимально приближенных к реальности баз данных, которые отражают различные сценарии использования продукта. Эти базы развернуты в нашей тестовой инфраструктуре.
Работа всех компонентов системы координируется с помощью Jenkins. Выглядит это следующим образом: по завершению ночного билда на всех тестовых SQL серверах проводится обновление версии базы до актуальной. Далее для каждой тестовой базы данных производится запуск утилиты. Каждая утилита может выполнять свой набор скриптов, которые пишутся исходя из области интереса, также различаются и данные, на которых выполняются тесты. Например, одна база может отражать инфраструктуру сервис-провайдера, другая ориентирована на SQL Backup, третья - предназначена для бэкапа на кассеты, и т.д. По завершению всех тестов заинтересованные лица получают на почту краткий дайджест, где отражены различия в параметрах производительности между текущей версией и версией, выбранной в качестве эталона схемы БД. В нашем случае за эталонную версию мы считаем прошлый релиз.
Для того, чтобы более подробно посмотреть отчет по каждой базе и по каждому тесту, отдел тестирования сделал несколько дашбордов в Grafana. Первый вид - это историческая кривая по каждому параметру для каждого скрипта. На таком общем виде удобно смотреть общий тренд, а также искать аномалии, например, резкое падение или, наоборот, резкий рост.
Следующий вид более специфичный - он показывает данные по каждому выполнению скрипта. Здесь стоит сказать, что каждый отдельно взятый скрипт при каждом прохождении тестов выполняется 300 раз, и в качестве результата теста берется медианное значение. Это нужно для того, что бы уменьшить влияние внутренних механизмов оптимизации SQL сервера на конечный результат. На приведенных ниже графиках видно различие значений в зависимости от номера прогона.
Скрипт - это отдельный текстовый файл в формате yaml, состоящий из двух основных разделов: заголовок и блок с инструкциями.
* В заголовке содержится служебная информация: название сценария, продукт, для которого сценарий написан, количество запусков в рамках одного прогона.
* Блок инструкций содержит от одного до N шагов которые фактически являются инструкциями SQL.
Блоки могут быть двух типов: служебные и измеримые.
* Первые необходимы для подготовки данных, получения необходимых параметров, очистки и т.п. Для этого типа статистика не собирается.
* Второй тип - это как раз те запросы, по которым нам интересны статистические данные, те запросы, которые мы мониторим.
Выполнение блоков происходит последовательно. Также предусмотрен сценарий, когда данные, полученные при выполнении скриптов, могут быть использованы как входные параметры для следующего блока.
Вот пример одного из скриптов:
```
name: Test-BigViewPerformance
veeam-product: Backup
number-of-runs: 10
scripts:
- name: PrepareSomeData
body: SELECT id FROM SomeTable
- name: BigViewTest
body: SET STATISTICS IO ON
SET STATISTICS TIME ON
SELECT * FROM [SomeBigView] where id = @id
SET STATISTICS IO OFF
SET STATISTICS TIME OFF
is-statistics: true
- name: Clean
body: EXEC RemoveAllDataFromSomeTable
```
Видим, что это сценарий тестирования Test-BigViewPerformance для продукта Backup, который будет выполнен 10 раз. Сценарий содержит 3 шага, причем id, полученный на первом шаге, будет использован в качестве входного параметра во втором. Интересный момент тут - это количество запусков. Дело в том, что полученная статистика может довольно сильно отличаться от запуска к запуску, так как, во-первых, работают механизмы оптимизации в самом SQL сервере, а во-вторых, сама среда выполнения динамическая. Эти два фактора мы должны учитывать, именно поэтому мы выполняем десятки прогонов одного сценария и потом смотрим дисперсию, среднее и квартили.
Статистику по выполнению запроса мы получаем стандартными средствами ADO.Net. Для этого достаточно подписаться на событие ***OnMessageReceived***
```
msSql Database.OnMessageReceived += (s) => { scriptExecutionSummary.Messages += "\n" + s; };
```
Неприятный момент тут заключается в том, что статистика приходит в виде строк и требует преобразования для получения структурированных данных. Фактически это те же самые строки, что мы видим в SQL Server Management Studio.
```
SQL Server parse and compile time:
CPU time = 47 ms, elapsed time = 123 ms.
Table 'Worktable'. Scan count 0, logical reads 0, physical reads 0, page server reads 0, read-ahead reads 0, page server read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob page server reads 0, lob read-ahead reads 0, lob page server read-ahead reads 0.
Table 'Backup.Model.Backups'. Scan count 2, logical reads 12, physical reads 1, page server reads 0, read-ahead reads 4, page server read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob page server reads 0, lob read-ahead reads 0, lob page server read-ahead reads 0.
SQL Server Execution Times:
CPU time = 0 ms, elapsed time = 17 ms.
(to be continued...)
```
Как видно на изображениях выше, мы используем не все метрики, а только Total elapsed time, CPU time, Logical IO Reads. По нашему опыту тестирования, этих данных достаточно для того, чтобы быстро оценить запрос на предмет ухудшения или улучшения производительности. Более глубокий анализ запроса уже выходит за рамки нашей задачи и выполняется вручную в случае необходимости.
### Опыт использования
На данный момент аптайм системы уже больше года. За это время на ежедневной основе мы проводим тестирование наших баз данных на десятке сценариев. Большую часть времени статистика по запросам находится в относительном равновесии. Общий тренд также не имеет сильных отклонений ни вверх, ни вниз. Конечно, бывают случаи, когда какой-то запрос резко идет вверх или вниз. Но ежедневный мониторинг помогает быстро находить проблемы и своевременно их устранять.
До внедрения системы процесс выглядел приблизительно следующим образом - команда QA приходила к нам примерно с таким дефектом: "Раскрытие списка бэкапа очень сильно тормозит. Билд на нагрузочных лабах мы давно не обновляли, вчера поставили свежий, и все стало плохо". С нашей стороны мы начинаем смотреть представление, отвечающее за раскрытие списка. Это примерно тысяча строк, около десятка временных таблиц, которые, в свою очередь, также содержат другие представления и функции. Путем пошагового анализа мы в итоге находим проблемное место. Но это стоит дорого. При такой сложности запроса - в том случае, если ты постоянно с ним не работаешь - ты каждый раз смотришь на него как впервые. То есть сначала тебе надо разобраться, как он в принципе работает, и что мы должны видеть на выходе. Хорошо, когда проблема на поверхности и это занимает всего несколько часов. Но иногда копать приходится очень глубоко, и можно потратить целый день, а то и два только на то, чтобы найти проблемное место. И часто бывает так: изменения, которые сильно повлияли на скорость выполнения, были внесены в процессе мерджа новой фичи из другой ветки около месяца назад. Разработчик, котрый изменения вносил, сделал все корректно (с точки зрения своей фичи) и проверил, что работает все быстро и правильно. Но он не учел, что при определенном наборе данных внесенные им изменения будут джойниться с таблицей на несколько миллионов строк. С одной стороны, он бы мог проверить все сценарии, а с другой стороны - наша реальность такова, что продукт большой, и отдельно взятому разработчику уже невозможно знать все сценарии, а по временным затаратам это будет колоссальный объем работы. В целом решение такого рода проблемы занимало примерно один день (и это в лучшем случае).
А сейчас, внедрив нашу систему, мы имеем следующую картину: каждое утро за чашечкой кофе мы смотрим дайджест, и, к примеру, видим, что две-три процедуры сильно прибавили в потреблении ресурса ЦПУ по сравнению с базовым билдом. Так как мониторим мы ежедневно, то знаем, что вчера такой проблемы не было. Значит, проблемы были привнесены за вчерашний день. После это иногда достаточно просто посмотреть историю коммитов, чтобы увидеть, что же стало причиной ухудшения показателей и кто внес эти изменения. Как результат - скорость нахождения проблемы сокращается в десятки раз.
Еще один плюс нашей системы - это накопленная статистика. Сейчас, к примеру, мы знаем, что отдельные запросы у нас ресурсоемкие, в силу своей сложности и специфики данных. И если к нам приходит отдел тестирования и говорит, мол, на моей машине все стало медленно, то мы можем посмотреть всю собранную за год использования статистику и объективно оценить, действительно ли все стало медленно - или, допустим, среда, в которой проводилось тестирование, не соответвует минимальным требованиям к продукту.
PS: Я пишу тут в основном о том, что если код стал работать медленно, то это плохо. Однако если ваш код сам по себе вдруг начал работать быстрее, не стоит раньше времени радоваться: возможно, кто-то просто закомментировал проблемное место. | https://habr.com/ru/post/586666/ | null | ru | null |
# Безопасность в iOS приложениях
Добрый день, Хабр! Представляю вашему вниманию перевод статьи про базовые основы безопасности конфиденциальных данных в iOS приложениях [«Application Security Musts for every iOS App»](https://medium.com/swift2go/application-security-musts-for-every-ios-app-dabf095b9c4f) автора Arlind Aliu.
Безопасность приложений – один из самых важных аспектов разработки программного обеспечения. Пользователи приложений надеются, что информация, которую они предоставляют, надежно защищена. Поэтому нельзя так просто предоставлять кому-либо конфиденциальную информацию.
К счастью, в этой статье мы обсудим ошибки, которые допускают разработчики в своих приложениях, а также способы их устранения.
Продолжение под катом.
### Хранение данных не в том месте
Я провел исследование нескольких приложений из AppStore и во многих допускается одна и та же ошибка: конфиденциальная информация хранится там, где её не должно быть.
Если вы храните данные личного характера в *UserDefaults*, то вы подвергаете её риску. *UserDefaults* хранятся в файле со списком свойств, который находится внутри папки «Настройки» в вашем приложении. Данные сохраняются в приложении без малейшего намека на шифрование.
Установив на mac стороннюю программу, как например iMazing, можно даже не взламывать телефон, а сразу увидеть все данные *UserDefaults*, из приложения установленного из AppStore. Такие программы позволяют смотреть и управлять данными из приложений, установленных на айфоне. Можно легко получить *UserDefaults* любого приложения.
В этом и заключается главная причина, по которой я решил написать статью – я нашел кучу приложений в AppStore, которые хранят данные в *UserDefaults*, такие как: токены, активные и возобновляемые подписки, число доступных денег и так далее. Все эти данные можно легко получить и использовать со злым умыслом, начиная от управления платными подписками в приложении и заканчивая взломом на сетевом уровне и хуже.
А теперь о том, как нужно хранить данные.
Запомните, в *UserDefaults* следует хранить только небольшой объём информации, такой как настройки внутри приложения, то есть данные, которые не являются конфиденциальными для пользователя.
Пользуйтесь специальными службами безопасности от Apple для того, чтобы хранить личные данные. API сервис Keychain позволяет хранить некоторый объём данных пользователя в зашифрованной базе данных. Там вы можете хранить пароли и прочие важные для пользователя данные, как например информация о кредитной карте, или даже небольшие важные заметки.
Так же там могут находиться зашифрованные ключи и сертификаты, с которыми вы работаете.
### API сервис Keychain
Ниже приведен пример того, как можно сохранить пароль пользователя в Связке ключей.
```
class KeychainService {
func save(_ password: String, for account: String) {
let password = password.data(using: String.Encoding.utf8)!
let query: [String: Any] = [kSecClass as String: kSecClassGenericPassword,
kSecAttrAccount as String: account,
kSecValueData as String: password]
let status = SecItemAdd(query as CFDictionary, nil)
guard status == errSecSuccess else { return print("save error")
}
}
```
Часть словаря *kSecClass:kSecClassGenericPassword* означает что информацией, нуждающейся в шифровании является пароль. Затем мы добавляем новый пароль в связку ключей вызывая метод *SecItemAdd*. Получение данных из связки аналогично сохранению.
```
func retrivePassword(for account: String) -> String? {
let query: [String: Any] = [kSecClass as String: kSecClassGenericPassword,
kSecAttrAccount as String: account,
kSecMatchLimit as String: kSecMatchLimitOne,
kSecReturnData as String: kCFBooleanTrue]
var retrivedData: AnyObject? = nil
let _ = SecItemCopyMatching(query as CFDictionary, &retrivedData)
guard let data = retrivedData as? Data else {return nil}
return String(data: data, encoding: String.Encoding.utf8)
}
```
Давайте напишем небольшую проверку корректности сохранения и получения данных.
```
func testPaswordRetrive() {
let password = "123456"
let account = "User"
keyChainService.save(password, for: account)
XCTAssertEqual(keyChainService.retrivePassword(for: account), password)
}
```
На первый взгляд может показаться, что Keychain API довольно сложно использовать, особенно если нужно сохранить больше одного пароля, поэтому я призываю вас использовать паттерн Фасад для этих целей. Он позволит сохранять и модифицировать данные в зависимости от нужд приложения.
Если хотите узнать больше про этот паттерн, а также о том, как создать простенькую обертку для сложных подсистем, тогда вот эта [статья](https://medium.com/swift2go/simplifying-ios-code-by-using-design-patterns-e51e4bc7eaf5) поможет вам. Так же в интернете полно открытых библиотек, помогающих использовать Keychain API, например, [SAMKeychain](https://cocoapods.org/pods/SAMKeychain) и [SwiftKeychainWrapper](https://github.com/jrendel/SwiftKeychainWrapper).
### Сохранение пароля и Авторизация
В моей карьере разработчика я постоянно сталкиваюсь с одной и той же проблемой. Разработчики либо хранят пароли в приложении, либо же создают запрос на сервер, который напрямую посылает логин и пароль.
Если вы храните данные в *UserDefault*, то прочитав информацию из первой части статьи, вы уже понимаете, как сильно вы рискуете. Сохраняя пароли в Связке ключей вы серьезно повышаете уровень безопасности вашего приложения, но опять же, прежде чем сохранять где-либо конфиденциальную информацию, нужно её предварительно зашифровать.
Предположим, что некий хакер может атаковать нас через нашу сеть. Таким образом он получит пароли в виде сырого текста. Лучше, конечно, хэшировать все пароли.
### Шифрование личных данных
Хэширование может показаться чересчур сложным занятием, если делать все самому, поэтому в данной статье мы воспользуемся библиотекой [CryptoSwift](https://cryptoswift.io/). В ней собрано много стандартных надежных алгоритмов шифрования, применяемых в Swift.
Давайте попробуем сохранить и извлечь пароль из связки ключей используя алгоритмы [CryptoSwift](https://cryptoswift.io/).
```
func saveEncryptedPassword(_ password: String, for account: String) {
let salt = Array("salty".utf8)
let key = try! HKDF(password: Array(password.utf8), salt: salt, variant: .sha256).calculate().toHexString()
keychainService.save(key, for: account)
}
```
Приведенная выше функция записывает логин и пароль и сохраняет их в Keychain в виде зашифрованной строки.
Давайте разберемся, что же происходит внутри:
— В переменную salt записываются логин и пароль в виде строки
— sha256 заполняет хэш SHA-2
— HKDF это функция формирования ключа ([KDF](https://en.wikipedia.org/wiki/Key_derivation_function)), основанная на коде аутентификации сообщений ([HMAC](https://en.wikipedia.org/wiki/Hash-based_message_authentication_code))
Мы создали переменную salt для того, чтобы усложнить хакерам задачу. Мы могли бы зашифровать только пароль, но в таком случае у злоумышленника может быть список самых часто используемых паролей, он без проблем зашифрует их и сравнит с нашим зашифрованным паролем. После чего найти пароль к конкретному аккаунту не составит труда.
Теперь же мы можем авторизоваться, используя наш аккаунт и созданный ключ.
```
authManager.login(key, user)
```
Конечно, сервер должен знать, что зашифровано в нашей переменной salt. Бэкэнд сможет сравнить ключи используя тот же алгоритм, чтобы идентифицировать пользователя.
Используя такой подход, вы сильно повышаете безопасность вашего приложения.
### В качестве завершения
Никогда не пренебрегайте безопасностью вашего приложения. В данной статье мы, прежде всего, разобрались какие могут быть последствия при хранении конфиденциальных данных в *UserDefaults* и для чего нужен Keychain.
Во второй части мы поговорим уже о более серьезном уровне безопасности, шифровании данных перед их сохранением, а также обсудим как правильно передавать информацию с персональными данными на сервер. | https://habr.com/ru/post/430532/ | null | ru | null |
# Масштабируем кластер Kubernetes до 7500 нод
*Фото Carles Rabada, Unsplash.com*
Мы заскейлили кластер Kubernetes до 7500 нод, создав масштабируемую архитектуру для крупных моделей, вроде [GPT-3](https://arxiv.org/abs/2005.14165), [CLIP](https://openai.com/blog/clip/) и [DALL·E](https://openai.com/blog/dall-e/), и для небольших итеративных исследований, например, [законов масштабирования для нейронных моделей языка](https://arxiv.org/abs/2001.08361). Кластер Kubernetes такого размера — редкость, и действовать нужно осторожно, зато мы получили простую инфраструктуру, в которой специалисты по машинному обучению работают быстрее и могут масштабироваться без изменения кода.
С нашего последнего поста о [масштабировании до 2500](https://openai.com/blog/scaling-kubernetes-to-2500-nodes/) нод мы продолжали расширять инфраструктуру под требования исследователей. В процессе мы узнали много нового. Возможно, эти знания пригодятся пользователям Kubernetes. В конце мы расскажем об оставшихся проблемах, за которые возьмемся дальше.
Наша рабочая нагрузка
---------------------
Сначала расскажем о нашей рабочей нагрузке. Оборудование и приложения, с которыми мы используем Kubernetes, могут показаться необычными. Может быть, наши проблемы и их решения вообще вам не подойдут.
Большое задание машинного обучения выполняется на множестве нод. Эффективнее всего, когда у него есть доступ ко всем аппаратным ресурсам на каждой ноде. Таким образом GPU общаются напрямую друг с другом с помощью [NVLink](https://www.nvidia.com/en-us/data-center/nvlink/) либо с сетевой картой при помощи [GPUDirect](https://developer.nvidia.com/gpudirect). Так что для многих рабочих нагрузок один под занимает целую ноду. Состязание за ресурсы NUMA, CPU или PCIE не учитывается при планировании. Bin-packing или фрагментация — не частая проблема. В пределах кластера элементы могут общаться друг с другом на полной скорости (full bisection bandwidth), так что мы не учитываем такие факторы, как стойки и топология сети. В итоге, несмотря на большое количество нод, на планировщик ложится относительно небольшая нагрузка.
А вот нагрузка на kube-scheduler очень неравномерная, с резкими пиками. Новое задание может привести к созданию сотен подов одновременно, а потом все снова успокаивается.
Наши самые большие задания используют MPI, и все поды в задании участвуют в одном MPI-коммуникаторе. Если один из подов умирает, останавливается все задание, и его приходится перезапускать. Задание регулярно создает чекпойнты и возобновляется с последнего из них. Так что поды у нас *наполовину stateful* — остановленные поды можно заменить, и работа продолжится, но это очень мешает и лучше не злоупотреблять.
Мы не особо полагаемся на балансировку нагрузки в Kubernetes. У нас очень мало HTTPS-трафика, нам не нужно A/B-тестирование, blue/green и canary деплои. Поды общаются друг с другом напрямую по IP-адресу с MPI через SSH, а не через эндпоинты сервиса. Service "discovery" ограничено — мы просто разово смотрим, какие поды участвуют в MPI при запуске задания.
Большинство заданий взаимодействуют с blob-хранилищем. Как правило, они стримят шарды набора данных или чекпойнты напрямую из blob-хранилища или кэшируют их на быстрый локальный эфемерный диск. У нас есть несколько PersistentVolume под семантику POSIX, но blob-хранилище куда проще масштабировать, и не нужно долго ждать присоединения и отсоединения.
Наконец, мы, в основном, занимаемся исследованиями, а значит рабочие нагрузки постоянно меняются. Хотя команда по супервычислениям старается предоставить уровень вычислительной инфраструктуры «продакшен-качества», приложения на кластере существуют недолго, а разработчики выполняют итерации быстро. В любое время могут возникнуть новые шаблоны использования, которые заставят нас пересмотреть наши предположения о трендах и допустимых компромиссах. Нам нужна стабильная система, с которой можно быстро реагировать на изменения.
Сети
----
Когда на кластерах у нас стало больше нод и подов, мы узнали, что у Flannel есть проблемы с увеличением пропускной способности до нужного уровня. Мы перешли на нативные сетевые технологии подов для конфигураций IP для Azure VMSS и соответствующие плагины CNI. Так нам удалось добиться пропускной способности на подах на уровне хоста.
Еще одна причина перехода на IP-адреса на базе алиасов в том, что на самых больших кластерах у нас могло быть по 200 000 IP-адресов одновременно. Мы тестили соединения на основе маршрутов, но нашли серьезные ограничения по числу маршрутов.
Без инкапсуляции нагрузка на базовый движок маршрутизации или SDN возросла, но зато у нас все очень просто. Добавлять VPN или туннелирование можно без дополнительных адаптеров. Мы не беспокоимся о фрагментации пакетов, потому что у части сети низкий MTU. С сетевыми политиками и мониторингом трафика все просто — источник и место назначения пакетов всегда очевидны.
Мы используем теги iptables на хосте, чтобы отслеживать использование сетевых ресурсов для каждого неймспейса и пода. Таким образом исследователи могут визуализировать паттерны использования сети. Во многих экспериментах мы используем четкие паттерны взаимодействия с интернетом и между подами, так что возможность изучать узкие места очень к месту.
Iptables-правила `mangle` позволяют произвольно отмечать пакеты, которые соответствуют определенным критериям. Вот какие правила мы используем, чтобы понять, какой трафик идет внутри, а какой — связан с интернетом. Правила `FORWARD` распространяются на трафик с подов, а `INPUT` и `OUTPUT` — на трафик с хоста:
```
iptables -t mangle -A INPUT ! -s 10.0.0.0/8 -m comment --comment "iptables-exporter openai traffic=internet-in"
iptables -t mangle -A FORWARD ! -s 10.0.0.0/8 -m comment --comment "iptables-exporter openai traffic=internet-in"
iptables -t mangle -A OUTPUT ! -d 10.0.0.0/8 -m comment --comment "iptables-exporter openai traffic=internet-out"
iptables -t mangle -A FORWARD ! -d 10.0.0.0/8 -m comment --comment "iptables-exporter openai traffic=internet-out"
```
Когда мы ставим метку, iptables запускает счетчики для числа байтов и пакетов в соответствии с правилом. Эти счетчики можно просмотреть с помощью `iptables`:
```
% iptables -t mangle -L -v
Chain FORWARD (policy ACCEPT 50M packets, 334G bytes)
pkts bytes target prot opt in out source destination
....
1253K 555M all -- any any anywhere !10.0.0.0/8 /* iptables-exporter openai traffic=internet-out */
1161K 7937M all -- any any !10.0.0.0/8 anywhere /* iptables-exporter openai traffic=internet-in */
```
Мы используем опенсорс-экспортер Prometheus [iptables-exporter](https://github.com/madron/iptables-exporter/), чтобы отправлять данные отслеживания в систему мониторинга. Это простой способ отслеживать пакеты в соответствии с разными условиями.
У нашей сетевой модели есть одна уникальная особенность — мы полностью раскрываем CIDR-диапазоны нод, подов и сервисной сети для наших исследователей. Мы используем топологию hub and spoke и нативные CIDR-диапазоны нод и подов для маршрутизации трафика. Исследователи подключаются к хабу, а оттуда получают доступ к отдельным кластерам (лучам звезды). При этом кластеры друг с другом общаться не могут — они изолированы и не имеют общих зависимостей, которые могут помешать локализации сбоя.
Мы используем NAT для преобразования CIDR-диапазона сервисной сети для трафика, поступающего из-за пределов кластера. Благодаря такой схеме исследователи вольны решать, как и какие сетевые конфигурации использовать для экспериментов.
Серверы API
-----------
Серверы Kubernetes API и etcd — это критические компоненты здорового кластера, так что мы обращаем особое внимание на нагрузку на эти системы. Мы используем дашборды Grafana от [kube-prometheus](https://github.com/coreos/kube-prometheus), а еще собственные дашборды. Нам показалось полезным настроить алерты о количестве ошибок HTTP 429 (слишком много запросов) и 5xx (ошибка сервера) для серверов API.
Некоторые предпочитают запускать серверы API в kube, нам больше нравится делать это за пределами самого кластера. У etcd и серверов API есть собственные ноды. У самых крупных кластеров по пять нод для серверов API и etcd, чтобы распределить нагрузку и свести к минимуму проблемы, если одна из них отвалится. У нас не было особых проблем с etcd с момента переноса событий Kubernetes в отдельный кластер etcd, как мы рассказывали [здесь](https://openai.com/blog/scaling-kubernetes-to-2500-nodes/). Серверы API — stateless и обычно их легко запускать в самовостанавливающейся группе экземпляров или масштабируемом наборе. Мы еще не пробовали автоматизировать самовосстановление кластеров etcd, потому что инциденты возникают совсем редко.
Серверы API требуют немало памяти, причем потребление линейно зависит от количества нод в кластере. Для кластера на 7500 нод у нас получается куча до 70 ГБ на каждый сервер API. К счастью, возможностей нашего оборудования хватит еще надолго.
Серьезной проблемой для серверов API были операции WATCH на конечных точках. Есть несколько сервисов, например kubelet и node-exporter, в которые входит каждая нода на кластере. Когда нода добавлялась в кластер или удалялась из него, срабатывал WATCH. А поскольку обычно каждая нода сама следила за сервисом kubelet через kube-proxy, число и трафик в этих ответах составляли N² и целый 1 ГБ/с или даже больше. Благодаря [EndpointSlices](https://kubernetes.io/docs/concepts/services-networking/endpoint-slices/) в Kubernetes 1.17 эту нагрузку удалось сократить в 1000 раз.
Обычно мы следим за запросами сервера API, которые растут вместе с кластером. Мы не хотим, чтобы DaemonSet взаимодействовал с сервером API. Если вам действительно нужно, чтобы каждая нода следила за изменениями, можно использовать промежуточный сервис кэширования, например [Datadog Cluster Agent](https://docs.datadoghq.com/agent/cluster_agent/), чтобы избежать узких мест в кластере.
Чем больше становились кластеры, тем реже мы использовали автомасштабирование. Если автомасштабирования было слишком много, у нас иногда возникали проблемы — при добавлении новой ноды в кластер создавалось слишком много запросов, а если таких нод сразу несколько сотен, на сервер API ложилась непосильная нагрузка. Ускорив этот процесс, пусть даже на несколько секунд, мы смогли избежать перебоев.
Метрики временных рядов в Prometheus и Grafana
----------------------------------------------
Мы используем Prometheus для сбора метрик временных рядов и Grafana для графов, дашбордов и алертов. Мы начали с установки [kube-prometheus](https://github.com/coreos/kube-prometheus), который собирает самые разные метрики и создает хорошие дашборды для визуализации. Со временем мы добавили много собственных дашбордов, метрик и алертов.
Когда нод стало очень много, возникли проблемы с объемом метрик, которые собирал Prometheus. kube-prometheus дает много полезных данных, но некоторые из них мы даже никогда не смотрели, а другие были слишком подробными, чтобы можно было эффективно собирать, хранить и запрашивать их. Мы используем [правила Prometheus](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#relabel_config), чтобы пропускать некоторые метрики.
Какое-то время мы пытались решить проблему, при которой Prometheus захватывал все больше и больше памяти, пока контейнер не падал с ошибкой Out-Of-Memory (OOM). Это происходило даже после того, как мы выделили приложению огромное количество памяти. Более того, когда возникал сбой, нам требовались часы, чтобы проиграть файлы write-ahead-log (WAL) и вернуть контейнер в строй.
В итоге мы [отследили источник OOM](https://github.com/prometheus/prometheus/issues/5547#issuecomment-592797528). Им оказалось взаимодействие между Grafana и Prometheus, при котором Grafana использовала API `/api/v1/series` для Prometheus с запросом `{le!=""}` (т. е. «дай мне все метрики гистограммы»). У реализации `/api/v1/series` не было ограничений по времени и пространству — если у запроса было много результатов, требовалось все больше памяти и времени. Причем это продолжалось даже после того, как инициатор запроса закрывал соединение. Памяти никогда не хватало, и Prometheus вылетал. Мы [пропатчили](https://github.com/openai/prometheus/pull/1) Prometheus, чтобы ограничить этот API контекстом и применить таймаут. После этого проблем не возникало.
Хотя Prometheus стал ломаться гораздо реже, когда нам все же приходилось его перезапускать, проигрывание WAL доставляло много проблем. Иногда только через много часов Prometheus снова начинал собирать метрики и обслуживать запросы. Благодаря [Robust Perception](https://www.robustperception.io/) мы узнали, что здесь спасает `GOMAXPROCS=24`. Prometheus пытается использовать все ядра при воспроизведении WAL, а если у серверов ядер много, из-за состязания производительность сильно падает.
Мы изучаем новые варианты расширения возможностей мониторинга (см. раздел [Нерешенные проблемы](https://openai.com/blog/scaling-kubernetes-to-7500-nodes/#unsolvedproblems)).
Проверки работоспособности
--------------------------
Когда кластер настолько большой, выявлять и удалять неисправные ноды нужно автоматически. Со временем мы создали несколько систем проверки работоспособности.
#### Пассивные проверки работоспособности
Некоторые проверки работоспособности всегда пассивно выполняются на всех нодах. Они отслеживают базовые ресурсы системы, вроде доступности сети, неисправных или заполненных дисков и ошибок GPU. Проблемы с GPU проявляются по-разному, но одна из самых распространенных — неисправимая ошибка ECC. С инструментами Nvidia Data Center GPU Manager (DCGM) гораздо проще делать запросы по таким и другим ошибкам Xid. Для отслеживания таких ошибок мы используем в том числе [dcgm-exporter](https://github.com/NVIDIA/gpu-monitoring-tools#https://github.com/NVIDIA/gpu-monitoring-tools), чтобы отправлять метрики в Prometheus, нашу систему мониторинга. Это метрика `DCGM_FI_DEV_XID_ERRORS` с самым частым кодом ошибки. Кроме того, [NVML Device Query API](https://docs.nvidia.com/deploy/nvml-api/group__nvmlDeviceQueries.html#https://docs.nvidia.com/deploy/nvml-api/group__nvmlDeviceQueries.html) дает более подробную информацию о работоспособности и работе GPU.
Обнаруженную ошибку часто можно исправить перезапуском GPU или системы, хотя иногда приходится физически заменять GPU.
Еще одна форма проверки работоспособности отслеживает события обслуживания от облачного провайдера. Все крупные облачные провайдеры сообщают о предстоящем обслуживании виртуальной машины, которое приведет к перерыву в работе. Например, нужно перезапустить виртуальную машину, чтобы установить патч для гипервизора или перенести физическую ноду на другое оборудование.
Пассивные проверки работоспособности непрерывно выполняются в фоновом режиме на всех нодах. Если проверка работоспособности сбоит, для ноды автоматически делается cordon, чтобы на ней нельзя было планировать новые поды. Если происходит более серьезный сбой проверки работоспособности, мы вытесняем поды, чтобы они сразу завершили работу. Под сам решает, разрешить это вытеснение или нет (настраивается через Pod Disruption Budget). В конце концов, после завершения всех подов или через 7 дней (как указано у нас в SLA) мы принудительно завершаем виртуальную машину.
#### Активные тесты GPU
К сожалению, не все проблемы с GPU отображаются как ошибки в DCGM. Мы создали собственную библиотеку тестов, чтобы отлавливать другие проблемы с GPU и гарантировать ожидаемое поведение оборудования и драйвера. Эти тесты нельзя выполнять в фоновом режиме — они занимают весь GPU на несколько секунд или минут.
Мы тестим ноды при загрузке по модели preflight. Все ноды присоединяются к кластеру с taint и меткой preflight, чтобы на них нельзя было планировать обычные поды. DaemonSet настроен на запуск тестовых preflight-подов на всех нодах с этой меткой. После успешного завершения тест сам удаляет taint, и нода доступна для обычного использования.
Время от времени мы выполняем эти тесты на протяжении жизненного цикла ноды, запуская CronJob для любой доступной ноды на кластере. Это, конечно, рандомный и неконтролируемый подход, но мы убедились, что он дает достаточное покрытие с минимальными перерывами и координацией.
Использование квот и ресурсов
-----------------------------
По мере увеличения масштаба кластеров исследователи заметили, что им сложно пользоваться емкостью, которую мы им выделили. В традиционных системах планирования заданий есть много разных функций для справедливого разделения ресурсов между командами, но в Kubernetes таких функций нет. Вдохновляясь этими системами, мы разработали несколько аналогичных возможностей для Kubernetes.
#### Taint для команд
В каждом кластере у нас есть сервис team-resource-manager с несколькими функциями. Он берет данные из ConfigMap, где указан селектор нод, метка команды и объем выделенных ресурсов для всех команд, использующих этот кластер. Он сверяет эти значения с текущими нодами в кластере, помечая нужное число нод с помощью taint `openai.com/team=teamname:NoSchedule.`
team-resource-manager содержит сервис вебхука допуска (admission webhook service), так что при отправке каждого задания применяется toleration в зависимости от членства в команде. Использование taint позволяет гибко ограничивать планировщик подов Kubernetes, например toleration для подов с низким приоритетом разрешает командам одалживать друг у друга емкость без масштабной координации.
#### Baloon для CPU и GPU
Мы используем автомасштабирование кластера, чтобы не только динамически масштабировать кластеры на базе виртуальных машин, но и исправлять (удалять и снова добавлять) нездоровые члены кластера. Для этого мы задаем для минимального размера кластера 0, а для максимального — доступную емкость. Если сервис автомасштабирования видит простаивающие ноды, он пытается сократить масштаб до необходимой емкости. Это не идеальный вариант по многим причинам — задержка при запуске виртуальной машины, затраты на предварительное выделение ресурсов и влияние на сервер API, о котором мы говорили раньше.
В результате мы решили развернуть balloon-деплой для хостов только с CPU и с GPU, куда входит ReplicaSet с максимальным размером для подов с низким приоритетом. Эти поды занимают ресурсы на ноде, так что автомасштабирование не считает, что они простаивают. При этом они имеют низкий приоритет, так что планировщик может выселить их сразу, чтобы освободить место для настоящей работы. (Мы решили использовать Deployment вместо DaemonSet, чтобы DaemonSet не считался простаивающей рабочей нагрузкой на ноде.)
Кстати, мы используем для подов anti-affinity, чтобы они равномерно распределялись по нодам. В ранних версиях у планировщика Kubernetes возникала проблема производительности O(N²) из-за anti-affinity. Начиная с Kubernetes 1.18 проблема исправлена.
### Gang scheduling — параллельное планирование
В экспериментах мы часто используем один или несколько StatefulSet, причем каждый работает в отдельной части проекта машинного обучения. Для оптимизаторов исследователям нужно, чтобы все члены StatefulSet были запланированы до начала обучения (потому что мы часто используем MPI для координации членов оптимизаторов, а MPI чувствителен к изменениям членства в группе).
По умолчанию Kubernetes не обязательно назначает приоритет для запросов от того или иного StatefulSet. Например, если два эксперимента запросили 100% емкости кластера, Kubernetes не планирует один из экспериментов полностью, а, допустим, берет по половине подов каждого эксперимента, что приводит к дедлоку и остановке обоих экспериментов.
Мы поэкспериментировали с кастомным планировщиком, но столкнулись с пограничными случаями, которые приводили к конфликтам с планированием обычных подов. В Kubernetes 1.18 появилась архитектура плагинов для основного планировщика Kubernetes, благодаря чему нативно добавлять такие фичи стало куда проще. Недавно мы остановились на [плагине Coscheduling](https://github.com/kubernetes/enhancements/pull/1463).
Нерешенные проблемы
-------------------
Мы решили еще не все проблемы с увеличением масштаба кластеров Kubernetes. Например:
#### Метрики
При нашем масштабе у нас возникает немало трудностей со встроенной СУБД для хранения временных рядов в Prometheus — сжатие происходит очень медленно, а для воспроизведения WAL при каждом перезапуске требуется очень много времени. Запросы часто приводят к ошибкам «query processing would load too many samples» — при обработке запроса будет загружено слишком много сэмплов. Сейчас мы переходим на другое хранилище и движок запросов, совместимые с Prometheus.
#### Шейпинг трафика для подов
В наших растущих кластерах для каждого пода рассчитывается определенная пропускная способность интернет-соединения. В итоге совокупная пропускная способность на человека сильно выросла, и теперь наши исследователи могут случайно вызвать нехватку ресурсов в других местах, например для загрузки наборов данных и установки пакетов программного обеспечения.
Заключение
----------
Мы считаем, что гибкая платформа Kubernetes отлично подходит для наших исследовательских задач. Ее масштаб можно увеличить для самых требовательных рабочих нагрузок. Пока, конечно, не все еще идеально, так что команда по супервычислениям в OpenAI продолжает изучать возможности масштабирования в Kubernetes. | https://habr.com/ru/post/558168/ | null | ru | null |
# Установка Yggdrasil Network на Windows
Найти общую [информацию](https://habr.com/ru/post/547250/) о Yggdrasil на русском языке не составляет труда. Однако, как показала практика, многие пользователи сталкиваются с трудностями при установке клиента сети. По заявкам трудящихся рассмотрим в этой статье установку и начальную конфигурацию Yggdrasil Network на компьютере под управлением операционной системы Windows.
Скачать и установить
--------------------
Протокол Yggdrasil, как и официальный клиент сети, являются полностью открытыми и бесплатными. В силу этого скачивать установочные бинарные файлы можно только из официальных источников, так как любые попытки распространения программы через другие каналы вызывает опасение: вероятно, скачав с другого места, вы установите не только Yggdrasil, но и вредоносное ПО.
Для загрузки перейдите на [страницу релизов](https://github.com/yggdrasil-network/yggdrasil-go/releases) официального гит-репозитория. Для Windows клиент сети Yggdrasil распространяется в виде службы (сервиса), установочный файл имеет расширение `msi`.
Если вы используете Windows 7 или Windows Server 2008 R2, согласно [документации](https://yggdrasil-network.github.io/installation-windows.html) вам необходимо перед установкой Yggdrasil поставить патч KB2921916: [x64](https://download.wireguard.com/windows-toolchain/distfiles/Windows6.1-KB2921916-x64.msu), [x32](https://download.wireguard.com/windows-toolchain/distfiles/Windows6.1-KB2921916-x86.msu). Без него виртуальный сетевой адаптер WireGuard может работать некорректно.
Установка msi-пакета не требует каких-либо дополнительных действий кроме клика, а процесс установки занимает около минуты. После установки в системе появится служба Yggdrasil. Чтобы увидеть ее, наберите "Службы" в меню Пуск (либо "services.msc") и нажмите Enter.
Windows 10Также в операционной системе появится новый сетевой адаптер WireGuard, который можно найти в Панели управления, в разделе "Центр управления сетями и общим доступом".
Чтобы открыть свойства подключения, кликните на подсвеченную кнопку "Yggdrasil".
Начальная конфигурация
----------------------
По умолчанию Yggdrasil автоматически находит других участников в локальной сети. Чтобы эта опция работала практически, необходимо включить "IP версии 6" на остальных (реальных) сетевых интерфейсах компьютера.
Связь с глобальным сегментом Yggdrasil, который не ограничивается вашей локальной сетью, обеспечивается подключением к публичным пирам хотя бы одного устройства в вашей локальной сети. Для поиска публичных пиров можете воспользоваться официальным [списком](https://publicpeers.neilalexander.dev/).
Выбирайте те, которые выделены зеленымАдреса публичных пиров нужно прописать в конфигурационном файле Yggdrasil (как правило, достаточно двух). По умолчанию файл находится по адресу: `%programdata%\yggdrasil\yggdrasil.conf`.
Публичные пиры указываются в секции `Peers` следующим образом:
```
Peers: [
tcp://domainexample.com:50001
tls://123.123.123.123:8443
]
```
Если вы используете Windows 7, текстовый редактор по умолчанию может испортить кодировку конфигурационного файла, поэтому рекомендуется использовать сторонние текстовые редакторы вроде AkelPad, NotePad++ и прочие, сохраняющие исходную кодировку конфига (UTF-8).
Чтобы изменения вступили в силу, необходимо перезапустить службу Yggdrasil: клик правой кнопкой мыши на "Yggdrasil Service" в списке сервисов, затем выбор пункта "Перезапустить".
Если все сделано правильно, после перезапуска Yggdrasil ваш компьютер имеет выход в глобальный сегмент сети: вы можете открывать сайты, использовать игровые серверы и разворачивать в сети Yggdrasil свои общедоступные сервисы.
Чтобы убедиться в работоспособности, попробуйте открыть какой-нибудь адрес из официального [списка](https://yggdrasil-network.github.io/services.html) публичных сервисов, которые держат энтузиасты. Например, `http://[324:71e:281a:9ed3::41]/`. Если веб-браузер отобразил страницу, а не ошибку, можно праздновать победу.
Безопасность
------------
Этот мануал был бы злом, если не упомянуть о большой опасности. После установки Yggdrasil, ваш компьютер имеет выделенный IPv6-адрес, к которому в рамках сети может обратиться любой желающий. Обыкновенно о настройке файерволла помнят лишь администраторы с опытом, а бытовой пользователь пиратской версии Windows вовсе живет с отключенной службой безопасности.
Вы должны убедиться, что служба Защитника на вашем устройстве включена. Для этого перейдите в Панель управления и выберите соответствующий пункт меню.
Для включения и отключения Брандмауэра используйте пункт меню слева, который выделен на скриншоте красной рамкой. Если какие-то приложения после включения Защитника не будут работать корректно, помните, что в интернете много материала о грамотной настройке Брандмауэра. Включение службы безопасности необходимо, так как она предотвратит большинство злонамеренных обращений к вашему компьютеру, направленных на взлом операционной системы и кражу информации. ~~Если, конечно, это запрос не от Microsoft.~~
Если вы пользуетесь общими папками (протокол ActiveDirectory, SMB), нужно позаботиться о доступе к вашим "расшаренным" папкам по паролю, чтобы злоумышленники и хулиганы случайно не получили доступ к вашим файлам, подключившись через Yggdrasil. С возможностями приходит ответственность, дорогой друг! | https://habr.com/ru/post/567012/ | null | ru | null |
# Распознаем медицинские тексты
Это третья публикация в рамках цикла статей по изучению московской базы ковидных больных. В настоящей работе были созданы векторные представления медицинских терминов, которые теперь доступны на Github. Любой разработчик может использовать их в своих исследовательских целях.
Предыдущие мои публикации можно найти по ссылкам:
1. [Мегаанализ распространения Covid-19 в Москве](https://habr.com/ru/post/580434/)
2. [Влияние загрязнения воздуха на тяжесть течения Covid- 19](https://habr.com/ru/post/581266/)
### Преамбула
Напомню, что автору в руки попала обезличенная база московских больных Covid-19 (без ФИО и информации из каких- либо личных документов). В ней содержатся записи о примерно 106 тыс. пациентах, для каждой из которых есть как ряд характеристик, так и в свободной форме написанные комментарии. Их оставлял медицинский персонал в нескольких случаях:
1. По результатам телефонного разговора.
2. Описание по факту первичного выезда бригады СМП (скорой медицинской помощи) к заболевшему.
3. Комментарий при лечении в стационаре / нахождения на карантине / долечивании на дому.
Разумеется появилось желание получить полезную информацию из этих полей. Было принято решение кластеризовать все тексты по их тематическому содержанию. После этого выбрать набор наиболее частых тем, которые создадут новые фичи. Останется получить проекции каждого текста на ранее отобранные темы, тем самым заполняя фичи конкретными значениями.
Но, к сожалению, готовые модели погружения слов в векторное пространство (т.н. word embeddings) при эксперименте дали ужасный результат на медицинской тематике. Они абсолютно не годились для поставленной задачи. Поэтому было принято решение самостоятельно создать отображение медицинских терминов в векторное пространство.
### Создание векторного отображения
Изначальный план был таков: взять векторное погружение слов общей практики и дообучить его на медицинской тематике. В качестве словарной базы использовались подшивки медицинских журналов, поскольку в них содержися более "живой" язык (по сравнению с книжным). Таким образом полная медицинская база состояла из:
1. Журнал "Consillium medicum" (2004- 2012)
2. Журнал "Клиницист" (2006- 2016)
3. Журнал "Врач- аспирант" (2004- 2010)
4. Журнал "Кардиология" (1996- 2004)
5. Журнал "Лечащий врач" (2010- 2020)
6. "Сибирский медицинский журнал" (2004- 2011)
7. Журнал "Трудный пациент" (2006-2014)
8. Журнал "Туберкулёз и болезни лёгких" (2010- 2017)
9. 30 медицинских книг
10. Текстовые комментарии московской базы ковидных больных (~80 тыс. штук).
Оказалось, что импортировать pdf- журналы в txt- формат не так- то просто: дело в том, что текст в них разбит на колонки и при использовании импорта различных pdf- просмотрщиков, получалась каша. Поэтому для конвертации журналов в текст использовался собственный модуль, основанный на библиотеке [PyMuPDF](https://pymupdf.readthedocs.io/en/latest/index.html). Она позволяет последовательно читать все блоки с pdf- страницы, тем самым получая упорядоченный текст. За счет использования собственного алгоритма импорта появилась возможность алгоритмически удалить "мусорный" текст: список используемой литературы (иногда на несколько страниц!), контактная информация авторов, замечания о конфликте интересов, колонтитуллы. Также удалялись 7 первых и 6 последних страниц в каждом журнале, поскольку как правило этот диапазон страниц содержит рекламу и организационную информацию (оглавнение, приветствие редакции, планы выпуска журнала....)
После импорта журналов в текстовый формат получилась папка размером 385 МБ, а текст всех книг потребовал 26 МБ дискового пространства. Для сравнения напишу, что все 4 тома романа "Война и мир" Л.Н. Толстого в тектовом формате составляют примерно 3 МБ.
На первый взгляд размер словарной базы кажется большим, но оценка сильно зависит от размерности векторного представления: чем выше размерность векторного пространства, тем более разреженно в нем "находятся" слова. Поэтому для качественного представления небольшого корпуса слов (подобного тому, что представлен в настоящей статье для медицинской тематики) желательно использовать низкоразмерное векторное представление.
К сожалению, для русского языка в свободном доступе нашлись только 300- мерные представления слов общей практики. Небольшой объем медицинских терминов "растворился" бы в этой бездне, показывая что все слова между собой очень далеки. Поэтому план изменился: было решено получить также базу слов общей практики и на обоих базах самостотяельно обучить 48-ми, 64-ех и 100- мерные векторные представления.
В качестве словарной базы общей практики использовались:
1. [Сборник учебной литературы гуманитарных специальностей](https://rutracker.org/forum/viewtopic.php?t=1369152)
2. [180 студенческих учебников [DOC]](https://rutracker.org/forum/viewtopic.php?t=299421)
После импорта в тексовый формат общеязыковая база составила 705 МБ (а обе базы вместе ~1.1 ГБ).
При выполнении обучения использовались два лемматизатора pymorphy2 и pymystem3. Последний использовался только в случае, если pymorphy2 предлагал слово из словаря FakeDictionary (т.е. не находил слова и начинал заниматься предположениями). В качестве токенизатора использовался старый добрый nltk.
Общее количество слов в наборах составило 45 млн, из них уникальных- 302 тыс. При этом было принято решение проводить отбраковку редких слов на уровне не менее 30 использований (против 5, используемых по- умолчанию). Это позволяет значительно более качественно понять статистику контекстов использования слов, по которым далее будет происходить сопоставление слов между собой. Конечно, это сильно снизило итоговую языковую "мощность": векторизуемое моделью word2vec количество слов составило 44 млн, а уникальных- всего 41 тыс. слов.
При обучении word2vec все исследователи столкнутся с проблемой нехватки памяти. Дело в том, что для обучения модели общий объем текстов необходимо хранить в виде отдельных слов, что в Python реализованно неэффективно. Gensim предлагает использовать периодическую подгрузку данных с диска, что очевидно сильно замедляет обучение. Поэтому был придуман альтернативный вариант: хранение данных в оперативной памяти в сжатом виде. Для этого использовался класс, который умеет "на лету" сжимать и разжимать данные:
```
import zlib
class CompressedCorpus:
COMPRESSION_LEVEL = 2
def __init__(self):
self.compressed_corpus = []
def add_compressed_sentences(self, sentences):
self.compressed_corpus.extend(sentences)
@staticmethod
def compress_sentences(sentences):
bin_data = pickle.dumps(sentences)
return zlib.compress(bin_data, level=CompressedCorpus.COMPRESSION_LEVEL)
def __iter__(self):
for compressed in self.compressed_corpus:
bin_data = zlib.decompress(compressed)
sentences_of_document = pickle.loads(bin_data)
for sentence in sentences_of_document:
yield sentence
```
В результате выполнения обучения с помощью пакета [gensim](https://radimrehurek.com/gensim/index.html) были получены [векторные представления медицинских терминов](https://github.com/AlekseyPython/word2vec_for_medical_corpus) (выбирайте подходящую для вас размерность векторного пространства).
После экспериментов оказалось, что 64- мерное представление слов показывает в решаемой задаче примерно на 20% более качественный результат, по сранению со 100- мерным. Насколько падает качество у 300- мерных векторов, можно только догадываться. Напомню, что при сравнении вариативности пространств нельзя *линейно* сравнивать их "мерности", необходимо использовать экспоненциальный закон. 48- мерное пространство показало схожие результаты, но иногда появлялся шум, из- за близости векторов.
Теперь любой желающий может их использовать для анализа текстов медицинской тематики:
```
from gensim import models
model = models.Word2Vec.load(file_with_word_embeddings)
```
Созданная модель так определяет близкие слова:
Болезнь('заболевание', 0.8347288966178894), ('патология', 0.7339873909950256), ('криз', 0.6073477268218994), ('хронический', 0.5976685285568237), ('недуг', 0.595315158367157), ('рак', 0.5917460322380066), ('невроз', 0.5848156809806824), ('поражение', 0.58390212059021), ('алкоголизм', 0.5755941271781921), ('расстройство', 0.5720771551132202), ('цирроз', 0.5429321527481079), ('недостаточность', 0.541659951210022), ('инфекция', 0.5362805128097534), ('колит', 0.5339022874832153), ('изсда', 0.5326570272445679), ('порок', 0.5312889218330383), ('энцефалопатия', 0.5306264162063599), ('ревматизм', 0.5263662934303284), ('синдром', 0.5193524956703186), ('нездоровье', 0.5097973346710205), ('амилоидоз', 0.5093125104904175), ('травма', 0.4981701970100403), ('мононуклеоз', 0.4978249669075012), ('гепатит', 0.4869999587535858), ('астма', 0.4858018755912781), ('перенапряжение', 0.484466016292572), ('осложнение', 0.4818928837776184), ('десинхроноз', 0.479522705078125), ('декомпенсация', 0.47163745760917664), ('остеохондроз', 0.4713606834411621), ('дерматоз', 0.46962982416152954), ('психоз', 0.46953797340393066), ('переутомление', 0.4688436985015869), ('дерматит', 0.46865373849868774), ('страдать', 0.4686203896999359), ('эндартериит', 0.4673176407814026), ('инфаркт', 0.4647698700428009), ('диатез', 0.46466541290283203), ('анемия', 0.46290749311447144), ('злокачественный', 0.462791383266449), ('псориаз', 0.4598379135131836), ('колика', 0.4569317400455475), ('ХНЗЛ', 0.4564151465892792), ('холелитиаз', 0.45443031191825867), ('глаукома', 0.453472763299942), ('порфирий', 0.4516097605228424), ('повреждение', 0.44984397292137146)
Врач('терапевт', 0.8099639415740967), ('медсестра', 0.7456645369529724), ('педиатр', 0.7449079155921936), ('стоматолог', 0.7308368682861328), ('врачебный', 0.7181729078292847), ('психиатр', 0.6961877942085266), ('невролог', 0.6842734813690186), ('поликлиника', 0.6683478355407715), ('медперсонал', 0.6595726013183594), ('посоветоваться', 0.6528365015983582), ('хирург', 0.6513217091560364), ('специалист', 0.64706951379776), ('фтизиатр', 0.6451202034950256), ('клиницист', 0.6442852020263672), ('отоларинголог', 0.6421664953231812), ('психоневролог', 0.6258573532104492), ('участковый', 0.6253350973129272), ('фельдшер', 0.6252065896987915), ('инфекционист', 0.6225680112838745), ('гинеколог', 0.6195974946022034), ('консультант', 0.6157099604606628), ('медик', 0.6129191517829895), ('медработник', 0.6103352904319763), ('психолог', 0.6088686585426331), ('анестезиолог', 0.6054319739341736), ('интернистый', 0.6031010150909424), ('уролог', 0.6026933193206787), ('провизор', 0.6022548079490662), ('патоморфолог', 0.6018158197402954), ('аллерголог', 0.5998104214668274), ('онколог', 0.5932439565658569), ('ассистент', 0.5927863717079163), ('пульмонолог', 0.5913029909133911), ('дерматолог', 0.5836321711540222), ('эндокринолог', 0.5816663503646851), ('лаборант', 0.581134557723999), ('сотрудник', 0.5809362530708313), ('акушер', 0.5761595368385315), ('психотерапевт', 0.5734131336212158), ('консультировать', 0.572510302066803), ('дежурный', 0.5693656206130981), ('нарколог', 0.5685620307922363), ('консультация', 0.5656259655952454), ('медицинский', 0.5599374175071716), ('дерматовенеролог', 0.5597026944160461), ('куратор', 0.5589353442192078)
Терапия('лечение', 0.9110350012779236), ('химиотерапия', 0.744488000869751), ('фармакотерапия', 0.7268965840339661), ('монотерапия', 0.64706951379776), ('антибиотикотерапия', 0.6396688222885132), ('препарат', 0.6288763880729675), ('коррекция', 0.5847635269165039), ('психофармакотерапия', 0.5735004544258118), ('гормонотерапия', 0.5589482188224792), ('терапевтический', 0.5570299029350281), ('абт', 0.5562933683395386), ('пхт', 0.5462656617164612), ('ивл', 0.5368460416793823), ('полихимиотерапия', 0.5262065529823303), ('инсулинотерапия', 0.522721529006958), ('иммунотерапия', 0.5146833062171936), ('обезболивание', 0.5121416449546814), ('купирование', 0.5090704560279846), ('медикаментозный', 0.49881476163864136), ('арвт', 0.4972829222679138), ('интерферонотерапия', 0.4958414137363434), ('асит', 0.4925050437450409), ('гкс', 0.4923551380634308), ('птт', 0.4913291931152344), ('агт', 0.48378074169158936), ('диетотерапия', 0.48257237672805786), ('госпитализация', 0.4796653091907501), ('реабилитация', 0.47430941462516785), ('психотерапия', 0.45638275146484375), ('тромбопрофилактика', 0.4539289176464081), ('кардиоверсия', 0.4508218765258789), ('химиопрофилактика', 0.44811952114105225), ('арв', 0.44347259402275085), ('профилактика', 0.4431573152542114), ('ваарт', 0.44169166684150696), ('кислородотерапия', 0.4411754906177521), ('кардиореабилитация', 0.43889859318733215), ('тренировка', 0.43811100721359253), ('комбинация', 0.4334109127521515), ('глюкокортикоид', 0.4329511821269989), ('фототерапия', 0.43233123421669006)
Выздоровление('излечение', 0.8492449522018433), ('ремиссия', 0.7511098384857178), ('регресс', 0.6205442547798157), ('самоизлечение', 0.5908384323120117), ('абациллирование', 0.5902377367019653), ('заживление', 0.5882741212844849), ('исчезновение', 0.5830905437469482), ('рецидив', 0.578253984451294), ('реконвалесценция', 0.5771373510360718), ('эпителизация', 0.5687963366508484), ('выздороветь', 0.5515270829200745), ('наступление', 0.5395905375480652), ('отпадение', 0.5310086011886597), ('эрадикация', 0.52912837266922), ('разрешиться', 0.525256872177124), ('возвращение', 0.5203354358673096), ('рубцевание', 0.5192395448684692), ('летально', 0.5173105001449585), ('возобновление', 0.5164587497711182), ('персистирование', 0.514289140701294), ('купирование', 0.5132368803024292), ('стихание', 0.5030621290206909), ('окл', 0.5023788809776306), ('рассасывание', 0.500794529914856), ('хронизация', 0.5003021955490112), ('умирание', 0.4988389313220978), ('завершение', 0.4983193278312683), ('исход', 0.4963388442993164), ('ресоциализация', 0.49621516466140747), ('обострение', 0.49614015221595764), ('бесповоротный', 0.4908732771873474), ('негативация', 0.48786062002182007), ('выздоравливать', 0.4863669276237488), ('выписка', 0.4859303832054138), ('восстановление', 0.4747615456581116), ('санировать', 0.47448742389678955), ('лечение', 0.4742755889892578), ('прогрессирование', 0.4742307960987091), ('санация', 0.47037824988365173), ('карантин', 0.46836093068122864), ('трудоспособность', 0.468219131231308)
**Кластеризация**
С помощью полученного представления удалось векторизовать все тексты, характеризующие состояние и лечение пациентов (как средне- арифметическое всех входящих в текст слов). Существует несколько методик, позволяющих оценить оптимальное количество кластеров.
Метод локтя не показывает ярко выраженной точки перегиба, позволяющей установить оптимальное количество кластеров. Хотя в диапазоне между 5 и 10 кластерами происходит заметное снижение искажений.
Построение среднего значения коэффициента силуэтов показывает остановку быстрого роста в диапазоне 7- 12 кластеров.
Информационные критерии Акаике и Байесса, полученные с помощью кластеризации Gaussian Mixture, переходят на "плато" в диапазоне 4- 12 кластеров. Все же не надо забывать, что подобный метод выбора числа кластеров представляет собой меру успешности работы GMM как оценивателя плотности распределения, а не как алгоритма кластеризации.
Посмотрим на размеры получаемых кластеров: глупо выделять кластеры, в которые входит небольшое количество объектов. Необходимо заранее задать примерно верное количество кластеров, чтобы получить корректные размеры каждого кластера (исходя из предыдущих оценок, было использованно значение 10). По графику можно принять осторожное решение о выделении до 9 кластеров.
За всей этой батареей методов был упущен из вида самый простой и очевидный подход: так как мы кластеризуем тексты, то можно найти максимально близкие слова к каждому кластеру и предоставить их пользователю для анализа. Так было установлено, что 7 кластеров имеют независимые непересекающиеся тематики (это важно, поскольку мы по сути ищем базис, на который позже будем искать проекции).
После выбора оптимального количества кластеров была успешно проведена кластеризация алгоритмом K- means (в качестве конкурентов у него были методы "Gaussian mixture" и "OPTICS", которые показали более худший результат). Это позволило в векторном пространстве обнаружить центры 7-ми популярных текстовых тематик (как центры кластеров). Используя косинусное расстояние между нормированными векторами текстов и центров кластеров, были получены проекции каждого текста на популярные тематики.
А стоит ли устанавливать значения проекций для всех фичей- кластеров? Может чтобы не было лишнего "шума" стоит устанавливать значение только для кластера с максимальной проекцией, или для нескольких, чья проекция близка к максимальной? Ведь большинство слов посвящено одной тематике (медицина) и возможно предположить, что тексты будут близки друг к другу независимо от своего содержания. Как определить размер близости косинусных расстояний, который задаст "серьезные" проекции? Для этого можно использовать вложенную кластеризацию, которая отделит между собой группы близких и далеких проекций. Получается кластеризация в кластеризации.
После выполнения "вложенной" кластеризации "важными" проекциями оказались те, чье косинусное расстояние не меньше, чем 0.785 от максимальной проекции. Этим фичам устанавливалось значение проекции, а все остальные проекции считались шумовыми и их фичи получали значение 0.
В противовес изложенному выше подходу была опробирована идея более слабого ограничения на количество кластеров (20 и даже 30 выявляемых тематик) с последющим сжатием пространства методом главных компонент (PCA). Это не принесло улучшения по сравнению с первоначально предложенным вариантом.
**Заключение**
С новыми фичами было достигнуто улучшение качества обучения Catboost, который занимался предсказанием тяжести заболевания и смерти пациентов. Например, по метрике Каппа Коэна улучшение составило почти 5% и, например, для предсказания смерти пациента достигло 84% (при этом с помощью анализа ShapValues было подтверждено отсутствие утечек).
Надеюсь мое решение поможет другим в достижении успеха на исследовательской ниве. | https://habr.com/ru/post/581408/ | null | ru | null |
# Как проанализировать рынок фотостудий с помощью Python (3/3). Аналитика
Каждый, кто открывает свой бизнес, хочет угадать идеальный момент открытия, найти идеальное место и выполнить точные, эффективные действия для того, чтобы бизнес выжил и приумножился. Найти идеальные параметры невозможно, но оценить наилучшие возможности помогают инструменты статистического анализа.
В открытых источниках содержится огромное количество полезной информации. Правильный ее сбор, хранение и анализ помогут найти оптимальные возможности для бизнеса.
Группа молодых предпринимателей рассматривала вариант открытия своей фотостудии в Москве. Им необходимо было узнать:
* какое общее состояние рынка фотостудий: растет, стабильный или падает?
* какова сезонность рынка?
* сколько они смогут заработать?
* где лучше открывать залы?
* какую сумму вкладывать в проект?
* на сколько сильная конкуренция на рынке?
Ответить на эти и многие другие вопросы им помогли [простой парсер](https://habr.com/ru/post/504900/), [база данных](https://habr.com/ru/post/512208/) и приведенная в это статье аналитика.
В [первой статье](https://habr.com/ru/post/504900/) мы рассмотрели парсинг сайта-агрегатора фотостудий [ugoloc.ru](http://ugoloc.ru) и выгрузили общую информацию о фотостудиях, залах и данные по бронированию залов.
Во [второй статье](https://habr.com/ru/post/512208/) мы рассмотрели запись полученных данных в БД и чтение данных из БД, а также настроили работу парсинга в зависимости от информации в БД.
В данной статье мы проведем простой анализ собранных данных.
Готовый проект с примерами таблиц из базы данных, промежуточных таблиц, графиков, доп.комментариями вы можете найти на моей странице в [github](https://github.com/dmitry-data-science/studios).
### Какие направления для анализа мы будем использовать
* определим динамику открытия фотостудий;
* вычислим прибыльность фотостудий в зависимости от месяца открытия;
* определим сезонность бизнеса;
* вычислим средний доход на зал, а также оптимальное количество залов у фотостудии;
* исследуем зависимость доходности от расположения фотостудии;
* выясним количество залов у студий-конкурентов;
* рассчитаем влияние прочих параметров на доход, таких как высота потолков, площадь залов, цены бронирования;
* рассмотрим другие возможные направления анализа.
### Выгрузка данных из БД
Для выгрузки выполняем следующие действия:
**устанавливаем соединение с базой**
```
directory = './/'
conn = sqlite3.connect(directory + 'photostudios_moscow1.sqlite')
cur = conn.cursor()
```
**выгружаем данные по студиям**
```
studios = db_to_studios(conn)
studios
```
**по залам**
```
halls = db_to_halls(conn)
halls
```
**по бронированию**
```
booking = db_to_booking(conn)
booking
```
**оставляем студии с датами открытия и исключаем гримерки из списка залов**
```
studios = studios[[x.year > 0 for x in studios['established_date']]]
halls = halls[halls['is_hall'] == 1]
```
### Динамика открытия фотостудий по годам
Построим частотную гистограмму открытия фотостудий по разным годам. Для этого вычисляем количество периодов (лет) и строим гистограмму.
**построение гистограммы**
```
num_bins = np.max(studios['established_date']).year - np.min(studios['established_date']).year + 1
plt.hist([x.year for x in studios['established_date']], num_bins)
plt.show()
```
На гистограмме видим явный рост новых фотостудий из года в год. Эта закономерность говорит нам не о фактическом росте рынка в 2 раза ежегодно, а, скорее, о росте самого агрегатора.
Данный факт говорит нам о необходимости разделения студий на 2 категории: зарегистрировавшиеся на агрегаторе при открытии фотостудии («новые») и спустя продолжительное время («старые»). Это и будет нашей следующей задачей.
### Выявление новых фотостудий
Какую фотостудию можно считать новой? Ту, которая только-только раскручивается и набирает клиентов. По визуальному анализу календарей бронирования от момента открытия видно, что стабильный поток клиентов студия набирает за несколько месяцев.
Получается, чтобы отличить новую фотостудию от старой (которая не сразу присоединилась к агрегатору), нужно сравнить доход за первые полмесяца с момента «открытия» с аналогичным периодом годом позже. У новых студий за год доход должен существенно вырасти, у старой — остаться, примерно, на том же уровне.
**Вначале объединим все таблицы и оставим только забронированные часы**
```
# merge all tables
data = (booking
.merge(halls, left_on = 'hall_id', right_on = 'hall_id', how = 'inner')
.merge(studios, left_on ='studio_id', right_on = 'studio_id', how = 'inner')
)
data = data[data['is_working_hour'] == 1]
data['date'] = pd.to_datetime(data['date'])
data
```
**Затем вычислим доход в первые полмесяца работы фотостудии**
```
first_month = (data[data['date'] <= [x + datetime.timedelta(days = 15) for x in data['established_date']]]
.loc[:, ['studio_id', 'price', 'duration']]
)
first_month['income'] = first_month['price'] * first_month['duration']
first_month = first_month.groupby('studio_id').agg(np.sum)
first_month
```
**В полмесяца спустя год**
```
month_after_year = (data[(data['date'] >= [x + datetime.timedelta(days = 365) for x in data['established_date']])
& (data['date'] <= [x + datetime.timedelta(days = 365 + 15) for x in data['established_date']])
]
.loc[:, ['studio_id', 'price', 'duration']]
)
month_after_year['income'] = month_after_year['price'] * month_after_year['duration']
month_after_year = month_after_year.groupby('studio_id').agg(np.sum)
month_after_year
```
**Показатели через год разделим на аналогичные при открытии**
```
month_diff = (month_after_year.merge(first_month, left_on = 'studio_id', right_on = 'studio_id', how = 'inner')
.merge(halls.groupby('studio_id').count()
, left_on = 'studio_id', right_on = 'studio_id', how = 'inner')
)[['income_x', 'income_y', 'is_hall']]
month_diff['income_diff'] = (month_diff['income_x'] / month_diff['income_y']) ** (1 / month_diff['is_hall'])
month_diff.sort_values('income_diff')
```
Получили коэффициент роста дохода спустя год. Показатель у разных студий распределен от 0,75 до 2,1 без резких скачков. Это говорит о том, что студия могла подключиться к агрегатору сразу после открытия, спустя неделю, месяц, год и т.д.
Для определения новых фотостудий возьмем условное значение коэффициента роста дохода в значении медианы: 1,18. Т.е. если доход фотостудии за год вырос более, чем на 18%, то будем считать эту фотостудию новой. Таких студий получилось 22.
### В какой месяц лучше открывать фотостудию?
Мы вычислили фотостудии, которые зарегистрировались на агрегаторе через короткое время после открытия. Поэтому фактический день открытия и день открытия по нашим данным у этих студий будем считать одинаковыми.
Для расчета мы возьмем новые фотостудии, посчитаем доход как сумму цен бронирования всех забронированных часов, сгруппируем по залам (с учетом месяца его открытия), посчитаем среднее значение годового дохода по месяцам открытия.
**Расчет среднего дохода за год в зависимости от месяца открытия**
```
new = studios['is_new'].reset_index().merge(data, left_on = 'studio_id', right_on = 'studio_id', how = 'inner')
new = new[new['is_new'] == 1]
new = new[new['date'] <= [x + datetime.timedelta(days = 365) for x in new['established_date']]]
new['est_year'] = [x.year for x in new['established_date']]
new['est_month'] = [x.month for x in new['established_date']]
new['income'] = new['price'] * new['is_booked']
mean_income = (new
.groupby(['hall_id', 'est_year', 'est_month']).agg('sum')['income'].reset_index()
.groupby('est_month').agg('mean')['income']
plt.bar(range(1, 12), mean_income)
plt.show()
)
```
На гистограмме видим четкую зависимость:
* лучшие месяцы для открытия фотостудии — начало года (январь-апрель)
* также хорошими месяцами для открытия являются сентябрь-октябрь;
* худшими месяцами являются май-июнь.
Интересно будет сравнить эти данные с сезонностью рынка.
### Определение сезонности бизнеса
Сезонность — изменение количества заказов в зависимости от периода. Проанализируем годовую сезонность.
Для расчета возьмем студии, открытые до 2018 года и посмотрим их брони за 2018-2020 года. Доход студии определяем как сумму цен за забронированные часы. Далее считаем суммарный доход всех студий по каждому месяцу выбранного периода.
**Расчет сезонности**
```
season = data[(data['open_date'] < '2018-01-01') & (data['date'] > '2018-01-01')]
season['income'] = season['price'] * season['duration']
season['year'] = [x.year for x in season['date']]
season['month'] = [x.month for x in season['date']]
incomes = season.groupby(['year', 'month']).agg(np.sum)['income']
incomes = incomes[incomes.index]
```
**Построение графика**
```
incomes = incomes[: -3]
plt.figure(figsize = (20, 10))
plt.plot([str(x[0]) + '-' + str(x[1]) for x in incomes.index], incomes)
plt.xticks(rotation=60)
plt.grid()
plt.show()
```
На графике видим четко выраженную сезонность: наибольшее количество заказов с октября по апрель и резкое падение с мая по сентябрь. Сезонность укладывается в логику бизнеса. В летний период люди фотографируются на улице, в парках. В зимний период такой возможности нет, и устраивать фотосессии приходится в помещении. С этим и связана сезонность: летом клиентов мало, зимой много. Пик заказов приходится на декабрь. Вероятно, это связано с Новым годом и ощущением праздника, которое хочется запечатлеть на фотографии.
Наилучшие месяцы для открытия связаны сезонностью. Открывать студию лучше в сезон или за месяц до его начала. В период с мая по август студию открывать не стоит, т.к. попадем в несезон.
### Расчет доходности зала
Важным показателем для открываемого бизнеса является доход с одного зала.
Для расчета группируем доходы по залам по каждому месяцу, исключаем 2020 год как аномальный в виду карантина и смотрим выборку доходов функцией .describe().
**Расчет доходности 1 зала**
```
hall_income = season.groupby(['studio_id','hall_id', 'year', 'month']).agg(sum)['income'].reset_index()
hall_income = hall_income[hall_income['year'] < 2020]
hall_income['income'].describe()
```
```
count 648.000000
mean 184299.691358
std 114304.925311
min 0.000000
25% 95575.000000
50% 170350.000000
75% 256575.000000
max 617400.000000
Name: income, dtype: float64
```
Получили доход на 1 зал в рублях.
Из данных по персентилям видно, что доход половины залов укладывается в интервал от 95 000 руб. до 256 000 руб. с медианным значением в 170 000 руб.
Из данных по средней и стандартному отклонению видим, что согласно правилу 1 сигмы две трети залов приносят от 70 000 руб. до 300 000 руб. с серединов в 184 000 руб.
Получается, средний зал может рассчитывать на доход в 170 000 — 180 000 руб. ± 80 000 руб.
Такой большой разброс объясняется влиянию прочих факторов, которые в дальнейшем постараемся определить.
#### Сколько залов открыть в фотостудии?
Для расчета вычислим среднюю месячную доходность на каждый зал, вычислим среднюю доходность зала на фотостудию, посчитаем количество залов в фотостудии и сгруппируем данные по количеству залов, рассчитав среднюю доходность на 1 зал.
**Расчет доходности зала в зависимости от количества залов в фотостудии**
```
(hall_income
.groupby(['studio_id', 'hall_id']).agg('mean').reset_index()
.groupby('studio_id').agg(['count', 'mean'])['income']
.groupby('count').agg('mean')
)
```
```
mean
count
1 134847.916667
2 146531.944444
3 300231.944444
4 222202.604167
```
Получили среднемесячную доходность 1 зала в зависимости от количества залов в фотостудии. Заметим закономерность: чем больше залов, тем больше доходность. Максимальная доходность у студий с 3 залами.
Это явление связано с тем, что воспользовавшись одним залом фотостудии, клиент может увидеть другой зал и сразу его забронировать. Таким образом, один зал фотостудии «продвигает» другие.
### Зависимость дохода от расположения зала
Местоположение зала может сильно влиять на доходность: в центре залы будут доступнее для клиентов, а значит, доход будет выше. Проверим гипотезу.
Для расчета посчитаем среднемесячную доход зала, сгруппируем по признаку «метро» и отсортируем в порядке возрастания.
**Доходность зала в зависимости от удаленности от центра**
```
data['income'] = data['price'] * data['duration']
data['year'] = [x.year for x in data['date']]
data['month'] = [x.month for x in data['date']]
(data
.groupby(['hall_id', 'metro', 'year', 'month']).agg('sum')['income'].reset_index()
.groupby(['hall_id', 'metro']).agg('mean')['income'].reset_index()
.groupby('metro').agg('mean')['income'].sort_values()
)[-59:]
```
Получили следующие данные:
```
metro
электрозаводская 5016.666667
метро Алексеевская 10485.264378
Дубровка 11925.000000
Марксистская/Нижегородская 18116.666667
Новогиреево, Щелковская 19000.000000
Войковская 21963.333333
Текстильщики 30667.051729
Нижегородская 31031.250000
Нагатинская 37787.500000
Павелецкая/Добрынинская 39357.142857
Партизанская 44354.375000
Полежаевская 45888.888889
Волгоградский проспект 46566.666667
Чкаловская 48541.666667
м. Марксистская, МЦК Нижегородская 49086.503623
Красносельская 55340.659341
Речной вокзал, Митино, Комсомольская 55944.444444
м. Марксистская/ мцк. Нижегородская 59771.111111
Академика Янгеля 66780.000000
Молодежная 66847.058824
Серпуховская 67692.545788
м.Шаболовская 70090.341880
м.Алексеевская 70337.676411
Молодежная, Парк Победы 72974.494949
Кутузовская 79987.083333
Преображенская Площадь 88800.000000
Нагатинская 95550.000000
Электрозаводская 98326.086957
Алексеевская 99216.279070
99925.000000
ВДНХ и Ботанический Сад 102835.622784
м. ВДНХ, м. Ростокино, ст. Яуза\Северянин 104956.521739
Преображенская площадь 111050.684459
Киевская 111090.000000
Калужская 111909.090909
Андроновка 116426.892180
Автозаводская Тульская 117450.000000
Бауманская 118382.236364
Озерная 122626.500000
Савёловская, Марьина роща 123258.518519
Петровско-Разумовская 124557.894737
Чкаловская, Курская 126300.000000
Дмитровская 129222.916667
Павелецкая 135281.642512
Бауманская, Площадь Ильича 138945.454545
Кевская 152246.883469
Серпуховская, Павелецкая 168484.500000
м.Электрозаводская 169079.381010
м. Дмитровская 172618.798439
Электрозаводская 173777.659900
Кожуховская 178254.545455
ВДНХ 181041.818182
Трубная 187283.444198
Ботанический сад 189140.857975
Курская или Площадь Ильича 250975.000000
Крылатское, Киевская, Белорусская 252685.714286
Бауманская, Электрозаводская 264164.473684
Новые-Черемушки 277162.791991
Марьина Роща 556621.746032
Name: income, dtype: float64
```
Обращаю внимание, что данные по метро оставил как есть. Для более точной картины их нужно привести к общему формату, например, «Бауманская, Электрозаводская», «м.Электрозаводская» и «электрозаводская» записать одним названием.
Из данных видим, что в районах с дорогой недвижимостью, таких как Марьина Роща, Новые Черемушки, Крылатское, доходность на зал выше.
### Сколько залов у студий-конкурентов
Сколько залов у работающих на рынке студий? Для ответа на этот вопрос присоединим к таблице студий таблицу с залами, сгруппируем по студиям, посчитав количество залов, и построим частотную гистограмму.
**Расчет количество залов у студий**
```
hall_num = studios.merge(halls, left_on='studio_id', right_on='studio_id').groupby('studio_id').agg('count')['is_hall']
plt.hist(hall_num, range(np.min(hall_num), np.max(hall_num)+1))
plt.show()
hall_num.describe()
```
```
count 105.000000
mean 2.685714
std 2.292606
min 1.000000
25% 1.000000
50% 2.000000
75% 3.000000
max 13.000000
```
Из полученных данных видим, что у большинства фотостудий (более 75%) не больше 3 залов. На всем рынке, как правило, у студий не более 5 залов.
### Влияние других параметров на доход фотостудии
#### Высота потолка
Для фотографий нужно много света, и большие окна в помещении с высокими потолками дают много естественного света. К тому же чем выше потолки, тем более рассеянный, равномерный свет доходит до пола. Поэтому высота потолка может влиять на доходность фотостудии. Проверим эту гипотезу.
Посчитаем средний месячный доход каждого зала с сохранением данных по высоте потолка, потом рассчитаем средний доход в зависимости от высоты потолка и постоим график.
**Доход зала в зависимости от высоты потолка в метрах**
```
halls_sq_ceil = (data
.groupby(['hall_id', 'ceiling', 'square', 'year', 'month']).agg('sum')['income'].reset_index()
.groupby(['hall_id', 'ceiling', 'square']).agg('mean')['income'].reset_index()
)
plt.bar(halls_sq_ceil.groupby('ceiling').agg('mean')['income'].index[:-2],
halls_sq_ceil.groupby('ceiling').agg('mean')['income'][: len(halls_sq_ceil) - 2]
)
plt.show()
```
В полученных данных видим, что до 6 метров есть прямая зависимость доходности фотостудии от высоты потолка. Оптимальная высота — 5-6 метров.
#### Площадь залов
Гипотеза: чем больше площадь зала, тем больший доход зал приносит.
Проверяем гипотезу. Используем предыдущие расчеты, рассчитаем среднюю доходность в зависимости от площади, построим график.
**Доход зала в зависимости от его площади**
```
square = halls_sq_ceil.groupby('square').agg('mean')['income']
plt.bar(square.index[:-3],
square.iloc[: len(square) - 3]
)
plt.show()
```
На графики видна четкая закономерность: чем больше площадь, тем больше зал приносит.
#### Цена бронирования
Гипотеза: есть оптимальная цена зала, которую клиенты платить практически за любой зал. Более высокую цену клиенты готовы платить исключительно за высокое качество.
Для проверки гипотезы вначале рассмотрим текущий уровень цен. Для этого сгруппируем общую таблицу бронирования по залам, цене, году, месяцу и просуммируем доход. Затем сгруппируем по залам и цене бронирования, вычислив средний доход. Далее сгруппируем по цене, рассчитав средний доход. Получили средний месячный доход на студию в зависимости от установленной цены бронирования
**Средняя месячная доходность студии в зависимости от цены бронирования зала**
```
price = (data
.groupby(['hall_id', 'price', 'year', 'month']).agg('sum')['income'].reset_index()
.groupby(['hall_id', 'price']).agg('mean')['income'].reset_index()
.groupby('price').agg('mean')['income']
)
```
**На сколько залов установлена определенная цена за часовую аренду**
```
plt.figure(figsize = (20, 10))
plt.hist(price.iloc[: len(price) - 5].index)
plt.show()
```
Из частотной гистограммы видим, что большинство студий установило цену за аренду от 500 до 2000 руб. Ниже 500 руб. — редкость. Максимальная цена аренды зала — 3500 руб.
**График зависимости среднего месячного дохода от цены аренды зала**
```
price = price[price > 10000]
plt.figure(figsize = (20, 10))
plt.scatter(price.index, price)
plt.show()
```
На графике видно, что до 2000 руб. есть четкая прямая зависимость: чем выше установлена цена бронирования, тем больше зарабатывает студия. При цене выше 2000 руб. доход с зала может быть как низким, так и высоким. По всей видимости, более 2000 руб. клиенты готовы платить только за высокое качество оказанных услуг: либо за удобное расположение, либо за оснащенность, либо за большую площадь, либо за качественный интерьер и т.д.
### Другие направления аналитики рынка
#### Анализ оснащенность
На сайте ugoloc.ru есть информация об оснащенности фотостудий: наличие цветных фонов, марка вспышек и т.д. Оснащенность фотостудий тоже может влиять на доходность, поэтому для полноты анализа следует учесть и этот фактор.
Не все студии могут указывать наличие дополнительного оборудования. Поэтому оценка влияния данного фактора может оказаться неточной.
#### Анализ влияния нескольких параметров на доход
Параметры влияют на доход не изолированно друг от друга. Например, площадь и цена бронирования связаны и вместе влияют на общую доходность студии. Поэтому их влияние разумнее рассматривать вместе. Влияние нескольких параметров стоит рассматривать исходя из специфики запросов клиента.
#### Расширение собираемых данных
Фотостудии на сайте ugoloc.ru составляют меньше трети рынка по количеству. По доходу и сегменту рынка долю студий с данного сайта-агрегатора оценить не представляется возможным. Для более точной картины стоит собирать данные с AppEvent, Google-Календарей, возможно, и с самописных приложений по бронированию.
#### Учет расходы
Вы могли заметить, что для полноты картины часто не хватало расходов. Например, чем больше площадь зала, тем больше доход с него. Вывод, конечно, хороший, но с ростом площади растет стоимость аренды зала. Поэтому на график, безусловно, полезно будет нанести рост расхода за аренду. В оптимальном соотношении дохода и расхода по конкретному параметру и скрыта прибыльность проекта.
От площади также зависит и стоимость ремонта: чем больше площадь, тем дороже ремонт.
С ростом количество залов снижаются расходы на персонал в расчете на 1 зал, т.к. 1 администратор может обслуживать как 1 зал, так и 3.
#### Анализ удаленности от метро
При оценке влияния расположения студии на доход зала важным неучтенным фактором является удаленность от метро. Проставлять его придется вручную или, кто хорошо знаком с API Гугла, можно попробовать автоматизировать это действие.
#### Удаленность от конкурентов
Чаще всего студии располагаются близко друг к другу. На одном лишь Электрозаводе их около 40. Есть гипотеза, что близость к другим фотостудиям повышает доходность. Для клиентов может быть знакомо именно место (здание/бизнес-центр) и они могут ему доверять, что положительно скажется на всех фотостудиях локации.
#### Загруженность фотостудий
Отдельно можно исследовать загруженность фотостудий:
* какой процент времени работы зала составляют брони;
* как брони связаны с днем недели (спойлер: в выходные бронируют чаще);
* есть ли незабронированные дни (в которые администратор может не выходить на работу);
* в какие часы чаще всего бронируют (особенно интересно посмотреть по будням)
* и т.д.
#### Состояние фотостудий в несезон
Студии чаще закрываются летом, когда нет заказов. При этом, у некоторых фотостудий количество заказов несильно падает. Какие преимущества есть популярных в несезон студий? Это отдельное направление для рассмотрения.
#### Анализ доходности конкурентов
Обладая информацией о стоимости аренды помещений под фотостудию и средних зарплатах персонала, можно оценить финансовое состояние конкурентов. Может оказаться, что некоторые студии находятся на грани закрытия. Соответственно, можно выявить их ошибки и постараться их избежать.
Аналогично можно исследовать опыт наиболее прибыльных фотостудий и использовать их преимущества в своей студии.
#### Этапы анализа
Приведенная аналитика является первым этапом, дающий примерную картину рынка. Для дальнейшего анализа клиенту необходимо определиться какую студию ему бы хотелось открыть, какой ценовой сегмент, какое возможное расположение, какая стоимость аренды, какое оборудование и т.д.
Идеальный вариант: определить несколько вариантов предложений по аренде. Тогда будут определены и площадь, и высота потолков, и примерное количество залов, и расходы, и ближайшие конкуренты.
В этом случае аналитику можно проводить более предметно и точно.
### Итог
В серии статей мы рассмотрели как из открытых источников собрать данные, сохранить их в базу данных и проанализировать. Результатом работы стало общее понимание рынка услуг фотостудий.
Приведенные расчеты можно применить:
* в создании бизнес-плана в доходной части. И это будут статистически подтвержденные данные;
* в оценки целесообразности и прибыльности проекта, сравнивая доход и расход при разных вариантах открытия;
* действующим фотостудиям. Многие фотостудии простаивают без заказов или работают в убыток. Значит, они что-то делают не так. Приведенная аналитика может помочь студиям в выявлении причин своего состояния.
Мне понравилось выполнять этот проект.
Решил поделиться опытом, который вам может быть полезен.
На сколько полезна была информация в этих трех статьях?
Поделитесь своим мнением.
Готовый проект вы можете найти на моей странице в [github](https://github.com/dmitry-data-science/studios). | https://habr.com/ru/post/512848/ | null | ru | null |
# Создаем простую игру с Jetpack Compose для часов на Google WearOS
Библиотека Jetpack Compose значительно изменила подход к разработке нативных приложений и позволила декларативно описывать в коде интерфейсы, которые зависят от состояния и автоматически отслеживают его изменение. Но долгое время ее применимость ограничивалась платформой Android для телефонов и планшетов, а затем (благодаря разработкам JetBrains) стало возможным использовать реактивный стиль разработки для создания десктопных и веб-приложений. Но все еще нельзя было создавать приложения для умных часов, работающих над вариантом платформы Android - WearOS. В июле 2022 года команда разработки Android предложила первую стабильную версию Compose for WearOS, а в начале декабря вышло обновление библиотеки версии 1.1 с новыми возможностями по настройке пользовательского интерфейса и дополнительными компонентами. В этой статье мы сделаем несложную игру для WearOS с использованием Compose.
Реактивные интерфейсы в Compose определяются как функция с аннотацией @Composable, в которой формируется композиция из других компонентов (входящих в состав библиотеки компонентов или собственных). Для Jetpack Compose for WearOS список компонентов можно найти в [документации](https://developer.android.com/reference/kotlin/androidx/wear/compose/material/package-summary). Для более подробного погружения в разработку реактивных приложений на WearOS рассмотрим простой пример.
Создадим проект с внешним build.gradle:
```
buildscript {
ext {
compose_version = '1.3.2'
wear_compose_version = '1.1.0'
}
}// Top-level build file where you can add configuration options common to all sub-projects/modules.
plugins {
id 'com.android.application' version '7.3.1' apply false
id 'com.android.library' version '7.3.1' apply false
id 'org.jetbrains.kotlin.android' version '1.6.10' apply false
}
```
Для модуля проект определяется как Android-приложение, но с добавлением зависимостей:
```
plugins {
id 'com.android.application'
id 'org.jetbrains.kotlin.android'
}
android {
namespace 'tech.dzolotov.wearosgame'
compileSdk 33
defaultConfig {
applicationId "tech.dzolotov.wearosgame"
minSdk 30
targetSdk 33
versionCode 1
versionName "1.0"
vectorDrawables {
useSupportLibrary true
}
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
}
}
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
kotlinOptions {
jvmTarget = '1.8'
}
buildFeatures {
compose true
}
composeOptions {
kotlinCompilerExtensionVersion '1.1.1'
}
packagingOptions {
resources {
excludes += '/META-INF/{AL2.0,LGPL2.1}'
}
}
}
dependencies {
implementation "androidx.compose.ui:ui:$compose_version"
implementation "androidx.wear.compose:compose-material:$wear_compose_version"
implementation "androidx.wear.compose:compose-navigation:$wear_compose_version"
implementation "androidx.wear.compose:compose-foundation:$wear_compose_version"
implementation 'androidx.activity:activity-compose:1.6.1'
}
```
В AndroidManifest.xml нужно добавить в тэг manifest:
```
```
Для описания экрана необходимо определить композицию компонентов в setContent. Compostable-функции могут использоваться для размещения нескольких компонентов (например, вертикально в Column, горизонтально в Row, а также с наложением в Box), а также для представления содержания (Text, Button, Card и другие). При необходимости настройки компонента необходимо использовать модификаторы, с помощью которых можно изменять фон, отступы, возможность прокрутки, действия при нажатии и другие. Например, для отображения текста и кнопки реализация может выглядеть следующим образом:
```
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
Column(
modifier = Modifier
.fillMaxSize()
.background(MaterialTheme.colors.background),
verticalArrangement = Arrangement.Center
) {
Text(
"Hello, WearOS",
color = Color.Green,
modifier = Modifier.fillMaxWidth(),
textAlign = TextAlign.Center,
)
Card(onClick = {
Log.i(this::class.java.simpleName, "Tapped")
}, modifier = Modifier.padding(top = 8.dp)) {
Text(
"Tap me",
modifier = Modifier.fillMaxWidth(),
textAlign = TextAlign.Center,
)
}
}
}
}
}
```
Выполним сборку и установку приложения на эмулятор или реальное устройство:
```
./gradlew installDebug
```
При разработке можно определять состояние внутри Composable, или получать его из внешнего источника (например, из LiveData, Flow или MutableState). Например, мы можем добавить возможность подсчета количества нажатий, для этого дополнительно выделим изменяемую часть в отдельный компонент:
```
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
Content()
}
}
}
@Composable
fun Counter(i: Int) {
Text(
"Counter: $i",
color = Color.Green,
modifier = Modifier.fillMaxWidth(),
textAlign = TextAlign.Center,
)
}
@Composable
fun IncrementButton(onPressed: () -> Unit) {
Card(onClick = {
onPressed()
}, modifier = Modifier.padding(top = 8.dp)) {
Text(
"Tap me",
modifier = Modifier.fillMaxWidth(),
textAlign = TextAlign.Center,
)
}
}
@Composable
fun Content() {
var counter by remember { mutableStateOf(0) }
Column(
modifier = Modifier
.fillMaxSize()
.background(MaterialTheme.colors.background),
verticalArrangement = Arrangement.Center
) {
Counter(i = counter)
IncrementButton {
counter++
}
}
}
```
При локальном создании состояния необходимо обернуть его в remember { }, поскольку функция будет вызываться повторно при каждом изменении состояния и надо явным образом обозначить, что значение должно быть инициализировано только однажды и сохраняться между перезапусками. Аналогично можно сделать прокручиваемую область с размером, больше чем область экрана, для этого необходимо использовать LazyColumn и элементы в item/items.
```
@Composable
fun Content() {
var counter by remember { mutableStateOf(0) }
LazyColumn(
modifier = Modifier
.fillMaxSize()
.background(MaterialTheme.colors.background),
verticalArrangement = Arrangement.Center
) {
item {
Counter(i = counter)
}
item {
IncrementButton {
counter++
}
}
val list = MutableList(10) { "Task $it " }
this.items(items = list) {
Text(it)
}
}
}
```
Но при такой реализации размещение будет выполняться в предположении, что экран часов является квадратным. Однако многие модели имеют круглый экран и для них изображение будет выглядеть не очень хорошо:
Для корректировки смещения необходимо использовать специальный компонент ScalingLazyColumn и определять смещение с учетом положения элемента на экране, например следующим образом:
```
@Composable
fun Content() {
var counter by remember { mutableStateOf(0) }
val itemSpacing = 8.dp
val scrollOffset = 0
val state = rememberScalingLazyListState(
initialCenterItemIndex = 1,
initialCenterItemScrollOffset = scrollOffset
)
ScalingLazyColumn(
modifier = Modifier.fillMaxWidth(),
anchorType = ScalingLazyListAnchorType.ItemCenter,
verticalArrangement = Arrangement.spacedBy(itemSpacing),
state = state,
autoCentering = AutoCenteringParams(itemOffset = scrollOffset)
) {
item {
Counter(i = counter)
}
item {
IncrementButton {
counter++
}
}
val list = MutableList(10) { "Task $it " }
this.items(items = list) {
Text(it)
}
}
}
```
Теперь результат выглядит значительно лучше:
Для определения вида экрана (круглый или квадратный) можно использовать свойства конфигурации, которую мы можем получить с использованием подхода LocalComposition для передачи объектов через дерево Composable.
```
val isRound = LocalConfiguration.current.isScreenRound
```
Аналогично могут быть получен контекст Activity (LocalContext), информация о плотности (LocalDensity), стили оформления (определяются через MaterialTheme и извлекаются из LocalContentColor, LocalTextStyle), менеджеры управления буфером обмена (LocalClipboardManager), фокусом (LocalFocusManager), режимами ввода (LocalInputModeManager) и другие.
Добавим логотип приложения над счетчиком:
```
@Composable
fun Logo() {
Image(painter = painterResource(id = R.drawable.demo), contentDescription = "Logo")
}
ScalingLazyColumn(...) {
item {
Logo()
}
//...
}
```
При необходимости создания нескольких экранов мы можем использовать библиотеку навигации, которая для WearOS реализована иначе, чем для обычного Compose. Прежде всего добавим библиотеку в gradle dependencies:
```
implementation "androidx.wear.compose:compose-navigation:$wear_compose_version"
```
Теперь необходимо создать контроллер навигации (будет использоваться в дальнейшем для переключения между экранами):
```
@Composable
fun Navigation() {
val navController = rememberSwipeDismissableNavController()
SwipeDismissableNavHost(
navController = navController,
startDestination = "main"
) {
composable("main") {
Content(navController = navController)
}
composable("game") {
GameScreen()
}
}
}
@Composable
fun GameScreen() {
Box(modifier = Modifier.fillMaxSize().background(Color.Blue))
}
@Composable
fun StartGameButton(onPressed: () -> Unit) {
Card(onClick = {
onPressed()
}, modifier = Modifier.padding(top = 8.dp)) {
Text(
"Start game",
modifier = Modifier.fillMaxWidth(),
textAlign = TextAlign.Center,
)
}
}
//...
ScalingLazyColumn(...) {
//...
item {
StartGameButton {
navController.navigate("game")
}
}
//...
```
Теперь, когда мы можем делать многостраничные приложения добавим взаимодействие с пользователем, для этого создадим простую реализацию игры в 15. Состояние игрового поля будем хранить отдельно (правильно было бы использовать ViewModel, но для упрощения разместим состояние в глобальной переменной). Для инициализации поля обернем вызов функции в LaunchedEffect, который позволяет выполнить однократное действие (или перезапустить его при изменении аргумента). Также добавим обработку жестов для перемещения чисел.
```
var gameField = mutableStateOf(mutableListOf())
fun initializeGame() {
val field = mutableListOf()
field.addAll(List(16) { 0 })
for (i in 1..15) {
var position = Random.nextInt(16)
while (field[position] != 0) {
position = Random.nextInt(16)
}
field[position] = i
}
gameField.value = field
}
```
Для описания экрана будем использовать разметку сеткой, но добавим дополнительные модификаторы для корректного отображения на круглом экране:
```
@Composable
fun GameScreen() {
LaunchedEffect(Unit) {
initializeGame()
}
Box(
modifier = Modifier
.fillMaxSize()
.background(Color.Blue)
) {
val size = LocalConfiguration.current.screenWidthDp
LazyVerticalGrid(
columns = GridCells.Fixed(4),
verticalArrangement = Arrangement.SpaceEvenly,
modifier = Modifier
.pointerInput(Unit) {
detectHorizontalDragGestures { change, dragAmount ->
println(change)
if (dragAmount>size/32) {
toRight()
}
if (dragAmount<-size/32) {
toLeft()
}
}
detectVerticalDragGestures { change, dragAmount ->
if (dragAmount>size/32) {
toBottom()
}
if (dragAmount<-size/32) {
toTop()
}
}
}
.padding((size / 16).dp)
.safeDrawingPadding()
.fillMaxSize(),
content = {
items(items = gameField.value) {
if (it != 0) {
Text(text = it.toString(), textAlign = TextAlign.Center)
}
}
})
}
}
```
При перемещении чисел нужно будет следить за тем, что в state нужно будет записать новый список (обычная мутация внутри списка не будет отслеживаться как изменение состояния):
```
fun toLeft() {
val pos = gameField.value.indexOf(0)
if (pos % 4 < 3) {
//shift next
val fieldCopy = mutableListOf()
fieldCopy.addAll(gameField.value)
fieldCopy[pos] = fieldCopy[pos+1]
fieldCopy[pos+1] = 0
gameField.value = fieldCopy
}
}
```
Далее необходимо доработать логику перемещения чисел и проверку завершения игры с переходом на экран с поздравлениями. Исходные тексты игры размещены на github в репозитории <https://github.com/dzolotov/wearos15>.
Во второй части статьи мы рассмотрим как можно работать с отдельными пикселями и делать более сложные визуализации на часах, об использовании сетевых запросов и взаимодействию с системными сервисами для работы с уведомлениями WearOS, получению информации о местоположении, заряде батареи и информацией о физической активности.
Статья подготовлена в преддверии старта курса [Android Developer. Professional](https://otus.pw/lkqg/). Также приглашаем всех желающих на бесплатный урок по теме: "Профайлинг ui". Узнать подробнее о курсе и зарегистрироваться на [бесплатный урок](https://otus.pw/lkqg/) можно по ссылке ниже.
* [Зарегистрироваться на бесплатный урок](https://otus.pw/lkqg/). | https://habr.com/ru/post/705686/ | null | ru | null |
# HTTP Error 503. Service Unavailable: случай в поддержке хостинга
Работа в поддержке хостинга в основном однотипная, большинство запросов от клиентов решаются по проработанной схеме, но иногда всё же приходится сталкиваться с нетривиальными проблемами. Тогда главная задача инженера — найти тот самый — единственно верный путь, который приведёт к её решению. В этой статье хочу рассказать о том, как мы столкнулись с плавающей ошибкой «HTTP Error 503. Service Unavailable» на нашем shared-хостинге, как пытались её отловить, провели диагностику и получили неожиданный финал.
### Начало
Хостинг предоставляет пользователям типичный стек Linux + Apache + Mysql + PHP и оболочку для управления. В нашем случае это ISP Manager 5 business на базе Centos 7 с конвертацией в CloudLinux. Со стороны административной части, CloudLinux предоставляет инструменты для управления лимитами, а так же PHP-селектор с различными режимами работы (CGI, FastCGI, LSAPI).
В этот раз к нам обратился клиент со следующей проблемой. Его сайт на движке Wordpress периодически начал отдавать 503 ошибку, о чём он нам и сообщил.
Коды ответа, начинающиеся с 50х, относятся к проблемам на стороне сервера. Это могут быть проблемы как самого сайта, так и веб-сервера, который их обслуживает.
Типичные ситуации, при которых мы получаем следующие ошибки:
* 500 Internal Server Error — довольно часто связана либо с синтаксическими ошибками в коде сайта, либо с отсутствующими библиотеками / не поддерживаемой версией PHP. Так же могут быть проблемы с подключением к базе данных сайта или неверными правами на файлы / каталоги
* 502 Bad Gateway — например, если Nginx ссылается на неправильный порт веб-сервера Apache или процесс Apache по какой-то причине перестал работать
* 504 Gateway Timeout — ответ от Apache не был получен в течение заданного в конфигурации веб-сервера времени
* 508 Resource limit is reached — превышен лимит, выделяемых пользователю ресурсов
В данном списке приведены лишь некоторые, наиболее распространённые случаи. Также стоит отметить, что при превышении лимитов пользователь может получить как 500, так и 503 ошибку.
При выполнении диагностики данных ошибок, первым делом проверяем журналы веб-сервера. Обычно, этого достаточно, чтобы определить виновника и исправить проблему.
Касаемо 503 ошибки в нашем случае, в логах мы видели запись:
> [lsapi:error] [pid 49817] [client x.x.x.x:6801] [host XXX.XX] Error on sending request(GET /index.php HTTP/1.0); uri(/index.php) content-length(0): ReceiveAckHdr: nothing to read from backend (LVE ID 8514), check [docs.cloudlinux.com/mod\_lsapi\_troubleshooting.html](http://docs.cloudlinux.com/mod_lsapi_troubleshooting.html)
На основании только этого лога, определить в чём может быть проблема не представлялось возможным.
### Первичная диагностика
Изначально, мы проверили статистику превышения лимитов пользователем. Незначительные превышения были зафиксированы за предыдущие дни, но ошибки в журналах были свежие, более того они появлялись в журнале с периодичностью от одной до нескольких минут.
Так же мы изучили рекомендации CloudLinux, по приведённой в журналах ошибок ссылке.
Изменение каких-либо параметров результата не принесло.
Сайт использовал базу данных на сервере Mysql 5.7, который работает на этом же сервере в контейнере Docker. В логах контейнера присутствовали сообщения:
```
[Note] Aborted connection 555 to db: 'dbname' user: 'username' host: 'x.x.x.x' (Got an error reading communication packets)
```
Как раз, среди этих сообщений были сообщения о прерванном подключении исследуемого сайта. Это дало предположение, о том, что подключение к СУБД выполняется некорректно. Для проверки мы развернули копию сайта на тестовом домене, сконвертировали базу данных сайта под нативную в Centos 7 версию СУБД 5.5.65-MariaDB. На тестовом сайте выполнили несколько сотен запросов с помощью утилиты curl. Ошибку воспроизвести не удалось. Но этот результат был предварительным и после конвертации БД на рабочем сайте проблема так и осталась.
Таким образом, проблема некорректного подключения к СУБД была исключена.
Следующим предположением было проверить — нет ли проблем с самим сайтом. Для этого подняли отдельный виртуальный сервер, на нём подняли максимально схожее окружение. Единственное существенное отличие — отсутствие CloudLinux. На тестовом сервере проблему воспроизвести не удалось. Итак, мы определили, что в коде сайта всё в порядке. Тем не менее, пробовали так же отключать плагины Wordpress, но проблема так же сохранялась.
В результате, пришли к тому, что проблема на нашем хостинге.
В ходе анализа журналов других сайтов было обнаружено, что проблема наблюдается на многих из них. Порядка 100 шт. на момент проверки:
```
/var/www/httpd-logs# grep -Rl "ReceiveAckHdr: nothing to read from backend" ./ | wc -l
99
```
В ходе тестирования обнаружили, что только что установленная чистая CMS Wordpress также периодически выдаёт ошибку 503.
Примерно за 2 месяца до этого мы проводили работы по модернизации сервера, в частности изменили режим работы Apache с Worker на Prefork, с целью получить возможность использовать PHP в режиме LSAPI, вместо медленного CGI. Было предположение, о том, что это могло повлиять, либо требуются какие-то дополнительные настройки Apache, но вернуть обратно режим Worker мы уже не могли. В ходе изменения режима работы Apache выполняется изменение всех конфигов сайтов, процесс не быстрый и не всё могло пройти гладко.
Корректировка настроек Apache так же не дала желаемого результата.
Попутно искали схожие проблемы в поисковых системах. На одном из форумов участники утверждали, что проблема у хостера и нужно его менять, если проблему не решают. Звучит не очень оптимистично, когда ты находишься с другой стороны, но и клиента понять можно. Зачем ему нерабочий хостинг.
На данном этапе мы собрали имеющуюся информацию и результаты проведённых работ. С ними обратились в поддержку CloudLinux.
### Детальная диагностика
В течение нескольких дней сотрудники поддержки CloudLinux вникали в проблему. В основном рекомендации были относительно установленных лимитов пользователей. Этот вопрос мы так же проверяли. При отключенных лимитах (Опция CageFS для пользователя) и с включенными лимитами в режиме PHP как модуль Apache проблема не наблюдалась. Исходя из этого, было сделано предположение, что каким-то образом оказывает влияние CloudLinux. В итоге, к концу недели запрос был эскалирован на 3-ий уровень поддержки, но решения пока не было.
Попутно изучали документацию Apache по режимам работы CGI и LSAPI, подняли второй экземпляр Apache на сервере хостинга на другом порту с тестовым сайтом, исключили влияние Nginx, отправляя запросы напрямую к Apache и получая те же коды ошибок.
Сдвинуться с мёртвой точки помогла документация LSAPI, как раз по диагностике 503 ошибки:
[www.litespeedtech.com/support/wiki/doku.php/litespeed\_wiki](https://www.litespeedtech.com/support/wiki/doku.php/litespeed_wiki):php:503-errors
В секции Advanced Troubleshooting предлагается выполнять трассировку найденных в системе процессов:
```
while true; do if mypid=`ps aux | grep $USERNAME | grep lsphp | grep $SCRIPTNAME | grep -v grep | awk '{print $2; }' | tail -1`; then strace -tt -T -f -p $mypid; fi ; done
```
Команда была доработана, с целью записи всех процессов в файлы с указанием их идентификаторов.
При просмотре файлов трассировок, мы видим в некоторых одинаковые строки:
```
cat trace.* | tail
...
47307 21:33:04.137893 --- SIGHUP {si_signo=SIGHUP, si_code=SI_USER, si_pid=42053, si_uid=0} ---
47307 21:33:04.140728 +++ killed by SIGHUP +++
...
```
Если взглянуть на описание структуры сигналов, отправляемых процессами, то увидим, что
```
pid_t si_pid; /* Sending process ID */
```
Указывает на идентификатор процесса, отправившего сигнал.
На момент изучения трассировок, процесса с PID 42053 в системе уже нет, поэтому в процессе захвата трассировок решили отслеживать так же процессы, отправившие сигнал SIGHUP.
Под спойлером описаны действия, которые позволили определить что это за процесс, а так же получить его трассировку и дополнительную информацию, о том, каким процессам он отправляет сигнал SIGHUP.
**Методика трассировки**
Консоль 1.
```
tail -f /var/www/httpd-logs/sitename.error.log
```
Консоль 2.
```
while true; do if mypid=`ps aux | grep $USERNAME | grep lsphp | grep "sitename" | grep -v grep | awk '{print $2; }' | tail -1`; then strace -tt -T -f -p $mypid -o /tmp/strace/trace.$mypid; fi ; done
```
Консоль 3.
```
while true; do if mypid=`cat /tmp/strace/trace.* | grep si_pid | cut -d '{' -f 2 | cut -d'=' -f 4 | cut -d',' -f 1`; then ps -aux | grep $mypid; fi; done;
```
Консоль 4.
```
seq 1 10000 | xargs -i sh -c "curl -I http://sitename/"
```
Ждём пока в консоли 1 появятся сообщения, при этом в консоли 4 видим статус запроса с кодом ответа 503, прерываем выполнение в консоли 4.
В итоге, получили название процесса `/opt/alt/python37/bin/python3.7 -sbb /usr/sbin/cagefsctl --rebuild-alt-php-ini`
Данный процесс выполнялся в системе с периодичностью раз в минуту.
Делаем трассировку нескольких процессов cagefsctl, чтобы отследить хотя бы один от начала до конца:
```
for i in `seq 1 100`; do strace -p $(ps ax | grep cagefsctl | grep rebuild-alt-php-ini | grep -v grep | awk '{print $1}') -o /tmp/strace/cagefsctl.trace.$(date +%s); done;
```
Далее изучаем что он делал, например:
```
cat /tmp/strace/cagefsctl.trace.1593197892 | grep SIGHUP
```
Так же были получены идентификаторы процессов, которые были завершены сигналом SIGHUP. Завершённые процессы были процессами PHP, выполняющимися в данный момент.
Полученные данные были переданы в поддержку CloudLinux с целью уточнить легитимность данного процесса и должен ли он работать с такой периодичностью.
Позже получили ответ, что работа команды `/usr/sbin/cagefsctl --rebuild-alt-php-ini` выполняется корректно, единственный нюанс в том, что команда выполняется слишком часто. Обычно вызывается при системном обновлении или изменении параметров PHP.
Единственная зацепка в данном случае осталась — проверить, кто является родительским процессом cagefsctl.
Результат не заставил себя долго ждать и какого же было наше удивление — родительским процессом для cagefsctl являлся процесс ispmgrnode. Это было немного странно, потому что уровень журналирования для ISP Manager был задан максимальным и в ispmgr.log не увидели вызов cagefsctl.
Теперь данных было достаточно, чтобы обратиться и в поддержку ISP System.
### Итоги
Проблема была спровоцирована после выполнения обновления ISP Manager. В целом, обновление ISP Manager — штатная ситуация, но она привела к запуску процесса синхронизации, который завершался с ошибкой и перезапускался ежеминутно. Процесс синхронизации вызывал за собой процесс cagefsctl, который в свою очередь завершал процессы PHP.
Причиной зависания процесса синхронизации стали проведённые на хостинге работы по модернизации оборудования. За несколько месяцев до возникновения проблемы, в сервер был установлен PCI-e NVMe-накопитель, создан раздел XFS и смонтирован в каталог /var. На него были перенесены в том числе и файлы пользователей, но не обновились дисковые квоты. Опций монтирования было не достаточно, требовалось так же изменить тип файловой системы в параметрах ISP Manager, т.к. она вызывает команды обновления дисковых квот. Для Ext4 и XFS эти команды отличаются.
Таким образом, проблема дала о себе знать спустя несколько месяцев после проведения работ.
### Выводы
Мы сами создали проблему, но это было не ясно до последнего момента. На будущее, будем стараться учесть как можно больше нюансов. Благодаря помощи более подготовленных коллег из поддержки CloudLinux и ISP System, проблема была решена. Теперь наш хостинг работает стабильно. А нами был получен опыт, который пригодится нам в будущей работе.
P.S.: Надеюсь, Вам было интересно ознакомиться с материалом статьи, а кому-нибудь она поможет быстрее решить подобную проблему. | https://habr.com/ru/post/510048/ | null | ru | null |
# Top 10 JavaScript Hack for Optimized Performance
JavaScript has been ruling the tech arena for more than two decades and helping developers simplifying complex tasks. It allows developers to implement complex task web pages in a most simplified manner. For most of the developers minified JavaScript file is the common phenomena while very few developers may be aware of Optimized JavaScript code. While meeting through many [Javascript developers](https://aglowiditsolutions.com/hire-javascript-developers/), I have come to know that Optimized JavaScript code is something that confuses developers, some of them might be doing it, but they are not aware of this.
What is an Optimized JavaScript Code
------------------------------------
When combinations of uniquely programmed logics along with small hacks utilized to enhance performance and speed is known as Optimized JavaScript code. Optimization not only optimizes performance and speed but also saves maximum development time. When you save time, you save some bucks as well.
So, I am here with some useful and fruitful hacks to help developers optimize performance, enhance speed and save time. Hope, you like the article and after going through it, you may utilize the best of Optimized JavaScript code.
### 1. Make JS code Leaner with Combining Javascript Modules & Minifying JS Files
Leaner code make standardized code format, which helps both developers and applications by giving more readability. That is possible when you combine the JavaScript modules and minifies the JS files. Though a minified version of the code may, sometimes, be difficult to read and understand, you will get coding leaner and optimized for sure. When you have a minified source, it helps you in many ways. For example, it can reduce the page load time, remove line breaks, additional spaces, comments, and much more. These benefits are possible as the minified source shrinks file sizes.
Optimization is also a kind of JavaScript minification, which play a very crucial role not only in removing and deleting unnecessary things such as spaces, commas, etc. but also helps developers do away with unnecessary code blocks. Here are some of the significant tools and library which help you minify the code are;
* Google Closure Compiler
* UglifyJS
* Microsoft AJAX Minifier
When you have larger JavaScript file, it affect page performance such as take time to load page and impact on speed while compressing or minifying code will resolve the issue smartly.
2. Using Scope in JavaScript is Good Step Forward
----------------------------------------------------
Reducing dependency on global variables and closures is yet another way to enhance performance and speed of the applications and that is possible using a JavaScript Scope named 'this'. Yes, 'this' helps developers write asynchronous code with callbacks. However, another scope like 'with' should be avoided as it drags down the performance of the application by modifying the scope chain.
```
init: function(name) {
this.name = name;
},
do: function(callback) {
callback.apply(this);
}
});
var bob = new Car('Aventador');
bob.do(function() {
alert(this.name); // 'Aventador' is alerted because 'this' was rewired
});
```
### 3. Utilizing Array Filter
Using Array filter helps developers filter out all elements from the array pool. It is a method which removes the elements which pass through testing. In short, the method creates an array which creates a callback function for not-required elements.
Let's understand how it works through this example.
```
schema = schema.filter(function(n) {
return n
});
Output: ["hi","ilove javascript", "goodbye"]
```
### 4. Replace Function String to Replace the Values
There is a function 'String.replace() which help developers replace strings using the functions. For example;
* To replace string, use 'String' and 'Regex'
* To replace all strings, use function 'replaceAll()' function
* Use /g at the end if you are using 'Regex'
Let's get understand this from the example given below;
```
var string = "login login";
console.log(string.replace("in", "out")); // "logout login"
console.log(string.replace(/in/g, "out")); //"logout logout"
```
### 5. Debugging Using Breakpoints and Console
Utilizing breakpoints and debugging points, you can filter outsource of error by setting multiple barriers. Here's how you can do this;
You can call the next function using **F11** and resume script execution using **F8**.
Using console, developers can easily check the dynamic values created by the function and what is the output.
### 6. Do Away with Unused Components from JavaScript Library
During the course of development, you may need libraries like jQuery UI or jQuery Mobile, which come up with loads of components. So, you need to decide which components you want to be loaded. You can do this while downloading the libraries.
### 7. Using HTTP/2 can make a Difference
Using the latest version of HTTP protocol can make a huge difference and provide helping hand in enhancing JavaScript performance. Currently, HTTP protocol uses HTTP/2 as its latest version and it utilizes multiplexing which enables multiple requests and responses which can work at the same time. HTTPS has all the features of HTTP/2 and therefore, it can also be a great option to move with.
### 8. Delete / Empty in an Array Using 'length'
Using 'length' you can resize the file by deleting and emptying elements in the array. You need to use the following keyword, 'array.length'.
Let's take a look at the example here;
```
array.length = n
```
Such as;
```
var array = [1, 2, 3, 4, 5, 6];
console.log(array.length); // 6
array.length = 3;
console.log(array.length); // 3
console.log(array); // [1,2,3]
```
Similarly, if you want empty the array, you need to use;
```
Array.length = 0;.
```
Take a look at the example here;
```
var array = [1, 2, 3, 4, 5, 6];
array.length = 0;
console.log(array.length); // 0
console.log(array); // []
```
The technique is very useful in resizing the file and enhancing the JavaScript performance.
### 9. Apply Switch Case over If / Else
Using the Switch case over if/else enables developers to shorten execution time. Using if/else makes testing lengthier. Therefore, you need to evaluate it.
### 10. Caching DOM Object
Using script repeatedly accesses certain DOM objects. For example, the object "document.images" will be looked up two times for each loop and if you have 10 such images, then there will be 20 calls. Let's look at the example here. | https://habr.com/ru/post/456544/ | null | en | null |
# Трехмерная визуализация в тренажерах подвижного состава на базе движка OpenSceneGraph
Чуть меньше года назад увидела свет [публикация](https://habr.com/ru/post/408885/), где мы рассказывали об учебно-лабораторном комплексе (УЛК) электропоезда ЭС1 «Ласточка», разработанном нашем университете. Тогда я обещал, что это будет не последняя публикация на данную тему, в частности грозился рассказать о проблемах создания трехмерной визуализации для подобного рода симуляторов и очертить основные подходы к их решению.
Прошедший год порадовал нас очередным релизом — УЛК высокоскоростного электропоезда ЭВС2 «Сапсан», который состоялся ещё в августе прошлого года. Сам по себе учебно-лабораторный комплекс данного электропоезда заслуживает отдельного рассказа, но в контексте этой публикации речь пойдет о наболевшем — проблеме создания адекватной подсистемы трехмерной визуализации, к решению которой наша команда подступалась с разных сторон около двух лет. Релиз симулятора «Сапсана» знаменателен (среди прочего) и тем, что определил вектор развития наших разработок в этой области.
1. Кратко об УЛК ЭВС2 «Сапсан»
==============================
Хочу подчеркнуть ещё раз (что я делаю с завидной периодичностью) что учебно-лабораторные комплексы подвижного состава, разрабатываемые в нашем университете, не предназначены для подготовки локомотивных бригад. Как справедливо [заметил один из комментаторов](https://habr.com/ru/post/408885/#comment_18492429) предыдущей статьи, наши УЛК являются не тренажерами, а симуляторами, где основной упор делается на грамотную реализацию физики движения поезда и моделирование работы подсистем подвижного состава, обеспечивающих его движение и остановку. Не является исключением и симулятор «Сапсана», на котором решены следующие задачи:
* Реализована динамическая модель механической части поезда с учетом продольных сил и профиля пути
* Построена подробная компьютерная модель работы ключевых подсистем электропоезда: силовой электрической схемы, тягового электрического привода, пневматических и электропневматических тормозов
* Воспроизведены основные алгоритмы работы системы управления электропоездом на разных уровнях
Кроме того, учебно-лабораторный комплекс имеет в своем составе полноразмерный макет кабины электропоезда с основными органами управления и средствами отображения информации. В отличие от тренажера «Ласточки» эта кабина не изготавливалась нами самостоятельно, а была приобретена в 2015 году у одной известной в нашей стране конторы, занимающейся выпуском учебных тренажеров. Поэтому в процесс разработки симулятора сосредоточился на создании программного обеспечения.
**Фото кабины**
*Общий вид интерьера кабины*
*Вид через лобовое стекло*
*Дисплей комплексного локомотивного устройства безопасности (КЛУБ-У). Красное «290» — это текущее ограничение скорости, получаемое из электронной карты КЛУБ-У. Пока здесь красуется предельная скорость, достигнутая «Сапсаном» на Октябрьской железной дороге. В будущем электронная карта будет реализована так, как это сделано в жизни*
*Главный дисплей «Интерфейс человек-машина»*
*Дисплей индикации состояния тормозной системы электропоезда*
*Задатчик скорости и контроллер тяги*
*Контроллер управления тормозами электропоезда*
*Тумблеры управления токоприемниками и аппаратами защиты (БВ/ГВ) — черные тумблеры около задатчика скорости*
*Интерфейс управления тренировкой — экран выбора маршрута движения*
*Экран управления громкостью аудиоэффектов*
*Счетчик пробега. С его появлением связана забавная история. Когда мы сдавали первый наш тренажер тепловоза 2ТЭ116, на наш вопрос когда будет подписан акт выполненных работ представитель заказчика отшутился: «Ну, давайте поступим как в жизни — при вводе нового локомотива в эксплуатацию он должен пройти 5000-километровый пробег. Вот пройдет...». Акт конечно был подписан намного раньше, но мы, оценив юмор ситуации, сделали подобный счетчик уже на тренажере «Ласточки». Счетчик можно сбросить в «0» введя сервисный пароль.*
*Правая вспомогательная панель с контрольными манометрами тормозной системы и клапаном экстренного торможения. Здесь установлены не все элементы присущие настоящему «Сапсану» — такой пульт был получен нами от поставщика*
*Поэтому, некоторые критичные для нас элементы управления были реализованы программно, в частности панель шунтирующих выключателей, управляемая с сенсорного дисплея*
Разработка ПО подобного тренажера-симулятора вопрос очень широкий, и я постараюсь (в меру разумного) удовлетворить интерес читателей к этим вопросам в будущем (если таковой появится), но пока что, вернемся к основной теме статьи — трехмерной визуализации процесса движения поезда.
2. История вопроса и технологии прошлого
========================================
В комментариях к прошлой статье [был задан вопрос](https://habr.com/ru/post/408885/#comment_18492469), который, признаюсь честно, изрядно меня позабавил. Да, действительно, во многих, до сих пор эксплуатируемых сегодня тренажерах до сих пор применяется такой подход: снимается видео на реальном участке железной дороги, а затем прокручивается на тренажере со скоростью, пропорциональной скорости движения. Так делали только потому, что в те далекие времена, когда подобные тренажеры создавались, качество трехмерной графики, оставляло желать лучшего, причем это касалось и суровых графических станций на коммерческих юниксах, а уж о ПК и речи не шло. Поэтому, даже производители компьютерных игр, например [вот этой](https://ru.wikipedia.org/wiki/Journeyman_Project), не гнушались использовать такой подход.
На сегодняшний день это не имеет смысла, потому что:
1. Недостаточная частота смены кадров на низких скоростях движения поезда не обеспечивает нужной плавности обновления картинки. Заветные 25 fps мы будем иметь только при той скорости, на которой снималось видео из кабины машиниста. И этот фатальный недостаток ничем не преодолеть — ни съемкой скоростной камерой (сколько будет весить видео, снятое на 120 кадрах в секунду? То-то же...), ни программной генерацией промежуточных кадров. Последнее предпринималось нами с использованием технологии OpenCV, но к нормальным результатам не привело. Этот вопрос многократно прорабатывался со всех сторон и в итоге был сделан вывод, что затраты ресурсов на создание такой системы намного превышают разработку аналогичной системы, но на базе 3D-графики
2. Трудности с плавной прокруткой видео назад. И даже учитывая, что они будут преодолены, то куда побегут бежавшие по перрону собаки, вздумай мы поехать задним ходом?
3. Отсутствие всяческой «интерактивности». Как быть со сменой сигнала светофора, с движением стрелочных переводов, движением встречных и попутных поездов?
Поэтому все современные тренажеры и симуляторы создаются с применением интерактивной 3D-графики, благо сегодня нет никаких препятствий ни с программной, ни с аппаратной точки зрения.
Если с аппаратной точки зрения всё предельно ясно — монитор установленный вместо лобового стекла подключается к ПК с нормальной видеокартой (даже не самой топовой), то с программной точки зрения встает вопрос выбора технологии реализации задачи.
3. Графический движок против игрового движка или почему был выбран OpenSceneGraph
=================================================================================
Могу ошибаться, но заранее предчувствую комментарии, в которых будет задаваться вполне закономерный вопрос, почему при анализе существующих технологий наш выбор не остановился на таких мастодонтах как Unity или Unreal Engine 4? Я отвечу на этот вопрос, более того, я обосную свой ответ.
Кратко — ни Unity ни Unreal Engine не удовлетворяют требованиям решаемой задачи. Более подробный ответ предусматривает, прежде всего перечисления тех требований, о которых идет речь. ТЗ, составленной нами на подсистему трехмерной визуализации, включает в себя (в порядке убывания значимости) следующие положения:
1. Независимость процесса разработки ПО подсистемы визуализации и процесса создания ресурсов для неё. К ресурсам, в данном случае, относятся трехмерные модели, текстуры, а так же так называемые *маршруты*. Под маршрутом понимается совокупность объектов конфигурации и ресурсов, позволяющих видеоподсистеме отобразить желаемый участок железной дороги и обеспечить симуляцию движения поезда по нему. Сюда же стоит отнести и *возможность смены маршрута без пересборки программной части видеоподсистемы*
2. Создание маршрутов неограниченной протяженности. Оговорюсь, что неограниченная протяженность в принципе недостижима по причине ограниченности аппаратных ресурсов. Данное требование следует понимать, что протяженность маршрута должна быть как минимум в пределах одно «плеча», то есть участка дороги между оборотными пунктами, а это, в зависимости от разных факторов достаточно большое расстояние, исчисляемое не одной сотней километров. Это требование накладывает необходимость обеспечивать динамическую загрузку/выгрузку ресурсов программы с достаточной плавностью при разумном потреблении памяти. И желательно, чтобы движок содержал такой функционал «из коробки»
3. Удобная интеграция с используемым стеком технологий. Традиционно, в силу опять таки причин объективных, для разработки ПО УЛК ПС в нашей команде используется язык C++ с фреймворком Qt, в качестве IDE QtCreator, а в качестве системы контроля версий — Git. В качестве системной платформы УЛК ПС используется ОС на базе ядра Linux
Что же не так с Unity и UE? Что тот, что другой движки способны импортировать ресурсы совершенно разных форматов. Однако при сборке проекта происходит их необратимое преобразование во внутренний бинарный формат, делающее невозможным добавление и изменение ресурсов без повторной сборки проекта. Технологии типа prefabs и asset bundles, доступные в Unity не решают задачу, так как редактор движка — не лучшее место для создания железнодорожных локаций, из-за чего возникает потребность расширения редактора, что приводит к необходимости писать «движок внутри движка». Кроме того, создание префабов и бандлов невозможно без применения редактора Unity, а это, как показала практика, не слишком удобно, особенно для чистых моделлеров и левел-дизайнеров. Что же касается UE, и на этом и на других ресурсах за два года мной было задано достаточно вопросов, о том как отделить процесс сборки проекта от процесса добавления/изменения используемых им ресурсов, и адекватного ответа я не получил ни в документации, ни от «матерых» геймдевелоперов. Буду очень рад (без сарказма) если меня аргументировано натыкают носом во что-то, что было мной упущено.
Что касается второго требования, то и Unity и UE вроде как обеспечивают возможность создания динамически загружаемых локаций, но остается нераскрытым вопрос, каким образом подобные локации можно создавать независимо от редактора и без пересборки проекта? Выход один — писать «движок внутри движка», который будет загружать «сырую» (в любом из наперед заданном формате экспорта из 3D-редакторов) геометрию и текстуры, применять к ним все необходимые эффекты и позиционировать в пространстве опираясь на данные, описанные в стороннем, независимом от движка формате, который нужно ещё разработать и научить движок его интерпретировать.
В связи с вышеперечисленным возникает вопрос — если для решения поставленной задачи необходимо писать мощную программную прослойку над игровым движком, большая часть функциональности которого в рассматриваемой задаче просто не нужна, то зачем нужен игровой движок?
Может быть достаточно графического движка? Этот вопрос я задавал предыдущей команде, бравшейся за обсуждаемую проблему опираясь на Unity (и закономерно слившейся чуть позже). В ответ получил встречный вопрос: «А что предлагаете вы?», ответив на который в духе приведенного выше текста получил саркастическую улыбку оппонента.
Если обойтись без сарказма, то представленная задача является типичной задачей визуализации — здесь требуется только фреймворк для работы с графикой, так как и физика, и аудиоподсистема, опирающаяся на физику реализованы на серверной стороне. Я и моя команды пришли к пониманию этого факта двигаясь по инерции предыдущих разработчиков сначала в сторону Unity, через UE и попытки прикрутить графическую подсистему от оного из открытых железнодорожных симуляторов (OpenBVE, что кстати получилось, но стало временным костылем)
[OpenSceneGraph](http://www.openscenegraph.org/) является на сегодняшний день самым развитым (из открытых и бесплатных) графическим движком, ориентированным на C++ разработку. Он достаточно широко применяется за рубежом именно для технической трехмерной визуализации. Этот движок не обошли стороной и разного рода симулятора, наиболее известный из которых — [FlightGear](http://home.flightgear.org/). Некогда существовал и железнодорожный симулятор на базе этого движка — [Indra](http://openscenegraph.sourceforge.net/screenshots/Indra/), от которого, впрочем, остались только унылые скриншоты по вышеприведенной ссылке и его дальнейшая судьба мне неизвестна.
В контексте решаемой задачи графический движок OSG обладает следующими положительными качествами:
* Кроссплатформенность, что делает возможным применить его в экосистеме GNU/Linux
* Язык разработки C++/STL, что дает возможность легко и непринужденно интегрировать его в устоявшийся в нашей команде технологический процесс разработки;
* Широчайший спектр поддерживаемых «из коробки» форматов ресурсов — 3D-геометрии и текстур за счет развитой системы плагинов. Простой и понятный интерфейс написания собственных плагинов для настройки менеджера ресурсов на нестандартные форматы, чем мы и воспользовались (об этом я напишу ниже);
* Система управления памятью на основе собственной модели умных указателей (собственный формат умных указателей используется исторически, в связи с тем что в начале разработки движка умных указатель в стандарте C++ не было);
* Гибкая модульная архитектура;
* Диспетчер объектов сцены, выполняющий динамическую загрузку объектов, обеспечивающий загрузку и отрисовку только тех объектов, которые попадают в пределы пирамиды отсечения (за счет класса osg::PagedLOD)
* Возможность интеграции с фреймворком Qt. Благодаря удобной модели «сигналы — слоты», предоставляемой Qt, существенно упрощающей и ускоряющей разработку на C++, мы широко применяем данный фреймворк для разработки ПО тренажерных комплексов. Соответственно, у нас накоплена значительная повторно используемая в разных проектах кодовая база, особенно это касается библиотеки межпроцессоной коммуникации на базе TCP-сокетов. Использовать возможности Qt и в проекте видеоподсистемы представляется вполне логичным решением;
* Достаточное для решаемой задачи качество картинки.
Потребовалось около полугода напряженного изучения возможностей OSG для того чтобы тщательно «прощупать почву» и найти подходы к решению поставленной задачи с помощью этого движка. То что родилось в итоге заслуживает отдельного разговора.
4. От архитектуры к рабочему прототипу
======================================
Видеоподсистема тренажеров подвижного состава (ВТПС) является клиентским приложением, буднично именуемым video3d-client и выполняет следующие функции:
* Запрос на подключение к серверной части тренажера, авторизация на сервере с последующим периодическим запросом идентификатора загружаемого маршрута, а затем и текущего положения поезда. При разрыве соединения со стороны сервера переход в режим ожидания возможности повторного подключения;
* Загрузка выбранного маршрута, организация динамического управления содержимым отрисовываемой сцены;
* Собственно рендеринг сцены в соответствии с текущим положением поезда на маршруте
Не то чтобы этот проект был opensource, однако с кодом полнофункциональной технологической демки вполне можно ознакомится [здесь](https://github.com/maisvendoo/video3d-client). Проект состоит из следующих модулей:
* *filesystem* — библиотека для работы с файловой системой, обеспечивает генерацию путей к конфигурационным файлам и ресурсам приложения
* *library* — кроссплатформенная реализация загрузчика динамических библиотек. В общем-то костыль, написаный в период, когда возможности интеграции с Qt (где есть готовый к бою модуль QLibrary) была ещё расплывчатой
* *osgdb\_dmd* — плагин для загрузки моделей формата, специфичного для движка DGLEngine версии 1.1. Для чего это потребовалось я объясню чуть ниже
* *route-loader* — библиотека, обеспечивающая абстрактный интерфейс к загрузчику маршрутов. Предполагается возможность загрузки маршрутов произвольного формата
* *tcp-connection* — библиотека межпроцессного взаимодействия через TCP-сокеты
* *viewer* — основной исполняемый модуль программы
* *zds-route-loader* — плагин для загрузки маршрутов формата ZDSimulator
При проектировании ВТПС встал вопрос выбора: разрабатывать формат маршрутов самостоятельно, либо воспользоваться существующим форматом маршрутов, а так же готовыми маршрутами отечественных железных дорог для существующего железнодорожного симулятора. На счастье подвернулось решение — закрытый проприетарный продукт [ZDSimulator](https://zdsimulator.com.ua/), обладающий той особенностью, что он заточен под отечественный подвижной состав и специфику работы сети железных дорог. Несмотря на похвальбу авторов проекта, он имеет массу существенных недостатков, но при этом имеет простой и понятный формат маршрутов, находящихся в открытом доступе. На первом этапе было грех не воспользоваться имеющейся возможностью, при том что графическая часть симулятора основана на открытом движке DGLEngine. Беда в том, что данный движок хоть и развивается (текущее состояние проекта [можно увидеть тут](https://github.com/DGLE-HQ/DGLE)), но его текущая вторая версия несовместима с версией 1.1, на которой основан ZDSimulator. Исходники версии 1.1 утеряны, ссылки ведущие к ним давно протухли.
Тщательный поиск в вебархиве позволил найти утерянное и спасти, разместив [DGLEngine v1.1](https://github.com/maisvendoo/DGLEngine) на Gtihub. Этот движок использует свой, специфический формат 3D-моделей. Имея исходники движка нетрудно было написать соответствующий плагин для OSG.
Таким образом задача создания ВТПС свелась к написанию программной части на движке OSG. В дальнейшем планируется разработка собственного формата маршрутов, так как текущий формат предусматривает движение только по главным путям и обладает рядом недостатков, не позволяющих воссоздать ряд сложных маршрутов.
Иерархия основных классов ВТПС представлена на следующей диаграмме
Иерархия классов загрузчика маршрутов выглядит так
Загрузчик любого другого формата маршрутов может быть написан как плагин, содержащий класс, наследующий от класса RouteLoader. При старте ВТПС ей передается путь к каталогу с маршрутом, определяется формат маршрута и динамически загружается соответствующий плагин, выполняющий далее остальную грязную работу.
Принципиально важным нюансом явилась интеграция движка OSG и Qt. Таковая интеграция существует и именуется [osgQt](https://github.com/openscenegraph/osgQt). Эта библиотека не использована в данном проекте по двум причинам:
1. Отсутствие необходимости в средствах управления окнами, предоставляемыми Qt. OSG имеет свою достаточно развитую систему управления окнами GUI и нет смысла городить GUI поверх другого GUI, так как osgQt предназначена прежде всего для интеграции вьювера OSG в GUI на базе Qt
2. osgQt подвержена багу — некорректная работа с контекстом OpenGL, который она в некоторых случаях не может поделить между OSG и QGLWidget, из-за чего сцена отображается где угодно, только не на виджете Qt. Причем доискаться причин пока не удалось, поскольку на некоторых системах данный баг не проявляет себя.
Возникло понимание того, что интеграция с Qt нужна в части использования концепции «сигналы-слоты», для обеспечения взаимодействия с сетевой подсистемой tcp-connection, использующей Qt и являющейся стандартом де-факто в наших разработках. Опираться на систему сообщений OSG и заново писать TCP-клиент (да ещё и кроссплатформенный) очень не хотелось. Нашлось элегантное решение, опирающееся на то, что если мы хотим, чтобы один объект послал сигнал, инициирующий срабатывание слота у другого объекта мы должны выполнить три условия:
1. Наследовать взаимодействующие классы от QObject
2. Организовать цикл обработки сигналов
3. Создать экземпляр класса QApplication (или QCoreApplication) существующий в памяти в процессе работы приложения
При этом вовсе ни в коем случае не следует выполнять вызов QApplication::exec(), запускающий штатный цикл обработки сигналов, достаточно организовать цикл в котором просто обрабатывать сигналы вызовом QApplication::processEvents(). В OSG таковой цикл имеется (тот цикл, в котором выполняется рендеринг) и имеется возможность создать обработчик событий, в котором обрабатывается событие osgGA::GUIEventAdapter::FRAME, генерируемое движком при отрисовке очередного кадра. Таким образом вся интеграция свелась к коду
**qt-events.h**
```
#ifndef QT_EVENTS_H
#define QT_EVENTS_H
#include
#include
class QtEventsHandler : public osgGA::GUIEventHandler
{
public:
QtEventsHandler(){}
virtual bool handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa);
protected:
};
#endif // QT\_EVENTS\_H
```
**qt-events.cpp**
```
#include "qt-events.h"
bool QtEventsHandler::handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa)
{
switch (ea.getEventType())
{
case osgGA::GUIEventAdapter::FRAME:
{
QCoreApplication::processEvents(QEventLoop::AllEvents, 100);
break;
}
default:
break;
}
return false;
}
```
**main.cpp**
```
#include "main.h"
/*!
* \fn
* \brief Entry point
*/
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
int main(int argc, char *argv[])
{
QCoreApplication app(argc, argv);
RouteViewer viewer(argc, argv);
if (viewer.isReady())
return viewer.run();
return 0;
}
```
после чего, классы унаследованные от QObject и его производных могут обмениваться сигналами до потери пульса.
Всё вышеперечисленной позволило за два месяца создать первый рабочий прототип ВТПС. Чтобы продемонстрировать что вышло в итоге, предлагаю следующую нарезку из опытных поездок по реальным маршрутам. Заранее прошу прощения за качество съемки — не разжились толковой техникой
Заключение и выводы
===================
Главным выводом, по крайней мере для нашей команды стало то, что «серябрянной пули» не существует и в вопросах выбора технологии реализации проекта. Агрессивно продвигаемые на рынок игровые движки не всегда подходят для решения специфических задач, к каким относится визуализация результатов моделирования технических систем. А если и подходят, то не являются оптимальными с точки зрения усилий, потраченных на разработку и сопровождение проекта.
Обидно, что весьма неплохой, а главное свободный, графический движок OSG по факту не имеет в нашей стране сообщества. Дабы исправить эту проблему я пишу [цикл статей здесь на ресурсе](https://habr.com/ru/post/429816/) (там я собрал все ссылки на более менее адекватные источники информации, в том числе и на русском языке). Кроме того, в качестве документации, описывающей базовые принципы OSG могу предложить ещё и [этот блог](https://maisvendoo.github.io/). Надеюсь что кому-то эта информация окажется полезной.
Что касается ВТПС, то работа в этом направлении продолжается. На очереди ещё масса важных задач, которые предстоит решить в ближайшем будущем.
Благодарю за внимание!
[(с) Центр развития инновационных компетенций РГУПС](https://vk.com/crikrgups) | https://habr.com/ru/post/436276/ | null | ru | null |
# Why PVS-Studio Uses Data Flow Analysis: Based on Gripping Error in Open Asset Import Library
An essential part of any modern static code analyzer is data flow analysis. However, from an outside perspective, the use of data flow analysis and its benefit is unclear. Some people still consider static analysis a tool searching for something in code according to a certain pattern. Thus, we occasionally write blog posts to show how this or that technology, used in the PVS-Studio analyzer, helps to identify another interesting error. Today, we have such an article about the bug found in the Base64, one of the encoding standard implementations of binary data.
It all started with checking the latest version of the Qt 6 library. There was a separate usual [article](https://www.viva64.com/en/b/0801/) on this, where I'd described 77 errors found. It turned out that at first, I decided to flip through the report, not excluding the third-party libraries' warnings. In other words, I didn't exclude the warnings related to \src\3rdparty in the settings. It so happened that I immediately ran up against a gripping error example in the [Open Asset Import Library](https://github.com/assimp/assimp). So, I decided to write this extra little note about it.
This defect highlights the benefit of data flow analysis in tools such as [PVS-Studio](https://www.viva64.com/en/pvs-studio/). Without that, it's impossible to find numerous errors. By the way, if you're interested in learning more about data flow analysis and other aspects of the tool's setup, you can read the [Technologies used in the PVS-Studio code analyzer for finding bugs and potential vulnerabilities](https://www.viva64.com/en/b/0592/) article.
Now, let's turn our attention right to the error, found in the Open Asset Import Library (assimp). File: \src\3rdparty\assimp\src\code\FBX\FBXUtil.cpp.
```
std::string EncodeBase64(const char* data, size_t length)
{
// calculate extra bytes needed to get a multiple of 3
size_t extraBytes = 3 - length % 3;
// number of base64 bytes
size_t encodedBytes = 4 * (length + extraBytes) / 3;
std::string encoded_string(encodedBytes, '=');
// read blocks of 3 bytes
for (size_t ib3 = 0; ib3 < length / 3; ib3++)
{
const size_t iByte = ib3 * 3;
const size_t iEncodedByte = ib3 * 4;
const char* currData = &data[iByte];
EncodeByteBlock(currData, encoded_string, iEncodedByte);
}
// if size of data is not a multiple of 3,
// also encode the final bytes (and add zeros where needed)
if (extraBytes > 0)
{
char finalBytes[4] = { 0,0,0,0 };
memcpy(&finalBytes[0], &data[length - length % 3], length % 3);
const size_t iEncodedByte = encodedBytes - 4;
EncodeByteBlock(&finalBytes[0], encoded_string, iEncodedByte);
// add '=' at the end
for (size_t i = 0; i < 4 * extraBytes / 3; i++)
encoded_string[encodedBytes - i - 1] = '=';
}
return encoded_string;
}
```
If you want, for a start you may try to detect the error yourself. So that you don't accidentally read the answer right away, let me show you some other exciting articles and briefly tell you what Base64 is:). Here's a list of additional articles on related topics:
1. [February 31](https://www.viva64.com/en/b/0550/);
2. [Machine Learning in Static Analysis of Program Source Code](https://www.viva64.com/en/b/0706/);
3. [How to introduce a static code analyzer in a legacy project and not to discourage the team](https://www.viva64.com/en/b/0743/).
Ok, let's go on. Here is the coding algorithm implementation of a byte string in [Base64](https://en.wikipedia.org/wiki/Base64) encoding. This is the coding standard of binary data with only 64 characters. The encoding alphabet contains text and numeric Latin characters A-Z, a-z, and 0-9 (62 characters) and 2 additional characters that vary among implementations. Base64 encoding converts every 3 source bytes into 4 encoded characters.
If only one or two bytes are left to encode, as a result, we have only the first two or three characters of the line. The output will be padded with one or two additional pad characters (=). The padding character "=" prevents further bits from being added to the reconstructed data. This point is implemented incorrectly in the function considered.
Found the error? Well done. If not, that's ok too. You need to delve into the code to notice that something goes wrong. The analyzer reports about this "something wrong" with the warning: [V547](https://www.viva64.com/en/w/v547/) [CWE-571] Expression 'extraBytes > 0' is always true. FBXUtil.cpp 224
To understand what worried the analyzer, let's take a look at the initialization of the *extraBytes* variable:
```
// calculate extra bytes needed to get a multiple of 3
size_t extraBytes = 3 - length % 3;
```
The programmer planned to calculate how many additional bytes of input data need to be processed if their total number is not equal to 3. To do this, we just need to divide the number of processed bytes by modulo 3. A correct option of the variable initialization looks like this:
```
size_t extraBytes = length % 3;
```
Then, if, for example, 5 bytes are processed, we get 5 % 3 = 2. So, we need to additionally process 2 bytes. If the input received 6 bytes, then nothing needs to be processed separately, since 6 % 3 = 0.
Although, it may have meant the number of bytes missing for a multiple of three. Then, the correct code should look that way:
```
size_t extraBytes = (3 - length % 3) % 3;
```
Right now, I'm not interested in trying to figure out the right variant. Anyway, the programmer wrote some average meaningless version of the code:
```
size_t extraBytes = 3 - length % 3;
```
Right at the moment of analyzing this code, the analyzer uses data flow analysis. Whatever value is in the *length* variable, after modulo division, a value in the range [0..2] will be obtained. The PVS-Studio analyzer can work with ranges, exact values, and sets. That is, we are talking about [Value Range Analysis](https://en.wikipedia.org/wiki/Value_range_analysis). In this case, it is the range of values that will be used.
Let's continue the evaluations:
```
size_t extraBytes = 3 - [0..2];
```
It turns out that the *extraBytes* variable will never be equal to zero. The analyzer will evaluate the following possible range of its values: [1..3].
Until the moment of checking, the variable is not changed anywhere. The analyzer reports us that the check result will always be true. Therefore, the tool is absolutely right:
```
if (extraBytes > 0)
```
This is a simple but wonderful example. It shows how the data flow analysis allowed us to evaluate the range of variable values. It also helped us to be certain that the variable does not change, and finally, that the condition is always true.
Of course, the incorrectness of function operation is not limited to the execution of a code fragment that should not be executed. Everything goes awry there. Imagine, you want to encode 6 characters. In this case, the output string must contain 8 characters. Let's quickly estimate how the considered function will behave.
```
// calculate extra bytes needed to get a multiple of 3
size_t extraBytes = 3 - length % 3; // 3-6%3 = 3
// number of base64 bytes
size_t encodedBytes = 4 * (length + extraBytes) / 3; // 4*(6+3)/3 = 12
std::string encoded_string(encodedBytes, '=');
```
The output string happened to contain 12 characters, not 8. Further, everything will work in a wrong way, too. There's no point in going into details.
That's how nice and easy static analysis found the error in the code. Just imagine how painful it would be to debug and understand why the characters encoding in Base64 encoding went wrong. By the way, here comes the question of the third-party libraries' quality. I touched upon it in the following article: [Why it is important to apply static analysis for open libraries that you add to your project](https://www.viva64.com/en/b/0762/).
Try to use PVS-Studio regularly in your development process to find many bugs as early as possible. You'll like it :). If you are developing an open-source project, you can use the analyzer for [free](https://www.viva64.com/en/b/0614/). Thanks for your attention. Wish you bugless code. | https://habr.com/ru/post/543138/ | null | en | null |
# Робот, который таки ответит на вопрос о погоде в Токио (на самом деле — нет, но уже близко)
Собственно, после одного из недавних [постов](https://habrahabr.ru/company/ibm/blog/303666/) [@IBM](https://habrahabr.ru/users/ibm/) возникла идея скрестить ~~ежа с ужом~~ [Dialog](http://www.ibm.com/smarterplanet/us/en/ibmwatson/developercloud/dialog.html) с [Natural Language Classifier](http://www.ibm.com/smarterplanet/us/en/ibmwatson/developercloud/nl-classifier.html). Причём тут Токио? А при наличии возможности определить его как сущность типа «город» в dialog и сохранить в профиле для обработки. Впрочем, именно получения погоды под катом не будет. Однако, по идее, можно прицепить обработку соответствующей «команды».
Перед началом работы понадобится зарегистрироваться в [Bluemix](https://console.ng.bluemix.net/registration/), создать приложение и получить учётные данные для Dialog и Natural Language Classifer. Само же приложение может быть локальным.
Код полученной библиотеки (на Kotlin, должно легко сочетаться с Java и, вероятно, другими языками на платформе JVM) — [тут](https://github.com/alex4321/watson-dialog-nlc-robot). Бинарная же сборка — [тут](https://drive.google.com/file/d/0B7cY3wBgM-aBRldXeGVnOElEc1U/view?usp=sharing) (кстати, куда её лучше забросить? CVS всё же про исходники). Вкратце, основные моменты:
* Сценарий описывается XML-файлом (как «надмножество» Dialog-й разметки). Классы, соответственно, определены в нём же.
* После классификации наиболее подходящий класс будет передан перед пользовательским вводом в Dialog (например — «isn't it too cold in Moscow» — «temperature isn't it too cold in Moscow»). Есть возможность подмены «команды» в выводе результатом её выполнения. Например, [Text:$City] заменится на содержимое переменной City (впрочем, нужна реализация команды — стандартных нет).
Пример кода сценария показан далее. Обратите внимание — ссылки на классы в input/grammar оформлены как [имяКласса]:
**Много XML**xml version="1.0" encoding="UTF-8"?
Hello, I'm Watson-based chatbot and can tell you about weather.
Goodbye.
I don't understand you.
[temperature] \*
$ (City)={City}
I processed your request. Temperature in [Text:$City] is [Temperature:$City]
\*
Send a city name.
I can't process this request.
[conditions] \*
$ (City)={City}
I processed your request. Conditions in [Text:$City] is [Conditions:$City]
\*
Send a city name.
I can't process your request
$ (City)={City}
I processed your request. Temperature in [Text:$City] is [Temperature:$City]
$ (City)={City}
I processed your request. Conditions in [Text:$City] is [Conditions:$City]
Tokyo
Ottawa
Moscow
Is it windy?
Will it rain today?
What are the chances for rain?
Will we get snow?
Are we expecting sunny?
Is it overcast?
Will it be cloudy?
How much rain will fall today?
How much snow are we expecting?
Is it windy outside?
How much snow do we expect?
Is the forecast calling for snow today?
Will we see some sun?
When will the rain subside?
Is it cloudy?
Is it sunny now?
Will it rain?
Will we have much snow?
Are the winds dangerous?
What is the expected snowfall today?
Will it be dry?
Will it be breezy?
Will it be humid?
What is today's expected humidity?
Will the blizzard hit us?
Is it drizzling?
How hot is it today?
Is it hot outside?
Will it be uncomfortably hot?
Will it be sweltering?
How cold is it today?
Is it cold outside?
Will it be uncomfortably cold?
Will it be frigid?
What is the expected high for today?
What is the expected temperature?
Will high temperatures be dangerous?
Is it dangerously cold?
When will the heat subside?
Is it hot?
Is it cold?
How cold is it now?
Will we have a cold day today?
When will the cold subside?
What highs are we expecting?
What lows are we expecting?
Is it warm?
Is it chilly?
What's the current temp in Celsius?
What is the temperature in Fahrenheit?
Как видно — в сценарии определены классы [temperature, conditions] и тип сущности City с возможными значениями [Tokyo, Ottava, Moscow].
Пример кода, который запустит обучение и выдаст «вводное» сообщение по его завершению:
**Исходник**
```
package com.alex4321.botdemo
import com.alex4321.bot.*
fun main(args: Array) {
if (args.size != 7 && args.size != 6) {
println("Need arguments [path, dialogUsername, dialogPassword, nlcUsername, nlcPassword, dialogID, nlcID] or " +
"[path, dialogUsername, dialogPassword, nlcUsername, nlcPassword, robotName]")
return
}
val path = args[0]
val dialogUsername = args[1]
val dialogPassword = args[2]
val nlcUsername = args[3]
val nlcPassword = args[4]
val robotName = if (args.size == 6) {
args[5]
} else {
""
}
val dialogId = if (args.size == 7) {
args[5]
} else {
""
}
val nlcId = if (args.size == 7) {
args[6]
} else {
""
}
val new = dialogId == "" && nlcId == ""
val code = WatsonProgramPath(path).read()
val program = WatsonNlcDialogProgram(code)
val auth = WatsonRobotAuth(dialogUsername, dialogPassword, nlcUsername, nlcPassword)
val robot = WatsonRobot(program, dialogId, nlcId, auth)
if (new) {
robot.train(robotName)
print("Dialog ID : ")
println(robot.dialogID)
print("NLC ID : ")
println(robot.nlcID)
println("Training")
while (! robot.available) {
Thread.sleep(10000)
}
}
println("Ready")
val conversation = robot.converse()
val intro =conversation.intro()
println(intro.response)
println(intro.profile)
}
```
Для начала работы нужно передать аргументы:
* path — путь к разметке сценария
* dialogUsername, dialogPassword, nlcUsername, nlcPassword — см. ваши данные для доступа в Bluemix
* robotName — уникальное наименование. Используется для именования диалогов и классификаторов
После запуска и обучения (не самый быстрый процесс, да) получим что-то типа:
```
Dialog ID : 93791233-53fb-42c7-8581-6bc2bb761e6a
NLC ID : 2374f9x68-nlc-7617
Training
Ready
[Hello, I'm Watson-based chatbot and can tell you about weather.]
{}
```
Добавим пользовательский ввод:
**Исходник**
```
package com.alex4321.botdemo
import com.alex4321.bot.*
fun main(args: Array) {
if (args.size != 7 && args.size != 6) {
println("Need arguments [path, dialogUsername, dialogPassword, nlcUsername, nlcPassword, dialogID, nlcID] or " +
"[path, dialogUsername, dialogPassword, nlcUsername, nlcPassword, robotName]")
return
}
val path = args[0]
val dialogUsername = args[1]
val dialogPassword = args[2]
val nlcUsername = args[3]
val nlcPassword = args[4]
val robotName = if (args.size == 6) {
args[5]
} else {
""
}
val dialogId = if (args.size == 7) {
args[5]
} else {
""
}
val nlcId = if (args.size == 7) {
args[6]
} else {
""
}
val new = dialogId == "" && nlcId == ""
val code = WatsonProgramPath(path).read()
val program = WatsonNlcDialogProgram(code)
val auth = WatsonRobotAuth(dialogUsername, dialogPassword, nlcUsername, nlcPassword)
val robot = WatsonRobot(program, dialogId, nlcId, auth)
if (new) {
robot.train(robotName)
print("Dialog ID : ")
println(robot.dialogID)
print("NLC ID : ")
println(robot.nlcID)
println("Training")
while (! robot.available) {
Thread.sleep(10000)
}
}
println("Ready")
val conversation = robot.converse()
val intro = conversation.intro()
println(intro.response)
println(intro.profile)
while(true) {
val input = readLine() as String
if (input == "exit") {
break
}
val answer = conversation.answer(input)
println(answer.response)
println(answer.profile)
}
}
```
В результате — что-то типа такого:
```
Ready
[Hello, I'm Watson-based chatbot and can tell you about weather.]
{}
Isn't it too cold in Moscow?
[I processed your request. Temperature in Text is Temperature, , Goodbye.]
{City=Moscow}
```
Или
```
Ready
[Hello, I'm Watson-based chatbot and can tell you about weather.]
{}
Isn't it cold now?
[Send a city name.]{}
Moscow
[I processed your request. Temperature in Text is Temperature.]
{City=Moscow}
```
Ну и собственно обработка команд. Обработчики имеют тип BiFunction. На входе — полученный при разборе аргументов список и пользовательский ввод. На выходе — текст, полученный при обработке команды. Например:
**Ещё исходник**
```
package com.alex4321.botdemo
import com.alex4321.bot.*
import java.util.function.BiFunction
fun main(args: Array) {
CommandHandler.register("Text", BiFunction { args, input -> args[0] })
if (args.size != 7 && args.size != 6) {
println("Need arguments [path, dialogUsername, dialogPassword, nlcUsername, nlcPassword, dialogID, nlcID] or " +
"[path, dialogUsername, dialogPassword, nlcUsername, nlcPassword, robotName]")
return
}
val path = args[0]
val dialogUsername = args[1]
val dialogPassword = args[2]
val nlcUsername = args[3]
val nlcPassword = args[4]
val robotName = if (args.size == 6) {
args[5]
} else {
""
}
val dialogId = if (args.size == 7) {
args[5]
} else {
""
}
val nlcId = if (args.size == 7) {
args[6]
} else {
""
}
val new = dialogId == "" && nlcId == ""
val code = WatsonProgramPath(path).read()
val program = WatsonNlcDialogProgram(code)
val auth = WatsonRobotAuth(dialogUsername, dialogPassword, nlcUsername, nlcPassword)
val robot = WatsonRobot(program, dialogId, nlcId, auth)
if (new) {
robot.train(robotName)
print("Dialog ID : ")
println(robot.dialogID)
print("NLC ID : ")
println(robot.nlcID)
println("Training")
while (! robot.available) {
Thread.sleep(10000)
}
}
println("Ready")
val conversation = robot.converse()
val intro = conversation.intro()
println(intro.response)
println(intro.profile)
while(true) {
val input = readLine() as String
if (input == "exit") {
break
}
val answer = conversation.answer(input)
println(answer.response)
println(answer.profile)
}
}
```
Теперь вывод выглядит так:
```
Ready
[Hello, I'm Watson-based chatbot and can tell you about weather.]
{}
Isn't it too cold in Moscow?
[I processed your request. Temperature in Moscow is Temperature, , Goodbye.]
{City=Moscow}
```
P.S.: и да, код явно не лучший, согласен. Жду критики.
UPD. Исправил очепятку в адресе репозитария. | https://habr.com/ru/post/304282/ | null | ru | null |
# Итератор в шаблонизаторе doT.js по объектам с фильтрацией
Компактный (3.5 Кб) и быстрый шаблонизатор **doT.js** для браузеров и nodeJS до сих пор (v.1.0.1) имеет итерацию только по массивам. Это не всегда удобно — подгонять управляющий объект под наличие в нём массивов. Лучше подогнать шаблонизатор под наличие в нём **итератора по объектам c проверкой условия**. Проверять условия в циклах по объектам приходится часто — это и hasOwnProperty(), и проверка на DOM-объект, и взятие части хеша по фильтрации индексов.
Как пишут в шаблоне итерацию по массиву? Примерно так:
```
{{~it.elemsArray:property:i}} ... {{~}}
```
Внутри цикла можно использовать {{=property}} (значение текущего свойства), {{=i}} (индекс массива) и выражения, основанные на них. Ничего не мешает дописать в шаблонизаторе проверку не только на массив, но и на объект, чтобы корректно выбрать дальнейшее построение цикла. Для этого понадобится забраться внутрь достаточно простого шаблонизатора и переписать цикл, уже работающий по массивам, на цикл, который будет работать по объектам. Оставив, конечно, исходную возможность в общем коде.
Добавим в шаблонизатор ещё один тип итератора. *(Число команд в арсенале увеличится на одну — {{@ ...}}, поэтому шаблонизатор станет работать немного медленнее — на время поиска ещё одного регекспа по шаблону.)*
```
{{@ it.elemsObject : property : i : condition}} ... {{@}}
```
**(другой возможный вариант)**Если же совместить итераторы в один, замедления практически не будет, так как регулярное выражение усложнится незначительно, и то, в конце себя. *(Этот вариант сейчас реализовывать не будем, чтобы не превращать шаблонизатор в другой.)*
```
{{~ it.elemsObjectOrArray : property : i : condition}} ... {{~}}
```
Усложнится дальнейшая генерация кода, но она, как известно, выполняется быстро. (Медленнее, скорее всего, будет даже не парсинг шаблона, а интерпретация синтезированного кода.)
"*condition*" здесь — просто исполняемая часть выражения. Особенность этого шаблонизатора, как и многих других — в том, что он синтезирует JS-код (что называется — компилирует шаблон), превращая его в исполняемую функцию, и тут же её выполняет. Воспользуемся этим, чтобы просто присоединить часть выражения к значению *property*, которое вычисляется в цикле. Как известно, цикл по объектам в JS часто выглядит так:
```
if(it.elemsObject)
for(var i in it.elemsObject){
var property = it.elemsObject[i];
if(property condition){
... тело цикла ...
}};
```
Именно это и будет делать итератор по объекту в нашем дополнении. Синтакически непонятное «property condition» — это наша уловка, полноценно использующая и без того существующий недостаток этого шаблонизатора — неявное исполнение eval() в new Function(). Чтобы не нарушать синтаксическую целостность кода, надо будет соблюдать требование, чтобы *condition* было выражением, не меняющим смысл при сцеплении с *property*.
Вот 3 наиболее популярных примера, когда это нужно и как это будет выглядеть.
1. Цикл по собственным свойствам
{{@ it.elemsObject: propName: ii :.hasOwnProperty(ii)}}… {{@}}
2. Цикл по DOM-элементам
```
{{@ it.elemsObject : elName : ii :.attributes}} ... {{@}}
```
Даст цикл:
```
var arr1 = it.elemsObject;
if(arr1)
for(var ii in arr1){
var elName = arr1[ii];
if(elName.attributes){
out += '...'
}}
```
3. Цикл по части основного объекта
```
{{@ it.elemsObject : elName : ii :, /y\d+/.test(ii) }} ... {{@}}
```
Выбирает для итераций только те объекты, индексы которых выглядят как «y<число>».
Последний пример сильно расширяет гибкость использования шаблонов — в корень общего объекта можно поместить одну или несколько коллекций элементов, отличающихся форматом индекса или свойствами своих значений. (Например, значения могут быть объектом со свойством — признаком коллекции. Здесь же продемонстрировано, как легко отказаться в шаблоне от элемента propName по умолчанию — просто поставив запятую, превратив выражение в перечисление выражений.
В существующем шаблонизаторе такие циклы, на самом деле, можно было бы реализовать за счёт использования конструкции «evaluate»: *{{ <произвольные операторы> }}*. Тогда пришлось бы полностью описать свой цикл в шаблоне. Но вместо этого создаём небольшое дополнение конструкции цикла по массивам, чтобы иметь краткую запись условного выражения, не теряющую понятности. Немного грамотно было бы (для больших систем) — обернуть выражение в функцию (чтобы не иметь составного синтаксиса), что, кстати, замедлило бы его и потребовало бы явно писать имя *property* в условии.
Для справки, цикл, который делает существующий шаблонизатор по массивам, выглядит так:
```
var arr1 = it.elemsObject;
if(arr1){
var vname, ii =-1, l1 = arr1.length -1;
while(ii < l1){
vname = arr1[++ii];
out += '...'
}}
```
Поэтому он не мог работать c объектами — он использует счётчик. Который, наверное, немного быстрее, чем универсальный цикл for-in, но потеря времени идёт не на циклах. Теряется время на интерпретации синтезированного шаблона. Не будем в данном расширении его как-либо совершенствовать, чтобы полностью сохранить работоспособность и поведение существующих шаблонов.
Есть в нашем новом типе цикла, c condition в конце, небольшое, но естественное ограничение — в нём нельзя использовать 2 символа "}" подряд. Во всех случаях кода это легко обойти. Допустимо писать многострочные выражения с определениями функций, например, не забывая лишь о том, что "}}" — это конец заголовка итератора. Пример:
```
{{@ it :year:i:, aa = function(){
return 1234;
}, /^y\d+$/.test(i + aa) }}
```
С такими возможностями шаблон легко превращается в описание функций с небольшими вставками HTML (а не наоборот). Необязательно это удобно, но ограничения на JS в итераторе мы сняли.
### Сопутствующие доработки
Значения propName: ii можно не писать — регексп парсинга в шаблонизаторе поправлен так, чтобы при отсутствии значений подставлялись имена по умолчанию. Имя свойства по умолчанию — arrI1, arrI2 и далее, в зависимости от порядкового номера заголовка итератора. Индекс объекта по умолчанию — i1, i2 или далее. Такие странные имена выбраны по историческим причинам — такие же существуют в doT.js для индексов массивов, а неявные имена массивов выглядели как arr1, arr2 и далее. Мы просто сохраняем традицию: если имя хеша — arr1, то имя его свойства — arrI1 (равно arr1[i1]). Например,
```
{{@ it.elemsObject :::.attributes}}
```
равносильно
```
{{@ it.elemsObject : arrI1 : i1 :.attributes}}
```
(если это — первый заголовок итератора в шаблоне)
или
```
{{@ it.elemsObject : arrI2 : i2 :.attributes}}
```
(если это — второй заголовок итератора в шаблоне, и т.д.)
Если подумать над качеством чтения шаблона, то имя по умолчанию правильнее было бы выбрать как последнее в составном имени объекта. В данном примере — elemsObject. Было бы так: {{@ it.elemsObject}} равен {{@ it.elemsObject: elemsObjectI1: i1}}. Но ради исторического соответствия не будем вводить такое правило для итератора.
\* Второе важное дополнение. Чтобы не удалялись элементы со значением 0||''||false||null — фильтр цикла становится true (фильтр не действует), если выражение в заголовке итератора отсутствует.
И третье — многострочный парттерн в регекспе для первого параметра (имя массива или объекта) заменён на однострочный (".+"). Это приводит к небольшому ускорению парсинга (3% по измерениям).
4. Добавлена возможность записи инлайновых одноуровневых (многострочных) хешей, как видно в примере на [jsfiddle](http://jsfiddle.net/spmbt/6KU9Y/2/). Существует возможность записи инлайновых массивов (в итераторе по объектам), как видно в том же примере.
### Сравнение скоростей
**Сколько же мы заплатим по времени исполнения за то, что включим в шаблонизатор возможность цикла по объектам?**
Ответ на вопрос даст тест, который лежит в проекте doT.js на Гитхабе. Его понадобится переписать, потому что он измеряет скорости скомпилированных шаблонов, а интересует в первую очередь разница в скоростях компиляции. Будем для простоты рассматривать тесты в Хроме (версия 30). На других браузерах их легко повторить и сделать похожие выводы и сравнение.
Он изначально сделан для сравнения сильно укороченного doU.js и полного doT.js, и показывает, насколько медленнее исполняемая часть полной функции doT.compile() по сравнению с сильно укороченной. Ещё там доказывается, что использование «it» вместо this почти не имеет разницы на длинных шаблонах, поэтому тесты изобилуют строчками измерений разных простых вариантов. Шаблон, скорость работы которого измеряется, выглядит так:
```
Just static text
================
\
Here is a simple {{=it.f1}}
\
test {{=it.f2}}\
{{=it.f3}}\
{{!it.f4}}\
```
Или его модификации, или повторения много раз (32-128-256). Нас интересуют эти тесты, чтобы показать, что лишняя проверка на заголовок итератора не замедлила работу простых шаблонов.
Для наших целей интересуют ещё тесты циклов. Чтобы их скорость была примерно равна скорости простых шаблонов, написан такой шаблон для теста (он без переносов строк):
```
Text from hash
==============
\
{{@it::i}} {{=i}}: {{=it[i]}} : {{@}}\
{{@it:val:i}} {{=i}}: {{=val}} : {{@}}\
{{@it:a}} {{=a}}: {{=a}} : {{@}}\
```
Для тестирования в старом шаблонизаторе doT.js версии 1.0.1 символы "@" заменялись на "~". То же — для тестирования по массивам — в новом. И данные использовались для одного случая — хеши, для другого — массивы с тем же количеством элементов. По результатам внизу диаграммы увидим, кто из них быстрее.
Будет интересовать как несжатая (doT11.js), так и сжатая (doT11m.js) новая версия. Для прохождения тестов переменную doT в каждой версии пришлось сделать уникальной. На картинках изображены диаграммы скоростей прохождения тестов (число вычислений с секунду): больше — быстрее, а значит, лучше. Первая картинка — это результат (внимание) скомпилированных шаблонов. Поэтому они такие быстрые — 500-700 К в секунду, а разница между минифицированной версией и несжатой не имеет того смысла, который мы хотим видеть. Зато, этот тест показывает, насколько медленнее полный цикл (строчки «5. doT.js», 6, 7) по сравнению с результатами компиляции (больше показатель — лучше).
Результаты показывают, что время компиляции шаблона занимает огромную долю общего времени — от 99% для коротких шаблонов до 90% для длинных (больше 10КБ), а для перезагруженного браузера — 92% и 75% при тех же условиях. Это есть плата за неявные eval(), которые приходится выполнять при дешаблонизации.
По числам видно, что минифицированный код работает быстрее на 1-1.5%. А исполнение компилированных шаблонов, по идее, не должна вообще зависеть от минификации. Зависимость — или проявление случайных погрешностей, или ошибки компиляции функций, или погрешности измерительного инструмента.
**Тот же тест для Firefox 25**
**Тот же тест для IE 8 (в 8 раз медленнее Хрома)**
Отдельного внимания заслуживает сравнение 2 типов циклов. Как предполагалось, цикл по массиву работает быстрее на почти тех же шаблонах, но немного различных данных. Разница — в 20% для коротких шаблонов, 25% для шаблонов средней длины (2-5 КБ с числом циклов до 300 в шаблоне). При 100 и более циклах в Хроме появляется интересный эффект, видимо, связанный с числом переменных в скомпилированной функции. Производительность цикла по объектов остаётся на обычном уровне, а циклы по массивам вдруг начинают резко проседать с ростом числа циклов (и переменных) в шаблоне. Например, при 190 циклах тест шаблона становится медленнее на 10%, а при 750 циклах — вообще чуть ли не тормозится — 6% от скорости шаблона по объектам.
Следующий рисунок иллюстрирует начало коллапса циклов по массивам на длинных шаблонах с числом циклов 386 (больше показатель — лучше).
Интересен вопрос — есть ли порог коллапса для цикла по объектам? Да. Увеличив объём тестового шаблона ещё в 2 раза (до 512 копий короткого шаблона), получаем зависание браузера на итерациях по массиву и раз в 10 меньшую скорость работы циклов по объектам. (Возможно, в таком режиме что-то не оптимизировано и переполняется какой-нибудь стек. Или так влияет скрипт тестирования, использованный в данном проекте, который, кроме шаблонизации, делает ещё тысячи и сотни тысяч повторений тестов, и у него тоже могло что-нибудь «потечь». Пока же делаем вывод, что предел числа циклов в шаблоне и в функциях JS вообще — есть. Лучше не делать больше 1000 циклов по объектам в одном шаблоне (для Хрома).)
Ещё замечен эффект общего замедления работы шаблонизатора со временем работы открытого браузера и проведения измерений в нём. При этом скорость работы по массивам начинает выглядеть не такой значительно повышенной по отношению к скорости по объектам.
### Скорости интерпретации шаблонов
Исходный интерес в вопросе о скоростях был в скорости интерпретации итератора по объектам. То, что скомпилированный шаблон по массиву работает быстрее — уже выяснили. Но разработчикам часто интересны не компилирвоанные шаблоны, а их интерпретация, пусть она и в 10-100 раз медленнее этапа исполнения. Ведь если надо отрисовать страницу за 30 мс, обычно не задумываются о компиляции для последующих отрисовок за 3 мс. Сделаем тесты для интерпретации наших шаблонов, используя те же заготовки функций и данных. Именно тут сыграет свою роль заготовка минифицированного шаблонизатора — в первой серии измерений она не имела значения.
В имеющихся тестах тоже есть отдельная страничка для отдельной компиляции (без исполнения). Преобразуем тесты на ней в полные, добавив исполнение отрисовки шаблонов. Это, практически, не изменит картину, но даст реалистичные тесты, более похожие на практические задачи.
Запускаем файл **doT/benchmarks/compileBench.html**.
Эта группа тестов показала всё, что нас интересовало:
1) минифицированный код показывает стабильное ускорение для одиночных коротких шаблонов — на 5%;
2) для тех же, но несжатых функций, короткие шаблоны демонстрируют замедление по сравшению с старым кодом в тестах с циклами измерений, на 4%;
3) для длинных шаблонов новый код всегда стабильно быстрее на 3%;
Интуитивно казалось, что сравнение покажет замедление на 10%, особенно там, где надо парсить массивы — примерно на столько увеличивается работа по проходам регекспов по шаблону. Изменения показывают соответствие этим предположениям, но совсем не такое значительное. Во-первых, оно скомпенсировано улучшением шаблона массива без потери свойств (".\*"), во-вторых — шаблон стал медленее на коротких шаблонах на 4% (на всех, не только массивы), но разница исчезает на длинных — в этом и заключается ожидаемое замедление.
Отдельной группой стоят измерения по другим шаблонам, с циклами (3 последних измерения). Третье — это шаблон по массивам в старом коде. Его пришлось чуть подправить, чтобы не было неявных переменных ("~it:val:i", а не "@it::i"). Возможно, поэтому он немного медленее, на 10% в коротких шаблонах. Видны другие особенности:
4) Интерпретатор по объектам медленнее интерпретатора по массивам на 3-5%;
5) исполнение того и другого было быстрее относительно других измерений, а интерпретация — в 2-3 раза медленнее; чем длиннее шаблон, тем медленнее;
6) старый код по массивам не быстрее нового кода по объектам — быстрее на указанные 3-5% лишь новый код по массивам. (Этот эффект получен небольшим переписыванием кода компиляции — использованы "++" вместо "+=1".)
7) скорость работы шаблонов и быстрота работы по массивам заметно (в разы) зависит от перезагрузки браузера. Массивы быстрее циклов по объектам на 20% вначале и на 5% через некоторое время работы тестовой страницы. Возможно, это — не только эффект работы функции, но и влияние среды тестирования (тестировалось в Хроме 32bit, Win).
Ответы на вопрос, не стал ли код хуже, мы получили. В целом, он не требует дальнейших доработок, чтобы его работа стала похожа на работу старого кода. Заменять старый на новый в существующих проектах — можно. Даже, если вопрос включает и скорости компиляции или исполнения.
**Ещё раз не мешает напомнить**: интерпретация (см. тесты) — гораздо медленнее исполнения скомпилированных шаблонов. Если где-то в проекте важна скорость и есть более одного исполнения шаблона — используйте отдельную компиляцию (doT.compile()).
### Хакнем шаблонизатор дальше?
Если описанное решение хорошо подходит для осторожного расширения функций как ничего не меняющее для старого кода, лишь добавляющее новый итератор, то для новых проектов можно использовать сразу вариант, в котором цикл над массивами while заменён на универсальный цикл for-in, а к циклу над массивом добавлено выражение-фильтр. Два типа итератора объединяются фактически в один, а скорость парсинга практически не страдает, как и скорость прохождения цикла. Могут быть побочные эффекты, поэтому замену на второй вариант неплохо бы протестировать в существующем проекте, чтобы определить, не будет ли нештатных ситуаций с ошибочными шаблонами. Меняются циклы, а значит — меняются побочные эффекты от ошибок.
Для цикла for-in над массивом для некоторых старых браузеров надо следить, чтобы итератор работал только над числовыми индексами и не захватил в итерацию свойство length. Требование отлично выполняется имеющимся механизмом фильтрации цикла, поэтому остаётся написать лишь корректную проверку, если объект оказался массивом. Не лишней будет такая проверка и для коллекций типа arguments или attributes. И точно не лишней — для объектов, унаследовавших свойства массива. Объекты на основе массива будут по умолчанию итерироваться только по числовым индексам.
Впрочем, это — несколько другая задача. В данной статье ограничимся сделанным осторожным расширением, которое проверено и работает на одном проекте.
### Результаты
Исследовано дополнение шаблонизатора doT.js до возможности итерации по объектам, сделанное с целью получить расширение, не нарушающее остальные свойства имеющейся версии.
Получили:
1) итерацию в шаблоне по объектам ({{@...}}) с возможностью фильтрации части элементов по любому условию;
2) возможность не указывать неиспользуемые параметры и двоеточия в конце заголовка итератора;
3) для итератора по массивам добавлена аналогичная возможность не указывать параметры в заголовке итератора по массивам;
4) нет потери скорости в работе шаблонизатора по сравнению со старой версией (есть незначительная потеря на коротких шаблонах);
5) минифицированная версия — на 250 байт больше, а на коротких шаблонах работатет немного быстрее;
6) на длинных шаблонах новая версия — на 3% быстрее при полном цикле (компиляция + исполнение).
О минификации. Результаты необходимо руками исправлять — восстанавливать переменные «global» и «doT», чтобы всё корректно работало. Этого не сделано в минифицированной версии 1.0.1 на гитхабе автора, поэтому она работает не совсем так, как несжатая (doT не появляется в глобальном окружении).
Брать [в ветке GitHub](https://github.com/spmbt/doT); [jsFiddle для проверки](http://jsfiddle.net/spmbt/6KU9Y/2/). | https://habr.com/ru/post/201592/ | null | ru | null |
# Python на примере демона уведомления о новых коммитах Git
Работая в команде я люблю быть в курсе активности участников. Поэтому было решено написать демона наблюдающего за поступлением новых коммитов в репозиторий *git*’а. Так как я работаю в *Ubuntu*, то уведомление было реализовано встроенным способом — библиотекой *libnotify*.
Язык — *Python*!
В статье упоминается:
1. Демон на *Python*;
2. Логирование на *Python*;
3. Хранение конфигурационных файлов программ на *Python*;
4. Работа с командами ОС из скриптов *Python*;
5. Получения списка последних изменений из *git*’а;
6. Стандартные всплывающие уведомления *Ubuntu*.
Для реализации задачи был выбран язык *Python* (высокоуровневый, интерпретируемый, объектно-ориентированный и расширяемый язык программирования), так как я его не знаю.
Для начала мне очень помогли два источника:
— официальная документация: <http://docs.python.org/tutorial/index.html>;
— цикл статей *IBM* на русском языке: <https://www.ibm.com/developerworks/ru/library/l-python_part_1/>.
Во время изучения основ, приступаем к написанию программы.
#### 1. Демон
В сети встречается много реализаций демонов, выбрал один из готовых с положительными отзывами и привлекательным названием: <http://www.jejik.com/articles/2007/02/a_simple_unix_linux_daemon_in_python/>. У этого демона были проблемы с завершением работы командой "*daemon.py stop*" вот в этом месте:
```
except OSError, err:
err = str(err)
if err.find("No such process") > 0:
if os.path.exists(self.pidfile):
os.remove(self.pidfile)
```
Это как видно возникло это из-за русской локали, фраза "*No such process*" в моей системе возвращалась на русском языке. Простой способ исправить — удалить эту проверку:
```
except OSError, err:
if os.path.exists(self.pidfile):
os.remove(self.pidfile)
```
#### 2. Ведение логов
Простейшим средством оповещение о процессе работы программы является использование функции *print*(). Но эта программа будет запускаться в качестве демона и не предполагает вывод информации о своем состоянии в консоль запуска. Удобным вариантом в этом случае является запись лога в файл. В *Python*’е есть встроенный способ логирования входящий в стандартную библиотеку — модуль *logging* (<http://docs.python.org/library/logging.html>).
Модуль имеет множество вариантов ведения лога (*handlers*, <http://docs.python.org/library/logging.handlers.html>): *StreamHandler*, *FileHandler*, *WatchedFileHandler*, *RotatingFileHandler*, *TimedRotatingFileHandler*, *SocketHandler*, *DatagramHandler*, *SysLogHandler*, *NTEventLogHandler*, *SMTPHandler*, *MemoryHandler*, *HTTPHandler*. Для контроля работы демона использовался *FileHandler*:
```
logging.basicConfig(filename = tempfile.gettempdir() + '/gitPushNotify.log',
level = logging.DEBUG,
format = '%(asctime)s %(levelname)s: %(message)s',
datefmt = '%Y-%m-%d %I:%M:%S')
logging.info('Daemon start')
```
#### 3. Хранение конфигурации программ на *Python*
Для хранения конфигурации приложений используется *ini* файл и встроенный модуль работы с ними *ConfigParser* (<http://docs.python.org/library/configparser.html>):
```
config = ConfigParser.ConfigParser()
configPath = os.path.dirname(__file__) + '/config.ini'
config.read(configPath)
```
Получение значения параметров функциями (в данном случае получение *integer* значения):
```
timeout = config.getint('daemon', 'timeout')
```
#### 4. Работа с командам ОС из скриптов *Python*
Для выполнения системных команд используется метод *check\_output*() модуля *subprocess* (<http://docs.python.org/library/subprocess.html>):
```
sourceOutput = subprocess.check_output('cd ' + repositoryPath, shell=True)
```
Также можно использовать методы модуля *os*:
```
sourceOutput = os.system(commandString)
```
Документация рекомендует использовать *subprocess*.
#### 5. Получения списка последних изменений из *git*’а
Для просмотра последних изменений репозитория удобно использовать команду *whatchanged* (<http://schacon.github.com/git/git-whatchanged.html>). Эта команда позволяет задавать формат выводимых сообщений лога, устанавливать количество выводимых изменений. Пример использования команды:
`$ git whatchanged master -10 --date=raw --date-order --pretty=format:"%H %n%cn %n%ce %n%ct %n%s"`
Аргументы по порядку:
*master* — ветка репозитория;
*-10* — количество выводимых записей;
*--date-order* — сортировка по дате изменения;
*--pretty=format:"..."* — формат вывода.
#### 6. Стандартные всплывающие уведомления *Ubuntu*
Работа со всплывающими уведомлениями в *Ubuntu* осуществляется через библиотеку *libnotify* (<https://wiki.ubuntu.com/NotificationDevelopmentGuidelines>). Проверить установлена ли она можно командой:
`$ dpkg -l | grep libnotify-bin`
Либо сразу выполнить:
`$ sudo apt-get install libnotify-bin`
Отобразить уведомление можно используя команду:
`$ notify-send "Habr!"
$ notify-send -i notification-message-email "Title" "Message"`
Флаг *-i* — изображение, указывается системное название или путь к любому изображению в формате *svg*, *png* или *jpg*.
#### Запуск демона
Необходимо сделать файл исполняемым:
`$ chmod +x gitPushNotifyDaemon.py`
Перед запуском в конфигурационном файле необходимо указать путь к репозиторию и частоту опроса:
`$ vim config.ini`
Запуск:
`$ python gitPushNotifyDaemon.py start`
Если всё прошло успешно:
`Daemon starting..`
Появится стартовое уведомление:
Теперь демона можно увидеть в списке процессов, выполнив команду:
`$ ps uax | grep gitPushNotifyDaemon.py`
За процессом работы демона можно наблюдать используя лог:
`$ tail -f /tmp/gitPushNotify.log`
Также можно отдельно запускать файл *gitPushNotify.py* для отладки:
`$ python gitPushNotify.py`
Репозиторий проекта: <https://github.com/antonfisher/gitPushNotify>
**На этом всё. Удачного дня!**
Ссылки:
1. <http://docs.python.org/tutorial/index.html> — официальный туториал;
2. <https://www.ibm.com/developerworks/ru/library/l-python_part_1/> — цикл статей *IBM*;
3. <http://www.jejik.com/articles/2007/02/a_simple_unix_linux_daemon_in_python/> — реализация демона от *Sander Marechal*;
4. <http://docs.python.org/library/logging.html> — *Python*, модуль *Logging*;
5. <http://docs.python.org/library/configparser.html> — *Python*, модуль *ConfigParser*;
6. <http://docs.python.org/library/subprocess.html> — *Python*, модуль *Subprocess*;
7. <https://wiki.ubuntu.com/NotificationDevelopmentGuidelines> — описание *libnotify*;
8. <http://schacon.github.com/git/git-whatchanged.html> описание команды *git-whatchanged*. | https://habr.com/ru/post/135408/ | null | ru | null |
# Checking Telegram Open Network with PVS-Studio
Telegram Open Network (TON) is a platform by the same team that developed the Telegram messenger. In addition to the blockchain, TON provides a large set of services. The developers recently made the platform's code, which is written in C++, publicly available and uploaded it to GitHub. We decided to check the project before its official release.
Introduction
------------
[Telegram Open Network](https://github.com/ton-blockchain/ton) is a set of various services. Among other things, it provides a payment system of its own based on the Gram cryptocurrency, and a virtual machine called TON VM, which executes smart contracts. It also offers a messaging service, TON Messages. The project as a whole is seen as a countermeasure to Internet censorship.
The project is built with CMake, so I didn't have any difficulties building and checking it. The source code is written in C++14 and runs to 210 thousand LOC:
Since the project is a small and high-quality one, there aren't many bugs in it, but they still should be dealt with.
Return code
-----------
```
static int process_workchain_shard_hashes(....) {
....
if (f == 1) {
if ((shard.shard & 1) || cs.size_ext() != 0x20000) {
return false; // <=
}
....
int r = process_workchain_shard_hashes(....);
if (r < 0) {
return r;
}
....
return cb.store_bool_bool(true) && cb.store_ref_bool(std::move(left)) &&
cb.store_ref_bool(std::move(right)) &&
cb.finalize_to(branch)
? r
: -1;
....
}
```
PVS-Studio diagnostic message: [V601](https://www.viva64.com/en/w/v601/) The 'false' value is implicitly cast to the integer type. mc-config.cpp 884
It looks like the function returns the wrong type of error status here. The function should apparently return a negative value for failure rather than true/false. That's at least what it does further in the code, where it returns -1.
Comparing a variable with itself
--------------------------------
```
class LastBlock : public td::actor::Actor {
....
ton::ZeroStateIdExt zero_state_id_;
....
};
void LastBlock::update_zero_state(ton::ZeroStateIdExt zero_state_id) {
....
if (zero_state_id_ == zero_state_id_) {
return;
}
LOG(FATAL) << ....;
}
```
PVS-Studio diagnostic message: [V501](https://www.viva64.com/en/w/v501/) There are identical sub-expressions to the left and to the right of the '==' operator: zero\_state\_id\_ == zero\_state\_id\_ LastBlock.cpp 66
TON follows a coding standard that prescribes that class members' names should end in an underscore. In cases like this, however, this notation may lead to a bug as you risk overlooking the underscore. The name of the argument passed to this function is similar to that of the class member, which makes it easy to mix them up. It is this argument that was most likely meant to participate in the comparison.
Unsafe macro
------------
```
namespace td {
namespace detail {
[[noreturn]] void process_check_error(const char *message, const char *file,
int line);
} // namespace detail
}
#define CHECK(condition) \
if (!(condition)) { \
::td::detail::process_check_error(#condition, __FILE__, __LINE__); \
}
void BlockDb::get_block_handle(BlockIdExt id, ....) {
if (!id.is_valid()) {
promise.set_error(....);
return;
}
CHECK(id.is_valid()); // <=
....
}
```
PVS-Studio diagnostic message: [V581](https://www.viva64.com/en/w/v581/) The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 80, 84. blockdb.cpp 84
The condition inside the *CHECK* macro will never execute as it has been already checked by the previous *if* statement.
There's also another error present here: the *CHECK* macro is unsafe since the condition inside it is not wrapped in a *do {… } while (0)* construct. Such wrapping is needed to avoid collisions with other conditions in the *else* branch. In other words, the following code wouldn't work as expected:
```
if (X)
CHECK(condition)
else
foo();
```
Checking a signed variable
--------------------------
```
class Slice {
....
char operator[](size_t i) const;
....
};
td::Result CellSerializationInfo::get\_bits(td::Slice cell) const {
....
int last = cell[data\_offset + data\_len - 1];
if (!last || last == 0x80) { // <=
return td::Status::Error("overlong encoding");
}
....
}
```
PVS-Studio diagnostic message: [V560](https://www.viva64.com/en/w/v560/) A part of conditional expression is always false: last == 0x80. boc.cpp 78
The second part of the condition will never execute because the type *char* is signed in this case. When assigning a value to a variable of type *int*, sign extension will occur, so its values will still lie within the range [-128, 127], not [0, 256].
It should be noted that *char* is not always signed: its behavior is platform- and compiler-dependent. So in theory, the condition in question could still execute when building on a different platform.
Bitwise-shifting a negative number
----------------------------------
```
template
bool AnyIntView|::export\_bits\_any(....) const {
....
int mask = (-0x100 >> offs) & 0xff;
....
}
```
PVS-Studio diagnostic message: [V610](https://www.viva64.com/en/w/v610/) Unspecified behavior. Check the shift operator '>>'. The left operand '-0x100' is negative. bigint.hpp 1925
Executing a bitwise right shift operation on a negative number is unspecified behavior: it's impossible to know in advance if the sign will be extended or padded with zeroes.
Null check after new
--------------------
```
CellBuilder* CellBuilder::make_copy() const {
CellBuilder* c = new CellBuilder();
if (!c) { // <=
throw CellWriteError();
}
....
}
```
PVS-Studio diagnostic message: [V668](https://www.viva64.com/en/w/v668/) There is no sense in testing the 'c' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. CellBuilder.cpp 531
The message says it all: if memory allocation fails, the program will throw an exception rather than return a null pointer. It means the check is pointless.
Redundant check
---------------
```
int main(int argc, char* const argv[]) {
....
if (!no_env) {
const char* path = std::getenv("FIFTPATH");
if (path) {
parse_include_path_set(path ? path : "/usr/lib/fift",
source_include_path);
}
}
....
}
```
PVS-Studio diagnostic message: [V547](https://www.viva64.com/en/w/v547/) Expression 'path' is always true. fift-main.cpp 136
This snippet is taken from one of the project's internal utilities. The ternary operator is redundant in this case: the condition it checks is already checked by the previous *if* statement. It looks like the developers forgot to remove this ternary operator when they decided to discard the use of standard paths (there's at least no mention of those in the help message).
Unused variable
---------------
```
bool Op::set_var_info_except(const VarDescrList& new_var_info,
const std::vector& var\_list) {
if (!var\_list.size()) {
return set\_var\_info(new\_var\_info);
}
VarDescrList tmp\_info{new\_var\_info};
tmp\_info -= var\_list;
return set\_var\_info(new\_var\_info); // <=
}
```
PVS-Studio diagnostic message: [V1001](https://www.viva64.com/en/w/v1001/) The 'tmp\_info' variable is assigned but is not used by the end of the function. analyzer.cpp 140
The developers were apparently going to use a variable named *tmp\_info* in the last line of this function. Here's the code of that same function but with other parameter specifiers:
```
bool Op::set_var_info_except(VarDescrList&& new_var_info,
const std::vector& var\_list) {
if (var\_list.size()) {
new\_var\_info -= var\_list; // <=
}
return set\_var\_info(std::move(new\_var\_info));
}
```
Greater or less than?
---------------------
```
int compute_compare(const VarDescr& x, const VarDescr& y, int mode) {
switch (mode) {
case 1: // >
return x.always_greater(y) ? 1 : (x.always_leq(y) ? 2 : 3);
case 2: // =
return x.always_equal(y) ? 1 : (x.always_neq(y) ? 2 : 3);
case 3: // >=
return x.always_geq(y) ? 1 : (x.always_less(y) ? 2 : 3);
case 4: // <
return x.always_less(y) ? 1 : (x.always_geq(y) ? 2 : 3);
case 5: // <>
return x.always_neq(y) ? 1 : (x.always_equal(y) ? 2 : 3);
case 6: // >=
return x.always_geq(y) ? 1 : (x.always_less(y) ? 2 : 3);
case 7: // <=>
return x.always_less(y)
? 1
: (x.always_equal(y)
? 2
: (x.always_greater(y)
? 4
: (x.always_leq(y)
? 3
: (x.always_geq(y)
? 6
: (x.always_neq(y) ? 5 : 7)))));
default:
return 7;
}
}
```
PVS-Studio diagnostic message: [V1037](https://www.viva64.com/en/w/v1037/) Two or more case-branches perform the same actions. Check lines: 639, 645 builtins.cpp 639
If you read carefully, you noticed that this code lacks a <= operation. Indeed, it is this operation that case 6 should be dealing with. We can deduce that by looking at two spots. The first is the initialization code:
```
AsmOp compile_cmp_int(std::vector& res, std::vector& args,
int mode) {
....
if (x.is\_int\_const() && y.is\_int\_const()) {
r.set\_const(compute\_compare(x.int\_const, y.int\_const, mode));
x.unused();
y.unused();
return push\_const(r.int\_const);
}
int v = compute\_compare(x, y, mode);
....
}
void define\_builtins() {
....
define\_builtin\_func("\_==\_", arith\_bin\_op,
std::bind(compile\_cmp\_int, \_1, \_2, 2));
define\_builtin\_func("\_!=\_", arith\_bin\_op,
std::bind(compile\_cmp\_int, \_1, \_2, 5));
define\_builtin\_func("\_<\_", arith\_bin\_op,
std::bind(compile\_cmp\_int, \_1, \_2, 4));
define\_builtin\_func("\_>\_", arith\_bin\_op,
std::bind(compile\_cmp\_int, \_1, \_2, 1));
define\_builtin\_func("\_<=\_", arith\_bin\_op,
std::bind(compile\_cmp\_int, \_1, \_2, 6));
define\_builtin\_func("\_>=\_", arith\_bin\_op,
std::bind(compile\_cmp\_int, \_1, \_2, 3));
define\_builtin\_func("\_<=>\_", arith\_bin\_op,
std::bind(compile\_cmp\_int, \_1, \_2, 7));
....
}
```
The *define\_builtins* function, as you can see, contains a call *compile\_cmp\_int* for the *<=* operator with the mode parameter set to 6.
The second spot is the *compile\_cmp\_int* function itself, which lists the names of operations:
```
AsmOp compile_cmp_int(std::vector& res, std::vector& args,
int mode) {
....
static const char\* cmp\_names[] = {"", "GREATER", "EQUAL", "GEQ", "LESS",
"NEQ", "LEQ", "CMP"};
....
return exec\_op(cmp\_names[mode], 2);
}
```
Index 6 corresponds to the *LEQ* word, which means «Less or Equal».
It's another nice bug of the [class of bugs found in comparison functions](https://www.viva64.com/en/b/0509/).
Miscellaneous
-------------
```
#define VM_LOG_IMPL(st, mask) \
LOG_IMPL_FULL(get_log_interface(st), ...., VERBOSITY_NAME(DEBUG), \
(get_log_mask(st) & mask) != 0, "") // <=
```
PVS-Studio diagnostic message: [V1003](https://www.viva64.com/en/w/v1003/) The macro 'VM\_LOG\_IMPL' is a dangerous expression. The parameter 'mask' must be surrounded by parentheses. log.h 23
The *VM\_LOG\_IMPL* macro is unsafe. Its second parameter is not enclosed in parentheses, which could potentially cause undesirable side effects if a complex expression is passed to the condition. But if *mask* is just a constant, this code will run with no problems at all. That said, nothing prevents you from passing anything else to the macro.
Conclusion
----------
TON turned out to be pretty small, so there are few bugs to find there, which the Telegram developer team should certainly be given credit for. But everyone makes mistakes every now and then, even these guys. Code analyzers are powerful tools capable of detecting dangerous spots in source code at the early development stages even in the most quality code bases, so don't neglect them. Static analysis is not meant to be run from time to time but should be part of the development process: "[Introduce Static Analysis in the Process, Don't Just Search for Bugs with It](https://habr.com/en/post/440610/)". | https://habr.com/ru/post/469915/ | null | en | null |
# Sanic — быстрее, чем кролики
Как известно, в великом множестве веб-фрейморков, существующих в экосистеме Python, очень легко заблудиться. С одной стороны, большой выбор - это хорошо, но с другой - это так же и бремя, так как приходится тратить усилия на поиски лучшего или хотя бы как можно более подходящего для конкретно ваших условий и задач, а потом и на сравнение и выбор среди найденного. Кто-то выбирает Django, кто-то FastApi, Flask, Tornado, Bottle... да мало ли их? Все мы очень любим то, что на слуху и то, к чему уже привыкли. Привычка - вторая натура. Однако, среди всего этого многообразия есть поистине недооценённые вещи, и с одной из них я хочу вас познакомить.
[**Sanic**](https://sanic.dev/en/) - это асинхронный и очень быстрый фрейморк и веб-сервер для построения веб-приложений на основе микросервисной архитектуры. Его создателем является израильский программист Адам Хопкинс, в 2018 году основавший данный проект. С тех пор Sanic постоянно и неустанно развивается. В комьюнити проекта, которое в основном обитает в [официальном канале в дискорде](https://discord.com/invite/FARQzAEMAA), существуют требования к кодстайлу, а также установлена ежеквартальная регулярность релизов, что не может не радовать. На момент написания статьи вышел очередной апдейт версии Sanic - 22.6.0. Также стоит упомянуть, что в начале текущего 2022 года издательством O'Reilly выпущена книга А.Хопкинса ["Python Web Development with Sanic"](https://sanicbook.com/).
> *...* хорошая девочка Лида.
> Да чем же она хороша?
> *© Я.Смеляков*
>
>
Sanic - это ASGI-сервис, со всеми вытекающими отсюда прелестями асинхронной разработки. Для развёртывания в продакшене прекрасно подходит всем известный Uvicorn.
Из коробки Sanic предоставляет возможность писать код как в синхронной, так и в асинхронной парадигме. Для эффективной разработки можно использовать любую версию Python, начиная с 3.7 (если нужна поддержка 3.6, то можно использовать версию 20.12LTS).
Для пользователей Mac и Linux доступны uvloop и ujson. Всё из той же коробки прекрасное и необходимое дополнение - собственный универсальный тестовый клиент для использования с pytest. Автодокументация Redoc и Swagger в форматe OpenAPI3, 4 варианта событий для listeners, middleware для стадий запроса и ответа, инъекции зависимостей, blueprints, расширяемость - что ещё нужно современному программисту?
Ах, да, бонус: простой и понятный синтаксис и полностью типизированные исходники. Ну не прелесть?
Ближе к делу: установка и первое минимальное приложение.
Стандартно делаем `pip install sanic`
```
# hello.py
from sanic import Sanic
from sanic.response import json
app = Sanic("my_first_app")
@app.route('/')
async def hello(request):
return json({'hello': 'world'})
if __name__ == '__main__':
app.run()
```
*Знакомо, не правда ли? По-моему, когда-то где-то все мы это уже видели... Но плохо ли это? По-моему, очень удобно, синтаксис фреймворка не нужно заучивать с нуля.*
К слову о том, что Sanic - это не только фрейморк, но и веб-сервер: запустить данный код из консоли очень просто: `sanic hello.app` (или же по старинке `python3 hello.py`)
Затем можно открыть браузер и перейти на `http://127.0.0.1:8000/` или вызывать из консоли `curl localhost:8000 -i` и получить
> HTTP/1.1 200 OK
> Connection: keep-alive
> Keep-Alive: 5
> Content-Length: 17
> Content-Type: application/json
>
> {"hello":"world"}
>
>
Открыв в браузере страницу `http://127.0.0.1:8000/docs` мы автоматически попадаем на страницу с документацией Redoc:
http://127.0.0.1:8000/docsSwagger же ждёт нас по адресу `http://127.0.0.1:8000/docs/swagger` :
http://127.0.0.1:8000/docs/swaggerИ это мы ещё ничего толком не сделали. А главное, всё это можно настроить как нам хочется. Прекрасно? Прекрасно!
Но конечно же это синтетический пример, который не позволяет раскрыть всю прелесть Sanic. В следующих частях шаг за шагом мы посмотрим на его возможности.
P.S. Любителям бенчмарков предлагается перепроверить эти [цифры](https://web-frameworks-benchmark.netlify.app/result?asc=0&f=django,flask,fastapi,sanic,starlette&metric=totalRequestsPerS&order_by=level64). | https://habr.com/ru/post/676556/ | null | ru | null |
# Следим и вычисляем с Vue 3, или Как использовать watchEffect
Привет! Меня зовут Алексей, я frontend-специалист SimbirSoft. В этой статье разберем новый метод слежения за реактивными свойствами watchEffect.
С появлением Vue 3 c Composition API стало доступно два метода слежения — watch и watchEffect. Если «старый» метод watch всем хорошо знаком и не должен вызывать затруднений у Vue-разработчиков, то новый метод стоит изучить подробнее. Материал будет полезен разработчикам, переходящим с Vue 2 на Vue 3 и всем «вьюшникам», которые еще не разобрались с этим методом.
Composition API предоставляет нам два разных метода слежения за реактивными свойствами — watch и watchEffect. Они похожи, но все же каждый полезен в определенных случаях. Рассмотрим, какие сходства и различия существуют у этих методов:
| | |
| --- | --- |
| **Общее** | **Отличия** |
| ● следят за изменениями зависимостей ● выполняют побочные эффекты в отдельной функции коллбэка ● предоставляют способ остановки слежения | ● watch (без immediate) может использоваться для ленивого запуска побочных эффектов (watchEffect всегда отрабатывает немедленно после монтажа компонента) ● watchEffect автоматически следит за изменениями любых состояний (может быть несколько переменных для отслеживания) ● watch обеспечивает доступ к текущим и предыдущим значениям |
Это были основные отличия, о других мы расскажем ниже.
Слежение за объектами и массивами в watchEffect
-----------------------------------------------
WatchEffect может отслеживать только адрес памяти реактивного объекта. Изменение элементов массива или свойств объекта не изменит адрес памяти и, следовательно, не вызовет срабатывания метода watchEffect:
```
add
{{ target }}
import { reactive, watchEffect } from "vue";
const target = reactive([1, 2, 3, 4]);
watchEffect(() => {
console.log(target);
});
const addTarget = () => {
target.push(5);
};
```
При нажатии на кнопку add видим, что данные в массив добавляются, но watchEffect отрабатывает только один раз. WatchEffect всегда срабатывает только один раз после монтажа компонента, в watch нам приходилось указывать для этого immediate — true:
Нам нужно преобразовать реактивный объект обратно в массив с помощью spread-оператора:
```
add
{{ target }}
import { reactive, watchEffect } from "vue";
const target = reactive([1, 2, 3, 4]);
watchEffect(() => {
const arr = [...target];
console.log(arr);
});
const addTarget = () => {
target.push(5);};
```
Теперь наш watchEffect успешно отрабатывает:
Для слежения за объектами будем использовать toRefs():
```
changeTitle
{{ data }}
import { reactive, watchEffect, toRefs } from "vue";
const data = reactive({
title: "Some title",
desc: "Some description",
});
watchEffect(() => {
const parse = toRefs(data);
console.log(parse);
});
const setTitle = () => {
data.title = "New title";
};
```
Вызов функции stop() остановит действие watchEffect:
```
changeTitle
stop
{{ data }}
import { reactive, watchEffect, toRefs } from "vue";
const data = reactive({
title: "Some title",
desc: "Some description",
});
const stopWatchEffect = watchEffect(() => {
const parse = toRefs(data);
console.log(parse);
});
const setTitle = () => {
data.title = "New title";
};
const stop = () => {
stopWatchEffect();
};
```
Параметры watchEffect
---------------------
Метод watchEffect принимает два аргумента. Первый — это коллбэк-функция. Второй — объект конфигурации:
```
watchEffect(
() => {},
{
flush: 'post',
onTrack(e) {
debugger
},
onTrigger(e) {
debugger
}
})
```
Свойство flush определяет, запускается ли метод watchEffect до, после или во время повторного рендеринга страницы:
```
flush: 'pre' | 'post' | 'sync'
```
По умолчанию созданные пользователем коллбек-функции наблюдателя вызываются до обновления компонентов Vue. Это означает, что если вы попытаетесь получить доступ к DOM внутри коллбек-функции наблюдателя, DOM будет в состоянии до того, как Vue применит какие-либо обновления.
Дополнительный объект настроек с опцией flush (значение по умолчанию — 'pre'):
```
let stop = watchEffect(callback, {
flush: 'pre'
})
```
Опция flush также может принимать значение 'sync', которое принудительно заставит эффект всегда срабатывать синхронно. Однако такое поведение неэффективно и должно использоваться только в крайних случаях:
```
watchEffect(callback, {
flush: 'sync'
})
```
Если вы хотите получить доступ к DOM в коллбек-функции наблюдателя после того, как Vue его обновил его, вам нужно указать flush: 'post':
```
watchEffect(callback, {
flush: 'post'
})
```
Отладка watchEffect
-------------------
Можно использовать опции onTrack и onTrigger для отладки поведения наблюдателя:
* onTrack вызывается, когда реактивное свойство или ссылка начинает отслеживаться как зависимость;
* onTrigger вызывается, когда коллбэк наблюдателя вызван изменением зависимости.
Оба коллбэка получают событие отладчика с информацией о зависимости, о которой идет речь. Обратите внимание, опции onTrack и onTrigger работают только в режиме разработки.
Аннулирование побочных эффектов
-------------------------------
Иногда в функции наблюдателя могут быть асинхронные побочные эффекты, которые требуют дополнительных действий при их аннулировании (то есть в случаях, когда состояние изменилось до того, как эффекты завершились). Для таких случаев функция эффекта принимает функцию onInvalidate. Она будет использоваться для аннулирования выполненного и вызываться в следующих случаях:
* когда эффект будет вскоре запущен повторно;
* когда наблюдатель остановлен (то есть когда компонент размонтирован, если watchEffect используется внутри setup() или хука жизненного цикла).
```
changeTitle
stop
{{ data }}
import { reactive, watchEffect, toRefs } from "vue";
const data = reactive({
title: "Some title",
desc: "Some description",
});
const stopWatchEffect = watchEffect((onInvalidate) => {
const parse = toRefs(data);
console.log(parse);
console.log("basic function");
onInvalidate(() => {
console.log("onInvalidate function");
});
});
const setTitle = () => {
data.title = "New title";
};
const stop = () => {
stopWatchEffect();
};
```
Снова запустим наше приложение:
Видим, что сначала отработала основная коллбек-функция, и в консоли вывелось basic function.
Если мы нажмем на кнопку stop, то сработает функция onInvalidate:
Если нажать на кнопку change title, то вначале выполнится функция onInvalidate, а затем основная функция. При изменении свойств onInvalidate будет всегда срабатывать первой:
### Практическое применение watchEffect
Мы будем отменять запросы axios, если входные данные изменились, и старые данные больше не актуальны:
```
load albums
load post
stop
{{ information }}
import { ref, watchEffect } from "vue";
import axios from "axios";
const type = ref("albums");
const information = ref(null);
const source = ref(null);
const setType = (value) => {
type.value = value;
};
const init = async function () {
source.value = axios.CancelToken.source();
try {
const data = await axios.get(
`https://jsonplaceholder.typicode.com/${type.value}`,
{
cancelToken: source.value.token,
}
);
return data;
} catch (error) {
console.log(error);
}
};
const stop = watchEffect((onInvalidate) => {
onInvalidate(() => {
source.value.cancel("Отмена запроса");
});
init(type.value).then((res) => {
information.value = res;
});
});
```
Функция setType изменит значение переменной type в зависимости от параметра, который был принят. WatchEffect следит за изменением переменной type, и при ее изменении делает запрос на получение постов или альбомов. Заметьте, мы нигде изначально не инициализируем запрос, поскольку watchEffect срабатывает один раз сразу при загрузке страницы:
Установим скорость сети в Slow 3G. И будем быстро переключаться по кнопкам load post и load alboms. Мы увидим, что запросы, которые больше не актуальны, отменяются.
### Резюме
Мы разобрались с методом наблюдения за реактивными сущностями с помощью watchEffect.
Что следует запомнить о методе watchEffect:
* он всегда срабатывает один раз после монтажа компонента;
* он может отслеживать несколько переменных;
* если вы хотите отслеживать изменения после обновления компонента, используйте опцию flush: 'post';
* функция onInvalidate всегда срабатывает перед основной функцией;
* для слежения за массивами используйте спред-оператор, а для слежения за объектами — функцию toRefs().
**Спасибо за внимание! Другие наши материалы на Habr о Vue:**
[Хочу перемен: почему пора переходить на Vue 3](https://habr.com/ru/company/simbirsoft/blog/675692/)
[Настройка ESLint для чистого кода в проектах на Vue](https://habr.com/ru/company/simbirsoft/blog/674036/)
**Подписывайся на наши соцсети! Авторские материалы для frontend-разработчиков мы также публикуем в**[**ВК**](https://vk.com/simbirsoft_team)**и**[**Telegram**](https://t.me/simbirsoft_dev)**.** | https://habr.com/ru/post/697910/ | null | ru | null |
# Пишем расширение для Chrome «загрузка аудиозаписей с Вконтакте»
В магазине расширений chrome наверняка уже есть загрузчики песен с вконтакте, но мы попробуем написать свой.
Наше расширение будет добавлять ссылку в каждую из песен раздела *Мои Аудиозаписи*, которая будет скачивать песню.
Выглядеть должно примерно так:
| Изначально: | Попробуем сделать так: |
| --- | --- |
| | |
Давайте начнем.
Вообще, писать расширения не так уж и сложно. Расширение — это всего лишь это файл-описание + html/js/css контент. Наше будет состоять из трех файлов — файла описания (manifest.json), внедряемого js скрипта (vk\_inject.js), и внедряемого файла стилей vk\_styles.css).
Главный файл в расширении — это, конечно, manifest.json. В нем содержится дескриптор расширения, и ссылки на внедряемые файлы.
mainfest.json
```
{
"manifest_version": 2,
"name": "Загрузчик музыки из vk.com",
"description": "Позволяет вам загрузить музыку из социальной сети Вконтакте.",
"version": "1.0",
"content_scripts": [
{
"matches": ["*://vk.com/audios*"],
"js": ["vk_inject.js"],
"css": ["vk_styles.css"]
}
]
}
```
Пока ничего сложного. Кроме описания, здесь содержится тег «content\_scripts», который определяет, какие js и css файлы будут внедрены в страницу.
В данном случае, наше расширение будет встраивать файлы *vk\_inject.js* и *vk\_styles.css* в каждую страницу, подходящую по адресу к маскам http://vk.com/audios\* или https://vk.com/audios\*. Это как раз те адреса, где содержатся наши (или других пользователей) аудиозаписи на сайте Вконтакте.
Файл стилей (vk\_styles.css) будет очень простой. Мы всего лишь определим css класс для внедряемой ссылки.
Обязательно нужно следить, чтобы класс не пересекался со стилями исходной страницы.
Конечно, мы можем обойтись и без внедряемого css файла, и просто задать все стили в коде при создании элемента ссылки, но я
хочу показать вам возможность внедрения стилей. Вы также можете переопределить стили для своих ссылок.
vk\_styles.css
```
.downloadLink {
float: right;
}
```
Практически все действия будут происходить во внедряемом коде vk\_inject.js.
Итак, что будем делать:
Страница vk.com/audios\* содержит два списка песен — 1) изначальные аудиозаписи на вашей странице — элемент и 2) список поиска — . В списке поиска будут отображаться найденные композиции, если вы перейдете в режим поиска. Оба эти элемента изначально присутствуют на странице аудиозаписей, так что мы можем поменять каждый из них.
Проблема в том, в каждом их этих списков могут добавляться или удаляться записи. Нам нужно следить за этим.
Внедряемый скрипт исполняется в отдельной виртуальной машине, и не может взаимодействовать со скриптом на станице. Поэтому мы не можем переопределять исходные функции или как-то иначе перехватывать js код на исходной странице.
Но, к счастью, оба эти скрипта разделяют DOM-дерево, так что мы будем следить за обновлениями DOM элементов списка с помощью MutationObserver.
vk\_insert.js
```
(function (){ // обернем все в безымянную функцию, чтобы не создавать глобальных переменных - просто хороший тон
var observer = new MutationObserver(listModified); // создаем объект observer -> вызывает listModified при каждом изменении DOM
var initialList = document.getElementById('initial_list'); // список изначальной музыки на нашей странице
if (initialList)
{
// список уже был заполнен при подключении расширения - добавляем ссылку "Скачать" для каждой записи в нем
var rows = initialList.children;
for (var i = 0; i < rows.length; i++)
{
addDownloadLink(rows[i]); // добавляем ссылку
}
observer.observe(initialList, {childList: true}); // следим за изменениями в изначальном списке тоже
}
// список аудиозаписей при поиске
var searchList = document.getElementById('search_list');
if (searchList)
{
// search_list изначально всегда пустой, нам нужно только отрабатывать добавление песен в него
observer.observe(searchList, {childList: true}); // следим за ним
}
// вызывается, когда в список песен добавляются (или удаляются) элементы
function listModified(mutations)
{
for (var i = 0; i < mutations.length; i++)
{
var mut = mutations[i];
if (mut.type != 'childList')
{
return;
}
// пройдемся по добавленным песням
for (var j = 0; j < mut.addedNodes.length; j++)
{
addDownloadLink(mut.addedNodes[j]);
}
// удаленные записи - mut.removedNodes игнорируем
}
}
// функция добавляет ссылку "Скачать" к разметке песни
function addDownloadLink(row)
{
var titleNode = row.querySelector('div.title_wrap'); // Исполнитель песни + название
if (!titleNode) // если ничего не работает (может, разметка была изменена?)- выйдем
{
return;
}
var input = row.querySelector('div.play_btn > input'); // найдем input, в котором хранится url
if (!input)
{
return;
}
var ref = input.getAttribute('value'); // сам URL файла
ref = ref.substr(0, ref.indexOf('?')); // обрежем все после '?', чтобы оставить только ссылку на mp3
var link = document.createElement('a');
link.className = 'downloadLink'; // добавим css класс 'downloadLink' для нашей ссылки
link.textContent = "Скачать";
link.setAttribute('download', titleNode.textContent + '.mp3'); // имя файла для загрузки
link.setAttribute('href', ref);
link.addEventListener('click', function(event){ // при клике на нашу ссылку, отменим запуск проигрывателя
event.stopPropagation();
});
titleNode.appendChild(link);
}
})();
```
### Устанавливаем расширение.
Итак, все три файла готовы. Вы можете скопировать их из поста или [загрузить архивом](http://4dro.ru/vk.zip).
В браузере войдите на страницу настроек, выберите вкладку *Расширения* (или просто введите «chrome://extensions» в адресную строку). Обязательно нужно включить *Режим разработчика*. Потом нажмите *Загрузить распакованное расширение...*.
Выберите папку, куда вы сохранили эти три файла. В моем случае это D:\Droopy\work\habr\plugin.
Расширение должно появиться в списке. Включите его.
Давайте проверим, как оно работает. Для этого зайдем на vk.com, и выберем раздел *Мои аудиозаписи*.
Так, ничего не работает…
Почему? Потому что Вконтакте при переходе со страницы на страницу самостоятельно обновляет html и программно изменяет url в адресной строке. Это не является классическим браузерным переходом со страницы на страницу.
Поэтому браузер и не запустил наше расширение, хотя адрес страницы и стал «https://vk.com/audios\*».
Для запуска нашего скрипта, нам нужно явно обновить страницу аудиозаписей.
Обновляем.
Ура, ссылки «Скачать» появились!
Причем, если мы начнем поиск аудиозаписей на этой же странице, то для каждой найденной песни автоматически будет добавляться ссылка на скачивание. Расширение работает.
Но есть одна сложность с названием скачиваемой песни. Когда вы нажимаете на ссылку «Скачать», в диалоге сохранения файла вам будет предлагаться имя файла из набора цифр. Нам же нужно нормальное название песни.
Дело в том, что вконтакте хранит аудиозаписи на отдельном домене, и хром для этого случая будет использовать имя файла на сервере вместо предложенного в ссылке.
В багтрекере хрома [сказано](https://code.google.com/p/chromium/issues/detail?id=366370), что в этом случае нужно выбирать пункт *Сохранить ссылку как...* в контекстном меню. Тогда нам будет предложено нормальное имя файла.
Наше расширение, конечно, не всегда работает на всех страницах вконтакте, но для скачивания любимых песен из своих аудиозаписей вполне подходит. | https://habr.com/ru/post/254005/ | null | ru | null |
# Vue + SSR + AMP — как подружить SPA с гугл страницами
Привет, хабрист!
Довольно давненько подружил свои приложения с гуглом.
Основная идея была - не создавая новых шаблонов, получить все страницы сайта AMP-friendly и, вообще, сделать ядро приложения AMP-ready.
Тут нас поджидает серьезная переработка стилей CSS и структуры приложения путем добавления дубликатов забаненных гуглом компонентов, таких как картинки, карусели, менюхи и прочее.
Я буду вещать на примере самого простого - картинок. Все прочее аналогично, хоть и посложнее на практике.
Объявим зависимости
package.json
```
{
"name": "ssr.app",
"version": "0.0.1",
"description": "google-ready app",
"productName": "AMP-friendly",
"dependencies": {
"@vue/composition-api": "^1.0.0-rc.5",
"vue": "^2.6.14",
"vue-meta": "^2.4.0",
"vuex": "^3.6.2",
"vuex-composition-helpers": "^1.0.23"
},
"devDependencies": {
"pug": "3.0.2",
"pug-plain-loader": "1.1.0",
"purgecss-webpack-plugin": "^4.1.3",
"terser-webpack-plugin": "4.2.3",
}
}
```
Теперь сделаем дефолтную функцию для сбора метаданных из компонентов. Это архи важный момент. На данном этапе будут засасываться стили, подключаться скрипты с сайта [ampproject.org](https://ampproject.org) и прочая SEO требуха ))
app.meta.js
```
export const keyTitle = 'header'
export const keyDescription = 'description'
export const keyMeta = 'meta'
export const keyCanonical = 'canonical'
export const keyAmp = 'amphtml'
export const keyImage = 'image'
export const keyItem = 'item'
export const defaultMediaTitle = 'My awesome site'
const ampBoilerplate = { vmid: 'amp_meta', 'amp-boilerplate': true, cssText:
'body{-webkit-animation:-amp-start 8s steps(1,end) 0s 1 normal both;-moz-animation:-amp-start 8s steps(1,end) 0s 1 normal both;-ms-animation:-amp-start 8s steps(1,end) 0s 1 normal both;animation:-amp-start 8s steps(1,end) 0s 1 normal both}@-webkit-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-moz-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-ms-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-o-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}'
}
const ampNoScript = { vmid: 'amp_meta', innerHTML: `
body {-webkit-animation: none;-moz-animation: none;-ms-animation: none;animation: none;}
`}
// сюда положим стили приложения, они сложены в чанки
const ampCSS = { loaded: false }
// тут берем из компонента информацию для meta
const getMeta = (key, item, route) => {
if (item && item[key]) return item[key]
return route.meta[key]
}
// тут нам придется пробежать по всем mounted компонентам
// нам нужно собрать стили для async компонентов
const getSources = (map, cmp) => {
const { $options, $children } = cmp
const { __file: file } = $options || {}
if (file) map[file] = ''
if ($children) $children.forEach((v) => getSources(map, v))
}
export function metaInfo() {
const cmp = this
const { $route: route, $store: store } = cmp
// если компонент возвращает какой-то item
// то метаданные берем из этого item
// иначе, компонент должен сам возвращать метаданные
// может быть, роут содержит в свойстве meta какие-то данные
// вообще иначе, метаданных не будет и SEO провалится (:
const item = cmp[cmp.keyItem || keyItem] || cmp
// приведу в пример только тайтл и дескрипшон страницы
const __title = getMeta(cmp.keyTitle || keyTitle, item, route)
const title = __title || defaultMediaTitle
const description = getMeta(cmp.keyDescription || keyDescription, item, route)
// с этого начинается google AMP
const ampLink = getMeta(cmp.keyAmp || keyAmp, item, route)
const out = {
title,
meta: [{ name: 'description', content: description }],
link: [],
script: [],
noscript: [],
style: [],
htmlAttrs: {
lang: 'ru',
},
// вот с этим нужно быть очень внимательными
// но без этого у нас выведется на страницу что-то такое
// <style>
__dangerouslyDisableSanitizersByTagID: { amp_meta: ['innerHTML', 'cssText'] },
}
// if (true) { // debug
if (route.params?.isAmp) { // подробнее в router.js
if (SSR) { // isServer
const { ssrContext } = store // подробнее в server.js
const { initialCSS, allCSS, chunkMap } = ssrContext
const cssSources = [...initialCSS]
if (!ampCSS.loaded) {
// засасываем CSS в кеш
ampCSS.loaded = true
const fs = require('fs')
const dir = './www/' // где лежат наши CSS-ки?
allCSS.forEach((f) => {
const contents = fs.readFileSync(dir + f, { encoding: 'utf-8' })
ampCSS[f] = contents || ''
})
}
// нужно собрать все async mounted компоненты
// получим
/*
{
'src/views/Home.vue': 'my-home-page',
'src/components/Async.vue': 'my-async-chunk'
}
*/
const sources = {}
getSources(sources, this.$root)
// добавим к initialCSS наши асинхронные чанки
Object.keys(sources).forEach((k) => (sources[k] = chunkMap[k] || sources[k]))
Object.keys(sources).forEach((k) => {
const start = 'css/' + sources[k]
const css = allCSS.find((v) => v.startsWith(start))
if (css && !cssSources.includes(css)) cssSources.push(css.replace('"', "'"))
})
// сформируем контент для тега style
// возьмем его из кеша ampCSS
const cssContents = cssSources
.map((f) => ampCSS[f])
.filter((v) => !!v)
.join('\n')
// и сформируем AMP-ready теги
out.htmlAttrs['⚡'] = true
// тут же, нужно подключить скрипты для компонентов
// amp-img, amp-iframe, amp-analytics и прочее
out.script.push({ async: true, src: 'https://cdn.ampproject.org/v0.js', crossorigin: 'anonymous' })
// __dangerouslyDisableSanitizersByTagID
out.noscript.push(ampNoScript)
out.style.push(ampBoilerplate)
out.style.push({ vmid: 'amp_meta', 'amp-custom': true, cssText: cssContents })
}
}else if (ampLink) {
// если страница имеет AMP версию, то
out.link.push({ rel: 'amphtml', href: ampLink })
}
return { ...out }
}
```
По большому счету, это все. Осталось подключить эту функцию через роутер к компонентам и сделать AMP-ready роуты
Создание роутера я упущу, продемонстрирую только сами роуты
routes-patch.js
```
const injectProps = (route, props) => {
const newProps = {}
const keys = []
if (props?.isAmp) route.params.isAmp = true
route.matched.forEach(cmp => {
if ((cmp.components.default.props || {}).isAmp) route.isAmp = true
Object.keys(cmp.components.default.props || {}).forEach(k => {
if (!keys.includes(k)) keys.push(k)
})
})
keys.forEach(k => {
if (notNull(props[k])) newProps[k] = props[k]
})
return newProps
}
export const parseParams = (route, add) =>
injectProps(route, {
...route?.params,
...route?.query,
...(isObject(add) ? add : {}),
})
function injectMeta(route) {
// тут подключаем menaInfo ко всем эндпоинтам, кроме узлов
if (route.children?.length) route.children.forEach(r => injectMeta(r))
else {
// эндпоинт может быть как синхронным, так и асинхронным компонентом
const oldComponent = route.component
if (isFn(oldComponent)) {
route.component = () =>
// подменим асинхронный вызов
// мы же обернули асинронный импорт в функцию
// ни кто не запретит нам сделать это еще раз
new Promise((resolve, reject) => {
oldComponent()
.then(cmp => {
// если мы объявили в компоненте metaInfo
// то не будем его затирать
// тан надо работать ручками
if (cmp.default && !cmp.default.metaInfo) cmp.default.metaInfo = metaInfo
resolve(cmp)
})
.catch(reject)
})
} else if (oldComponent && !oldComponent.metaInfo) oldComponent.metaInfo = metaInfo
}
}
```
Ну, и, наконец, сами роуты
routes.js
```
import layoutMain from 'src/layouts/MainLayout.vue'
/*
вот зачем это
webpackChunkName: "home-page"
js/home-page[.hash]?.js
css/home-page[.other hash]?.css
*/
const HomePage = () => import(/* webpackChunkName: "home-page" */ 'src/views/Home.vue')
const err404 = () => import(/* webpackChunkName: "404" */ 'src/views/404.vue')
const route1 = {
path: '',
component: HomePage,
// отсюда можно задать дефолтные значения чего-нибудь
// или передать статичные флаги
// route{:param1}/{:param2}?param3=value
// будут доступны через
// $route.params.param[1,2,3]
// или
// $route.query.param3 - это дефолтное поведение
// или через
/*
src/views/Home.vue
export default {
props:{param1:String,param2:String,param3:String, meta:Object}
}
*/
props: (route) => parseParams(route, { meta:{title:'My home page'} /* some static props */ }),
}
const route404 = {
path: '*',
component: err404,
props: (route) => parseParams(route, { meta:{title:'Oooops...'} /* some static props */ }),
}
const children = [route1,route404]
const routes = [
{
path: '/amp',
component: layoutMain,
// { isAmp: true }
// достаточно только в корне поставить этот флаг
props: (route) => parseParams(route, { isAmp: true }),
children,
},
{
path: '/',
component: layoutMain,
children,
},
]
// подключаем дефолтную функцию ко всем эндпоинтам
routes.forEach(r => injectMeta(r))
export default routes
```
Конфигурим сервер, парсим бандлы, вытаскиваем из них сорцмапы
**Важно! Серверный бандл обязательно должен содержать сорцмап**
server.js
```
const path = require('path')
const fs = require('fs')
const { createBundleRenderer } = require('vue-server-renderer')
const bundle = require(path.resolve('./server-bundle.json'))
const clientManifest = require(path.resolve('./client-manifest.json'))
const chunkMap = {}
const { maps } = bundle
Object.keys(maps).forEach(k => {
const chunkName = (k.match(/^js\/(.*)\.js$/) || [])[1]
if (chunkName) {
const chunk = chunkName.split('.')
/*
js/home-page[.hash]?.js
css/home-page[.other hash]?.css
*/
if(chunk.length > 1) chunk.pop() // удалим hash из чанка
const sources = (maps[k].sources || [])
.map(v => (v.match(/^webpack:\/\/\/\.\/(.*.vue)$/) || [])[1])
.filter(v => !!v)
sources.forEach(v => (chunkMap[v] = chunk.join('.')))
}
})
const initialCSS = clientManifest.initial.filter(v => v.match(/\.css$/))
const allCSS = clientManifest.all.filter(v => v.match(/\.css$/))
console.log(initialCSS)
/*
[ 'css/app.3ff19892.css' ]
*/
console.log(allCSS)
/*
[
'css/404.0e584305.css',
'css/app.3ff19892.css',
'css/home-page.5cc9953c.css',
]
*/
console.log(chunkMap)
/*
вот что будет если не убрать хеш
home-page.5393f5e1.js
home-page.5cc9953c.css
{
'src/components/404.vue': '404',
'src/views/HomePageModel.vue': 'home-page',
'src/views/Home.vue': 'home-page',
}
*/
const renderer = createBundleRenderer(bundle, {
template: fs.readFileSync(path.resolve('template.html'), 'utf-8'),
clientManifest,
})
const express = require('express')
const app = express()
app.get('*', (req, res) => {
renderer
// внутри нашего приложения нужно положить это в
// const store = new Vuex.Store()
// store.initialCSS = context.initialCSS
.renderToString({ initialCSS, allCSS, chunkMap }, (err, html) =>
{
res.send(html)
}
})
```
Ну, и AMP компоненты теперь рендерить очень удобно.
Мы объявляем в приложении компонент app-img
Везде его используем
app-img.vue
```
component(:is="is" v-bind="{$attrs}")
```
```
export default {
setup(){
const vm = getCurrentInstance().proxy
const is = computed(() => vm.$route.isAmp ? 'img', 'amp-img')
return {is}
}
}
```
Вуаля! Не так много кода и столько функционала :)
Буду признателен за конструктивную критику.
UPD
чуть не забыл про важную часть.
у нас же размер CSSa ограничен.
сожмем
```
chain.plugin('purgecss-webpack-plugin').use(
new PurgecssPlugin({
paths: glob.sync(`${PATHS.src}/**/*`, { nodir: true }),
content: [
'./src/**/*.html',
'./src/**/*.vue',
'./src/**/*.jsx',
],
defaultExtractor: (content) => {
const broadMatches = content.match(/[^<>"'`\s]*[^<>"'`\s:]/g) || []
const innerMatches = content.match(/[^<>"'`\s.()]*[^<>"'`\s.():]/g) || []
return broadMatches.concat(innerMatches)
},
})
)
``` | https://habr.com/ru/post/599301/ | null | ru | null |
# Добавляем favicons для bookmarklets
Так как плагин [Favicon Picker 2](https://addons.mozilla.org/en-US/firefox/addon/3176) не поддерживает FireFox 3, а смотреть на пустые иконки букмарклетов стало грустно, я предпринял попытку исправить эту ситуацию.
Для работы нам понадобится расширение [Stylish](https://addons.mozilla.org/en-US/firefox/addon/2108).
После установки необходимо нажать на иконку Stylish и выбрать Создать стиль -> Пустой стиль...
В появившемся окне вводим
`@namespace url(http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul);`
Дальше собственно настраиваем стиль для каждого букмарклета
`toolbarbutton.bookmark-item[label^="Сюда вставляем название вашего букмарклета в точности как записано в имени"] {
list-style-image: url("Сюда прописываем полный путь к желаемой favicon") !important;
}`
Вот пример для букмаклета [BugMeNot](http://lifehacker.com/software/productivity/bugmenot-bypass-web-site-registration-031809.php)
`toolbarbutton.bookmark-item[label^="[BugMeNot]"] {
list-style-image: url("http://www.bugmenot.com/favicon.gif") !important;
}`
Надеюсь что эта инструкция вам пригодится. | https://habr.com/ru/post/27872/ | null | ru | null |
# Разбор WKB формата без сторонних библиотек
В процессе разботы над одной задачей в проекте [Карты Mail.Ru](http://maps.mail.ru) возникла необходимость чтения формата [WKB](http://en.wikipedia.org/wiki/Well-known_text). Конечно, можно было воспользоваться [GDAL](http://en.wikipedia.org/wiki/GDAL), но нужно было только чтение, а все остальные возможности были излишни. Так и родился этот небольшой велосипед.
Хочу сразу предупредить, что функциональность реализована только в необходимых рамках и поддерживаются только базовые типы, такие как:* точка
* линия
* полигон
* мультилиния
* мультиполигон
Не поддерживается перекодировка порядка следования байт в слове. А так — бери и пользуйся.
Для удобства также пригодится класс-враппер представляющий область памяти как STL-like контейнер; тут даже комментировать ничего не надо. Его можно забрать [отсюда](https://github.com/darkserj/container). И дополнительные простейшие классы для геометрических примитивов: точки и прямоугольника.
**Код классов**
```
namespace ml {
struct point_d {
double x;
double y;
};
inline std::ostream & operator << (std::ostream &s, point_d const &p) {
return s << p.x << ", " << p.y;
}
inline double distance(point_d const &p1, point_d const &p2) {
double dx = (p1.x-p2.x);
double dy = (p1.y-p2.y);
return sqrt(dx*dx+dy*dy);
}
struct rect_d {
point_d min;
point_d max;
static rect_d void_rect() {
return rect_d(std::numeric_limits::max(),std::numeric\_limits::max(),
-std::numeric\_limits::max(),-std::numeric\_limits::max());
}
bool empty() const {
return (\*this == rect\_d::void\_rect() || (width()==0 && height()==0));
}
inline double height() const {
return fabs(max.y-min.y);
}
inline double width() const {
return fabs(max.x-min.x);
}
rect\_d & extend(const rect\_d &r) {
if(r.empty())
return \*this;
min.x = std::min(min.x,std::min(r.min.x,r.max.x));
min.y = std::min(min.y,std::min(r.min.y,r.max.y));
max.x = std::max(max.x,std::max(r.min.x,r.max.x));
max.y = std::max(max.y,std::max(r.min.y,r.max.y));
return \*this;
}
template< typename C >
rect\_d & bounds( C begin, C end) {
for(; begin != end; ++begin) {
min.x = std::min(min.x,begin->x);
min.y = std::min(min.y,begin->y);
max.x = std::max(max.x,begin->x);
max.y = std::max(max.y,begin->y);
}
return \*this;
}
};
inline std::ostream & operator << (std::ostream &s,const rect\_d &r) {
return s << '[' << r.min << ',' << r.max << ']';
}
} // namespace ml
```
Для использования класса необходимо предварительно загрузить данные в формате WKB в память. Как это будет сделано, пусть останется на усмотрение того, кто будет это использовать.
Использовать написанный класс предполагалось примерно следующим образом:
```
char *data = ....
ml::wkb shape(data);
std::cout << ml::wkb::type_to_text(shape.type()) << std::endl;
std::cout << shape.bounds() << std::endl;
```
Первая версия получилась решением в лоб, и выглядела так:
**Первая версия**
```
namespace ml {
class wkb {
char const * m_data;
public:
enum type_e{
wkb_point = 1,
wkb_line_string = 2,
wkb_polygon = 3,
wkb_multi_point = 4,
wkb_multi_line_string = 5,
wkb_multi_polygon = 6,
wkb_geometry_collection = 7
};
static char const *type_to_text(type_e type) {
switch (type) {
case wkb_point: return "wkb_point";
case wkb_line_string: return "wkb_line_string";
case wkb_polygon: return "wkb_polygon";
case wkb_multi_point: return "wkb_multi_point";
case wkb_multi_line_string: return "wkb_multi_line_string";
case wkb_multi_polygon: return "wkb_multi_polygon";
case wkb_geometry_collection: return "wkb_geometry_collection";
default: return "unknown";
}
}
typedef container line;
wkb(char const \*data) : m\_data(data) {}
wkb & operator = (wkb const &d) { m\_data = d.m\_data; return \*this; }
inline char byte\_order() const { return m\_data[0]; }
inline type\_e type() const { return (type\_e)\*(int\*)&m\_data[1]; }
inline int size() const { return \*(int\*)&m\_data[5]; }
line linestring() const {
return line((line::value\_type\*)&m\_data[9], size());
}
ml::point\_d const & point() const {
return \*(ml::point\_d\*)&m\_data[5];
}
wkb linestring(size\_t index) const {
size\_t offset = 9;
for(size\_t i=0; isize(); ++i) {
wkb o(&m\_data[offset]);
if(i == index)
return o;
for(size\_t j=0; j
```
В принципе, все работало и давало верные результаты, но (куда же без этого «но») когда пришлось обрабатывать несколько миллионов объектов, время, затраченное на обработку, нас не устроило.
По результатам профилирования стало понятно, почему очень много времени тратилось на вычисление нужной части WKB. Создавалось много промежуточных объектов на стеке и была в наличии пусть небольшая, но рекурсия. Почесав в затылке, мы решили несколько облагородить код и избавиться от ненужной рекурсии, да и вообще от лишних действий. Для начала мы добавили код вычисления окончания текущего элемента и получения начала следующего элемента:
```
inline const char * end_of_ring(const char *ptr) const {
return ptr + 4 + (*(unsigned int *)(ptr) * 16);
}
inline const char * end_of_polygon(const char *ptr) const {
for (size_t sz = *(unsigned int*)((ptr+=9)-4);sz--;)
ptr += (*(unsigned int *)(ptr) * 16) + 4;
return ptr;
}
```
После этого были переписаны методы получения элементов, они стали проще и очевиднее: **Скрытый текст**
```
line linestring() const {
return line((line::value_type*)(m_data+9), size());
}
ml::point_d const & point() const {
return *(ml::point_d*)(m_data+5);
}
wkb linestring(size_t index) const {
assert(index>=0 && index=0 && index=0 && index
```
Уже это увеличило производительность. Но учитывая специфику обработки точек, можно было еще улучшить архитектуру и удобство, добавив следующий метод: **Скрытый текст**
```
template< typename T >
T & apply( T & func) const {
switch (type()) {
case wkb_polygon: {
const char * ptr = m_data+9;
for(size_t i=0; i
```
мы дописали функтор для вычисления описывающего прямоугольника примерно следующим образом:
```
struct bounds_counter {
ml::rect_d r;
bounds_counter() : r(ml::rect_d::void_rect()) {}
void operator()(ml::point_d const *begin, ml::point_d const *end) {
r.bounds(begin,end);
}
ml::rect_d const & bounds() const {
return r;
}
};
```
метод bounds после переписывания стал выглядеть так:
```
ml::rect_d ml::wkb::bounds() const {
struct bounds_counter {
ml::rect_d r;
bounds_counter() : r(ml::rect_d::void_rect()) {}
void operator()(ml::point_d const *begin, ml::point_d const *end) {
r.bounds(begin,end);
}
ml::rect_d const & bounds() const {
return r;
}
};
bounds_counter b;
return apply(b).bounds();
}
```
Этот вариант не будет работать для g++, он более жестко следует стандартам:
> 14.3.1/2: A local type, a type with no linkage, an unnamed type or a type compounded from any of these types shall not be used as a template-argument for a template type-parameter.
>
>
но вполне работоспособен в clang и, судя по поиску в интернете, в MSVC++ (честно признаюсь, мы не проверяли). *Для универсальности и корректности, определение функтора надо разместить в неименованном пространстве имен.*
После всех доработок время выполнения задачи уменьшилось примерно в четыре раза. Также при использовании этого подхода было удобно написать вывод объектов в формате JSON:**Скрытый текст**
```
std::string ml::wkb::to_geo_json() const {
struct point_formatter {
std::stringstream &ss
unsigned int counter;
bool parts;
point_formatter(std::stringstream &s) : ss(s),counter(0), parts(false) {}
void operator() (ml::point_d const *begin, ml::point_d const *end) {
if (parts) ss << (counter ? ",[" : "[");
ss << "[" << begin->x << "," << begin->y << "]";
for(++begin;begin != end;++begin){
ss << ",[" << begin->x << "," << begin->y << "]";
}
if (parts) ss << "]";
++counter;
}
point_formatter & make_parts(bool p) {parts = p; counter = 0; return *this;}
};
std::stringstream ss;
point_formatter fmt(ss);
ss << std::fixed << std::showpoint << std::setprecision(6);
ss << "{";
switch(type()) {
case wkb_point: {
ss << "\"type\":\"Point\",\"coordinates\":";
apply(fmt);
} break;
case wkb_line_string: {
ss << "\"type\":\"LineString\",\"coordinates\": [";
apply(fmt);
ss << "]";
} break;
case wkb_multi_line_string: {
ss << "\"type\":\"MultiLineString\",\"coordinates\": [";
apply(fmt.make_parts(true));
ss << "]";
} break;
case wkb_polygon: {
ss << "\"type\":\"Polygon\",\"coordinates\": [";
apply(fmt.make_parts(true));
ss << "]";
} break;
case wkb_multi_polygon: {
ss << "\"type\":\"MultiPolygon\",\"coordinates\": [";
for(size_t i=0; i < size(); ++i) {
ss << (i ? ",[" : "[");
polygon(i).apply(fmt.make_parts(true));
ss << "]";
}
ss << "]";
} break;
default: break;
}
ss << "}";
return ss.str();
}
```
В итоге получился достаточно удобный класс для работы с данными, представленными в формате WKB. Стало удобно добавлять новые операции над объектами. Достигнута приличная производительность.
Весь код, приведенный в статье, можно взять [здесь](https://github.com/darkserj/wkb_wrapper) и [здесь](https://github.com/darkserj/container).
*Ершов Сергей,
программист проекта [Карты@Mail.Ru](http://maps.mail.ru)* | https://habr.com/ru/post/167517/ | null | ru | null |
# Детектирование аппаратных Троянских угроз с помощью алгоритмов машинного обучения
Интро
-----
Все мы в какой-то степени подвержены Троянской угрозе сегодня. Любой девайс, который был куплен в ближайшем магазине под домом, может служить не только Вам, как потребителю, но и злоумышленнику в его целях. Потому угроза и названа Троянской: в древнегреческой мифологии есть случай захвата целой крепости с помощью подарка, который только на первый взгляд таким кажется. Что уж говорить о захвате данных современных пользователей: паролей, реквизитов, личных сообщений.
Есть два основных вида Троянца: software(программный) и hardware(аппаратный). Software trojan представляет собой тип вредоносных программ, маскирующихся под легальное ПО. Как правило, это эмуляция бесплатного ПО либо вложение в электронном письме, и установка этой программы даёт возможность выполнить её скрытые истинные задачи: полный контроль над ПК, личными данными, транзакциями и т.п. Примерно такие же цели преследует и hardware trojan, представляя собой злоумышленное изменение электросхем в устройствах (чаще всего с целью кражи данных, паролей). Допустим, вы покупаете клавиатуру в непроверенном магазине, и это устройство внутри содержит встроенную антенну (любой радиопередатчик), которая способна передавать вводимые символы злоумышленнику по радиосвязи. Вообще, такая проблема часто возникает, когда компания проектирует интегральную схему (здесь и далее - ИС), но для производства таких схем вынуждена обращаться к другой ненадёжной компании. Звучит совсем не безопасно, правда?
Сегодня существует множество способов защиты от программной Троянской угрозы и, что самое главное, они постоянно обновляются, так как и вредоносное ПО, и аппаратура "не спят", улучшаясь со временем. Самые простые рекомендации для пользователя - регулярно обновлять ПО, использовать "антивирус" и банально не проходить по непроверенным ссылкам на почте и в Интернете. Однако что делать с hardware угрозами? Оказывается, в последнее время приобретает всё большую популярность анализ угроз с помощью машинного обучения. Об этом я и хотел сегодня рассказать.
---
Основные исследования
---------------------
Исследователи из университета Мейджо, Япония, предлагают анализировать сигналы электропотребления при работе Троянца и без него. Данные для решения такой задачи классификации предобрабатываются для более точного анализа. А именно, сигнал с помощью дискретного преобразования Фурье (ДПФ) переводится в частотную область, в которой можно обнаружить характерные частоты работы Троянца.
Рис.1. Исследуемый сигнал электропотребленияРис.2. Частотная область сигналаДалее, на размеченных данных (где х - частоты сигнала, а у - +-1(с или без Троянской угрозы)) обучается классификатор с помощью метода опорных векторов (SVM), что позволяет с неплохой точностью анализировать энергопотребление с целью выявить угрозу и вовремя сообщить об этом пользователю. Стоит отметить, что эксперименты проводились на FPGA - довольно популярной программируемой логической интегральной схеме.
Другой подход, более комплексный, был представлен в "Journal of Hardware and Systems Security" в декабре 2018 года исследователями университета Флорида. Дело в том, что существующие на тот момент подходы работали долго, с недостаточной точностью и только лишь против небольшой части Троянских угроз. И основная идея этой инновации следующая: микросхемы фотографируются с помощью растрового электронного микроскопа (РЭМ) и далее с помощью алгоритмов компьютерного зрения можно обнаружить даже едва заметные изменения в цепи (как правило, анализируются транзисторы). Такие изменения и свидетельствуют о наличии встроенной Троянской угрозы.
Говоря детальнее, производится анализ двух фотографий: первая - эталонная деталь ИС, а вторая - деталь под подозрением, которую мы и хотим проверить на наличие Троянца. При этом нам известны основные структурные особенности Троянских угроз и, соответственно, исходя из различия фотографий можно идентифицировать место и тип угрозы. Такой подход очевидно намного менее энерго- и ресурсозатратен в отличие от полной разборки ИС и ручного анализа на поиск угрозы.
Теперь совсем подробно Аппаратные Троянские угрозы классифицируются на основе:
* своих физических характеристик(определённые геометрические формы внутри ИС); это может быть как добавление\удаление новых транзисторов в схему, так и модификация уже существующих связей, шин и т.п.; банальным примером тут может быть изменение логического элемента с NAND на NOR в интересах злоумышленника;
* активации; некоторые Троянцы непрерывно крадут ваши данные, а другие активируются только при определённом внешнем\внутреннем воздействии.
Алгоритм поиска угрозы таков:
* подготовка образца;
* быстрое фото с помощью микроскопа;
* обнаружение различий между эталонным образцом без Троянца и аналогичным рассматриваемым образцом.
На самом деле, сделать нужную для обучения фотографию своего рода искусство. При подаче на рассматриваемую деталь набора напряжений различные элементы проявляют себя более активно. Алгоритм автоматический и способен использовать нужные ему фотографии. Также фотографии можно делать с разного расстояния, менять время съёмки (dwelling time) и разрешение (от этого зависит качество съёмки и, соотв., результат; здесь рождается знакомый для machine learning компромисс между временем работы алгоритма и качеством обнаружения угроз).
Рис.3. Зависимость качества изображения от внешнего напряжения, зума, времени съёмки и разрешенияДалее всё просто: по выбранной метрике "похожести" анализируются аналогичные участки эталона и проверяемой микросхемы. Все несостыковки проверяются дополнительно на выявление одного из известных типов Троянских угроз.
Рис.4. Этапы выявления несостыковок на исследуемой ИС в сравнении с оригиналом На сегодня уже существует и более продвинутый подход к поиску Троянца с помощью машинного обучения без эталона. Сперва данные, как и ранее, предобрабатываются для фото.
Рис.5. Подготовка ИС из SIM-карты телефона для поиска Троянских угрозДалее делается фото плюс несколько фильтров, которые дают чёткое чёрно-белое изображение. Исследуемые участки цепи вырезаются в отдельные снимки и подаются на вход предсказателя, который относит элемент к оригинальным либо же подозрительным. Предсказатель в данном случае - всё тот же SVM с ядром RBF (для выявления нелинейных зависимостей данных). Он тренируется на наборе размеченных сэмплов, которые получаются, если вкратце, с помощью дискретного преобразования Фурье над элементами ИС.
Пояснение по RBF по ДПФRBF(radial basis function) - функция преобразования исходного пространства признаков в новое нелинейным образом. Суть в том, что построенная методом SVM линейная граница в новом пространстве будет нелинейной в исходном. Это даёт возможность строить классификаторы хорошей точности с выявлением нелинейностей. Пайплайн для обучения такого классификатора выглядит следубщим образом:
```
rbf_kernel_svm_clf = Pipeline([
("scaler", StandardScaler()),
("svm_clf", SVC(kernel="rbf", gamma=5, C=0.001))
])
rbf_kernel_svm_clf.fit(X, y)
```
Что касается ДПФ, деталь ИС имеет чёткие контуры, которые видны на чёрно-белом фоне. Есть специальный метод описания контуров объектов с помощью Фурье-дескрипторов. Там и требуется ДПФ,
Рис.6. Общая схема работы алгоритма по обнаружению подозрительных деталей ИСТакой подход позволяет распознать контур логического элемента в схеме и, соответственно, более точно определить, является ли этот элемент здоровым и оригинальным. И в случае вредоносной аппаратуры выявить её и указать дальнейшие действия по избавлению от угрозы.
Рис.7. Результат работы алгоритма с указанием необходимых действий для уничтожения Троянца
---
Выводы
------
В современном мире потребность в различных микросхемах по-прежнему увеличивается, параллельно со спросом растёт и предложение таких товаров. А значит, всё чаще можно приобрести оборудование от злоумышленников, даже не подозревая об этом. Борьба с аппаратными (их можно называть троянскими исходя из известной аналогии в древнегреческой мифологии) угрозами сегодня актуальна для защиты конфиденциальной информации пользователя и его собственности в целом. Что более интересно, защита от такой угрозы уже сейчас может проводиться автоматически с помощью искусственного интеллекта, а не вручную. Такой подход сокращает время обнаружения Троянца с недель и месяцев до часов примерно с такими же показателями точности. Будущее уже наступило!
---
Литература
----------
1. Takato Iwase, Yusuke Nozaki, Masaya Yoshikawa, "Detection Technique for Hardware Trojans Using Machine Learning in Frequency Domain", 2015 IEEE 4th Global Conference on Consumer Electronics (GCCE)
2. N. Vashistha, M. Tanjidur Rahman, H. Shen, D. L. Woodard, N. Asadizanjani, and M. Tehranipoor, “Detecting Hardware Trojans Inserted by Untrusted Foundry using Physical Inspection and Advanced Image Processing,” Springer journal of Hardware and Systems Security, special issue on Hardware Reverse engineering and Obfuscation 2018.
3. Nidish Vashistha, Hangwei Lu, Qihang Shi, M Tanjidur Rahman, Haoting Shen, Damon L Woodard, Navid Asadizanjani and Mark Tehranipoor, "Trojan Scanner: Detecting Hardware Trojans with Rapid SEM Imaging combined with Image Processing and Machine Learning".
4. M. Tehranipoor and F. Koushanfar, “A Survey of Hardware Trojan Taxonomy and Detection,” IEEE Des. Test Comput., vol. 27, no. 1, pp. 10–25, Jan. 2010.
5. Joseph Clements and Yingjie Lao, "Hardware Trojan Attacks on Neural Networks", Department of Electrical and Computer Engineering Clemson University, Clemson, SC 29634.
6. Yuntao Liu, Yang Xie, and Ankur Srivastava, "Neural Trojans", 2017 IEEE 35th International Conference on Computer Design.
7. X. Zhang and M. Tehranipoor, “Case study: Detecting hardware Trojans in third-party digital IP cores,” in 2011 IEEE International Symposium on Hardware- Oriented Security and Trust, 2011, pp. 67–70.
8. K. Xiao, D. Forte, Y. Jin, R. Karri, S. Bhunia, and M. Tehranipoor, “Hardware Trojans: Lessons Learned after One Decade of Research,” ACM Trans. Des. Autom. Electron. Syst., vol. 22, no. 1, pp. 1–23, May 2016.
9. F. Wolff, C. Papachristou, S. Bhunia, and R. S. Chakraborty, “Towards Trojan-free trusted ICs: Problem analysis and detection scheme,” in Proceedings of the conference on Design, automation and test in Europe, 2008, pp. 1362–1365. | https://habr.com/ru/post/533652/ | null | ru | null |
# Hello World! как ему следует быть на C в Linux
Очень многие начинающие программисты думают, что знают, как написать Hello World. Естественно, с этого примера ведь и начинается большинство учебников.
А давайте посмотрим, как это делается.
Обычно в учебнике по C эта программа выглядит примерно так:
`#include
void main()
{
printf("Hello world\n");
}`
Первое, что мы здесь видим, это то, что запускающий эту программу никогда не узнает, как она выполнилась. Значит надо добавить код возврата. Функция printf, как мы знаем, возвращает количество напечатанных символов. Или, если была ошибка, отрицательное значение. Учитывая это, программа будет выглядеть примерно так:
`#include
#include
int main()
{
const char \* msg = "Hello world!\n";
int printf_res = printf(msg);
if (printf_res < strlen(msg))
{
return 1;
} else {
return 0;
}
}`
Да простят меня уважаемые читатели, но дальше я буду добавлять к этому сразу много исправлений, иначе этот пост разрастется так, что никто не дочитает до конца. Кто хочет, может исправлять свой код каждый раз, когда заканчивается очередной абзац. И это будет правильно. Это лучший способ понять, что я хочу сказать этим постом.
Теперь давайте подумаем чуть дальше.
Разве это действительно критичная ошибка, что нам не удалось сразу все сообщение напечатать? Конечно нет! Ведь не всегда то, что мы запускаем, пишет строчки в консоль. И ведь разница есть. Мы ведь сейчас пишем под Linux (вы об этом не забыли?), а он ведь очень разный бывает. И вывод может отправляться, например, в какое-нибудь странное устройство, которое просто не умеет записывать больше одного символа за раз. Так что одного printf нам будет мало; нужно писать, пока не получится.
А теперь, что если у нас не «Hello World!\n»? А если там строчка вроде «Use %s to print string»? Нельзя нам здесь пользоваться printf, если мы хотим, чтобы этот код можно было еще где-нибудь использовать. А мы ведь этого хотим, иначе какие же мы программисты.
И кстати, что для printf () значит ошибка? Да что угодно, мы ничего об этом не знаем, пока не залезем в код библиотек.
Так что видимо придется нам использовать что-то ниже уровнем. А что у нас тогда есть? puts ()? Тем более ничего не знаем об ошибках. Видимо надо использовать write ().
Итак, что у нас получается на данный момент? Мы используем write (). Если в вывод записалось не все, мы продолжаем с того места, где остановились. Мы обрабатываем ошибки.
Кстати, а что там на тему ошибок? Вы ведь уже посмотрели man 2 write? Не посмотрели? А зря. Ведь если функция write () вернула отрицательное значение, это еще не обязательно значит, что нам не повезло. Давайте посмотрим в man. И ведь если внимательно посмотрим, то мы там увидим, что отрицательное значение нам могут вернуть, если вызов был прерван сигналом. (Вы не знаете, что такое сигналы? Узнайте срочно, если хотите писать под Linux). А ведь это не обязательно ошибка. А вдруг пользователь как раз в этот момент изменил какой-нибудь конфигурационный файл и послал всем процессам SIGHUP, который обычно значит «пересмотри конфиги»?
И вот в этот момент я — surprise surprise — покажу код того, что у нас должно было получиться к этому моменту.
`#include
#include
#include
int main()
{
const char \* const msg = "Hello World!\n";
const char \* begin = msg;
const char \* const end = begin + strlen(msg);
while (begin < end)
{
size\_t remaining = end - begin;
ssize\_t res = write(STDOUT\_FILENO, begin, remaining);
if (res >= 0)
{
begin += res;
continue; // Let's send the remaining part of this message
}
if (EINTR == errno)
{
continue; // It's just a signal, try again
}
return 1; // It's a real error
}
return 0; // OK! Let's celebrate and drink some beer!
}`
Вот так по-моему должен выглядеть правильный hello world. Возможно я где-то что-то забыл обработать. В таком случае лучше не минусуйте сразу, а поправьте в комментах.
Если Эта статья хабражителям понравится, будут еще статьи на тему «чем учебники отличаются от реальной жизни».
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_
###### Текст подготовлен в [Хабра Редакторе](http://www.softcoder.ru/habraeditor/) от © SoftCoder.ru | https://habr.com/ru/post/75971/ | null | ru | null |
# Гибкая система логирования на Go
Данная статья это адское изобретение нового велосипеда. Так что на продакшене использовать только на свой страх и риск. Я долго искал систему для ведения логов на Go которая удовлетворила бы мои запросы (гибкая, возможность уведомления на емейл, очень быстрая и хранение логов в мускуле).
Скажу честно искал я дня три так не чего и не нашел. Потом я начал писать свой велосипед (первая его версия была очень кривая и еле еле работала). Потом я удалил весь тот код и начал ~~думать~~ писать заново.
Я сразу понял что писать в бд каждый раз очень утомительно. По этому я сделал так:
Библиотека для каждого типа логов делает ключ в редисе куда пишет данные в таком формате:
**Данные в редисе**`('Debug','2015-11-05 20:12:37.700052989 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.700506704 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.700663127 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.700803651 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.700987999 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.701128513 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.701293643 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.701433496 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.701602372 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.701745287 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.701925988 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.702093499 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.702276867 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.702431455 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.702581625 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.702738953 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.702899007 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.703055622 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.703210768 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.70340691 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.703566623 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.7037252 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.703954549 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.704119435 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.704281902 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.704536707 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.704721061 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.704901908 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.705106033 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.705284342 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.705465074 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.705633484 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.705802108 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.705962381 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.706129288 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.706314702 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.706463092 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.706674268 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.706848586 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.707050005 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.707221136 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.707379335 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.707583978 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.707742422 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.707967253 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.708164671 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.708410554 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.708578324 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.708775197 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.708955609 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.709184168 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.709349784 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.709510939 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.709726286 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.709940253 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.710141611 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.71034329 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.710537637 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.710763157 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.710969449 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.711167704 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.711355522 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.711550562 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.711756 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.712048767 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.712273974 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.712517739 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.712828333 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.71306392 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.713335398 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.713570618 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.71389819 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.714182802 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.714448273 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.714754937 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.715018147 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.715291228 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.715596998 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.715910118 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.7162719 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.716552975 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.716807074 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.717153412 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.717434854 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.717704591 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.717991896 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.718283451 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.718590239 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.718849058 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.719152303 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.719424972 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.719734567 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.720070491 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.720386241 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.720651655 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.72094698 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.721207595 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.721514296 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.721776408 +0200 EET','Testing'),('Debug','2015-11-05 20:12:37.722090163 +0200 EET','Testing'),`
Я сразу захотел их встроить в sql запрос но наткнулся на ошибку sql синтаксиса. Я долго ~~бился голов об клавиатуру~~ искал багу в коде, а оказалось что из — за способа добавления данных в редис в конце строки всегда будет кома. Когда я её заметил я ~~долго гуглил~~ спросил на тостере как же убрать эту кому. Оказалось проще некуда:
```
strings.TrimRight(data, ",")
```
Потом я начал пытаться из библиотеки запустить функцию в отдельном потоке. Со временем я понял ~~что я осёл~~ что это я сделать не могу и поэтому вынес её в демон.
На выходе я имею:
`Библиотека -> пишет данные в редис. Вся нагрузка на редис`
`Демон -> одним запросом все логи с редиса перемещаю в mysql`
На слабом впс (частота 1.6; 1ядро, 2 гб озу) 1 000 000 записей в мускуль добавилось за 25мл.сек (бд без тюнинга) правда в редис эти данные писались около 6 минут. Вся нагрузка на на редисе.
Вот вроде и всё.
**Конфиг**`{
"MailConf" : [
"логин на smtp сервере",
"пароль",
"smtp сервер",
"порт smtp сервера"
],
"MailTo" : [
"на_какие_емейлы_отправлять@gmail.com",
"v.grabko99@yandex.ru"
],
"Types" : [
"Debug",
"Info",
"Warn",
"Error",
"Fatal"
],
"EmailSend" : [
"Error",
"Fatal"
],
"Redis" : [
"localhost:6379",
"parsh888",
"log_"
],
"MysqlConnect" : [
"юзер",
"пароль",
"база данных"
],
"MysqlTable" : "log",
"ReplicationTimeSecond" : 320
}`
**Библиотека**
```
package GeneralsLog
import (
"encoding/json"
"gopkg.in/redis.v3"
"io/ioutil"
"log"
"microService/libs/mail"
"time"
)
type Config struct {
MailTo, MailConf, Types, EmailSend, Redis, MysqlConnect []string
MysqlTable string
}
var (
R *redis.Client
MailConf map[string]string
MailTo []string
Types []string
EmailSend []string
RedisConfig []string
//Путь к файлу с конфигами
config_file string = "/home/v-smerti/localhost/api/src/microService/config/log.json"
)
func init() {
//Спарсим конфиг
bs, err := ioutil.ReadFile(config_file)
if err != nil {
log.Panicln(err)
}
b := []byte(bs)
var conf Config
err = json.Unmarshal(b, &conf)
if err != nil {
log.Panicln(err)
}
//Передаём данные с конфиг файла в глобальные переменные
MailConf = map[string]string{
"username": conf.MailConf[0],
"password": conf.MailConf[1],
"host": conf.MailConf[2],
"port": conf.MailConf[3],
}
MailTo = conf.MailTo
Types = conf.Types
EmailSend = conf.EmailSend
RedisConfig = conf.Redis
//Конект с редисом
R = redis.NewClient(&redis.Options{
Addr: RedisConfig[0],
Password: RedisConfig[1],
DB: 0,
})
//Инициализация пакета. Здесь проверям есть ли в редисе такие типы логов. Если нет то создаём
for _, typ := range Types {
_, err := R.Get(RedisConfig[2] + typ).Result()
if err == redis.Nil {
if err := R.Set(RedisConfig[2]+typ, " ", 0).Err(); err != nil {
mail.Send(MailConf, MailTo, "Fatal error game", "package GeneralsLog func Init____R.Set (Создание пустой записи в редис ключ "+typ+")")
}
} else if err != nil {
mail.Send(MailConf, MailTo, "Fatal error game", "package GeneralsLog func Init____R.Set (Проверка записи "+typ+" в редисе)")
}
}
}
func New(types string, messages string) {
for _, typ := range Types {
if typ == types {
if data, err := R.Get(RedisConfig[2] + typ).Result(); err == nil {
//Надо для проверки текущего типа в списке на отправку уведомления на e-mail
for _, b := range EmailSend {
//надо отправлять
if b == typ {
mail.Send(MailConf, MailTo, typ, messages)
}
}
data = data + "('" + types + "','" + time.Now().String() + "','" + messages + "'),"
if err := R.Set(RedisConfig[2]+typ, data, 0).Err(); err != nil {
mail.Send(MailConf, MailTo, "Fatal error game", "package GeneralsLog func "+typ+"____R.Set (Обновление записи в редисе)")
}
} else {
mail.Send(MailConf, MailTo, "Fatal error game", "package GeneralsLog func "+typ+"____R.Get (Получение данных с редиса)")
}
} else {
}
}
}
```
**Демон**package main
import (
«database/sql»
\_ «github.com/go-sql-driver/mysql» //можно подключить любую sql базу данных
«gopkg.in/redis.v3»
«log»
«microService/libs/mail»
«strings»
«time»
«encoding/json»
«io/ioutil»
)
type Config struct {
MailTo, MailConf, Types, EmailSend, Redis, MysqlConnect []string
MysqlTable string
ReplicationTimeSecond time.Duration
}
var (
DB \*sql.DB
R \*redis.Client
MailConf map[string]string
MailTo []string
Types []string
EmailSend []string
RedisConfig []string
MysqlTable string
ReplicationSecond time.Duration
//Путь к файлу с конфигами
config\_file string = "/home/v-smerti/localhost/api/src/microService/config/log.json"
)
func init() {
print(«Starting...»)
//Спарсим конфиг
bs, err := ioutil.ReadFile(config\_file)
if err != nil {
log.Panicln(err)
}
b := []byte(bs)
var conf Config
err = json.Unmarshal(b, &conf)
if err != nil {
log.Panicln(err)
}
//Передаём данные с конфиг файла в глобальные переменные
MailConf = map[string]string{
«username»: conf.MailConf[0],
«password»: conf.MailConf[1],
«host»: conf.MailConf[2],
«port»: conf.MailConf[3],
}
MailTo = conf.MailTo
Types = conf.Types
EmailSend = conf.EmailSend
RedisConfig = conf.Redis
MysqlTable = conf.MysqlTable
ReplicationSecond = conf.ReplicationTimeSecond
//Конект с редисом
R = redis.NewClient(&redis.Options{
Addr: RedisConfig[0],
Password: RedisConfig[1],
DB: 0,
})
//конект с бд
db, err := sql.Open(«mysql», conf.MysqlConnect[0]+":"+conf.MysqlConnect[1]+"@/"+conf.MysqlConnect[2])
if err != nil {
log.Fatal(err)
}
DB = db
//Инициализация пакета. Здесь проверям есть ли в редисе такие типы логов. Если нет то создаём
for \_, typ := range Types {
\_, err := R.Get(RedisConfig[2] + typ).Result()
if err == redis.Nil {
if err := R.Set(RedisConfig[2]+typ, " ", 0).Err(); err != nil {
mail.Send(MailConf, MailTo, «Fatal error game», «package GeneralsLog func Init\_\_\_\_R.Set (Создание пустой записи в редис ключ „+typ+“)»)
}
} else if err != nil {
mail.Send(MailConf, MailTo, «Fatal error game», «package GeneralsLog func Init\_\_\_\_R.Set (Проверка записи „+typ+“ в редисе)»)
}
}
print(" Ok!")
}
func main() {
for {
replication\_db()
time.Sleep(time.Second \* ReplicationSecond)
}
}
func replication\_db() {
for \_, typ := range Types {
data, err := R.Get(RedisConfig[2] + typ).Result()
if err == redis.Nil {
mail.Send(MailConf, MailTo, «Fatal error game», «package GeneralsLog func replication\_db\_\_\_\_R.Set (Нету в редисе „+typ+“)»)
if err := R.Set(RedisConfig[2]+typ, " ", 0).Err(); err != nil {
mail.Send(MailConf, MailTo, «Fatal error game», «package GeneralsLog func replication\_db\_\_\_\_R.Set (Создание пустой записи в редис ключ „+typ+“)»)
}
} else if err != nil {
log.Fatal(err)
mail.Send(MailConf, MailTo, «Fatal error game», «package GeneralsLog func replication\_db\_\_\_\_R.GET (Фатальная ошибка редиса)»)
} else {
if data != " " {
\_, err := DB.Exec(«INSERT INTO » + MysqlTable + " (type,time,messages) VALUES" + strings.TrimRight(data, ","))
if err != nil {
log.Fatal(err)
} else {
log.Println(«replication»)
}
if err := R.Set(RedisConfig[2]+typ, " ", 0).Err(); err != nil {
mail.Send(MailConf, MailTo, «Fatal error game», «package GeneralsLog func replication\_db\_\_\_\_R.Set (Очистка записии „+typ+“)»)
}
}
}
}
}
В коде ещё есть импорт пакета mail.
**Пакет mail**
```
package mail
import (
"fmt"
"net/smtp"
)
func Send(conf map[string]string, to []string, subject string, msg string) error {
auth := smtp.PlainAuth(
"",
conf["username"],
conf["password"],
conf["host"],
)
address := fmt.Sprintf("%v:%v", conf["host"], conf["port"])
body := []byte("Subject: " + subject + "\r\n\r\n" + msg)
err := smtp.SendMail(
address,
auth,
conf["username"],
to,
body,
)
if err != nil {
return err
}
return nil
}
```
```
--
-- Структура таблицы `log`
--
CREATE TABLE IF NOT EXISTS `log` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`type` text NOT NULL,
`time` datetime NOT NULL,
`messages` text CHARACTER SET utf32 NOT NULL,
PRIMARY KEY (`id`),
KEY `type` (`type`(191))
) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;
``` | https://habr.com/ru/post/270263/ | null | ru | null |
# Обработка ошибок в Express
Когда я только начинал работать с Express и пытался разобраться с тем, как обрабатывать ошибки, мне пришлось нелегко. Возникало такое ощущение, будто никто не писал о том, что мне было нужно. В итоге мне пришлось самому искать ответы на мои вопросы. Сегодня я хочу рассказать всё, что знаю об обработке ошибок в Express-приложениях. Начнём с синхронных ошибок.
[](https://habr.com/ru/company/ruvds/blog/476290/)
Обработка синхронных ошибок
---------------------------
Если вам нужно обработать синхронную ошибку, то вы можете, для начала, с помощью инструкции `throw`, выдать такую ошибку в обработчике запроса Express. Обратите внимание на то, что обработчики запросов ещё называют «контроллерами», но я предпочитаю использовать термин «обработчик запросов» так как он кажется мне понятнее.
Вот как это выглядит:
```
app.post('/testing', (req, res) => {
throw new Error('Something broke! ')
})
```
Такие ошибки можно перехватить с помощью обработчика ошибок Express. Если вы не написали собственный обработчик ошибок (подробнее об этом мы поговорим ниже), то Express обработает ошибку с помощью обработчика, используемого по умолчанию.
Вот что делает стандартный обработчик ошибок Express:
1. Устанавливает код состояния HTTP-ответа в значение 500.
2. Отправляет сущности, выполнившей запрос, текстовый ответ.
3. Логирует текстовый ответ в консоль.
*Сообщение об ошибке, выведенное в консоль*
Обработка асинхронных ошибок
----------------------------
Для обработки асинхронных ошибок нужно отправить ошибку обработчику ошибок Express через аргумент `next`:
```
app.post('/testing', async (req, res, next) => {
return next(new Error('Something broke again! '))
})
```
Вот что попадёт в консоль при логировании этой ошибки.
*Сообщение об ошибке, выведенное в консоль*
Если вы пользуетесь в Express-приложении конструкцией async/await, то вам понадобится использовать функцию-обёртку, наподобие [express-async-handler](https://zellwk.com/blog/express-errors/). Это позволяет писать асинхронный код без блоков [try/catch](https://zellwk.com/blog/express-errors/). Подробнее об async/await в Express можно почитать [здесь](https://zellwk.com/blog/async-await-express).
```
const asyncHandler = require('express-async-handler')
app.post('/testing', asyncHandler(async (req, res, next) => {
// Сделать что-нибудь
}))
```
После того, как обработчик запроса обёрнут в `express-async-handler`, то можно, так же, как было описано выше, выбросить ошибку с использованием инструкции `throw`. Эта ошибка попадёт к обработчику ошибок Express.
```
app.post('/testing', asyncHandler(async (req, res, next) => {
throw new Error('Something broke yet again! ')
}))
```
*Сообщение об ошибке, выведенное в консоль*
Написание собственного обработчика ошибок
-----------------------------------------
Обработчики ошибок Express принимают 4 аргумента:
1. error
2. req
3. res
4. next
Размещать их нужно после промежуточных обработчиков и маршрутов.
```
app.use(/*...*/)
app.get(/*...*/)
app.post(/*...*/)
app.put(/*...*/)
app.delete(/*...*/)
// Собственный обработчик ошибок нужно поместить после всех остальных промежуточных обработчиков
app.use((error, req, res, next) => { /* ... */ })
```
Если создать собственный обработчик ошибок, то Express прекратит использование стандартного обработчика. Для того чтобы обработать ошибку, нужно сформировать ответ для фронтенд-приложения, которое обратилось к конечной точке, в которой возникла ошибка. Это означает, что нужно выполнить следующие действия:
1. Сформировать и отправить подходящий код состояния ответа.
2. Сформировать и отправить подходящий ответ.
То, какой именно код состояния подойдёт в каждом конкретном случае, зависит от того, что именно произошло. Вот список типичных ошибок, к обработке которых вы должны быть готовы:
1. Ошибка `400 Bad Request`. Используется в двух ситуациях. Во-первых — тогда, когда пользователь не включил в запрос необходимое поле (например — в отправленной платёжной форме не заполнено поле со сведениями о кредитной карте). Во-вторых — тогда, когда в запросе содержатся некорректные данные (например — ввод в поле пароля и в поле подтверждения пароля разных паролей).
2. Ошибка `401 Unauthorized`. Этот код состояния ответа применяется в том случае, если пользователь ввёл неправильные учётные данные (вроде имени пользователя, адреса электронной почты или пароля).
3. Ошибка `403 Forbidden`. Используется в тех случаях, когда пользователю не разрешён доступ к конечной точке.
4. Ошибка `404 Not Found`. Применяется в тех случаях, когда конечную точку невозможно обнаружить.
5. Ошибка `500 Internal Server Error`. Применяется тогда, когда запрос, отправленный фронтендом, сформирован правильно, но на бэкенде при этом возникла какая-то ошибка.
После того, как определён подходящий код состояния ответа, его нужно установить с помощью `res.status`:
```
app.use((error, req, res, next) => {
// Ошибка, выдаваемая в ответ на неправильно сформированный запрос
res.status(400)
res.json(/* ... */)
})
```
Код состояния ответа должен соответствовать сообщению об ошибке. Для этого нужно отправлять код состояния вместе с ошибкой.
Легче всего это сделать с помощью пакета [http-errors](https://www.npmjs.com/package/http-errors). Он позволяет отправлять в ошибке три фрагмента информации:
1. Код состояния ответа.
2. Сообщение, сопутствующее ошибке.
3. Любые данные, которые нужно отправить (это необязательно).
Вот как установить пакет `http-errors`:
```
npm install http-errors --save
```
Вот как этим пакетом пользоваться:
```
const createError = require('http-errors')
// Создание ошибки
throw createError(status, message, properties)
```
Рассмотрим пример, который позволит как следует в этом всём разобраться.
Представим, что мы пытаемся обнаружить пользователя по адресу его электронной почты. Но этого пользователя найти не удаётся. В результате мы решаем отправить в ответ на соответствующий запрос ошибку `User not found`, сообщающую вызывающей стороне о том, что пользователь не найден.
Вот что нам нужно будет сделать при создании ошибки:
1. Установить код состояния ответа как `400 Bad Request` (ведь пользователь ввёл неправильные данные). Это будет наш первый параметр.
2. Отправить вызывающей стороне сообщение наподобие `User not found`. Это будет второй параметр.
```
app.put('/testing', asyncHandler(async (req, res) => {
const { email } = req.body
const user = await User.findOne({ email })
// Если пользователь не найден - выбросим ошибку
if (!user) throw createError(400, `User '${email}' not found`)
}))
```
Получить код состояния можно с помощью конструкции `error.status`, а сообщение ошибки — с помощью `error.message`:
```
// Логирование ошибки
app.use((error, req, res, next) => {
console.log('Error status: ', error.status)
console.log('Message: ', error.message)
})
```
*Результат логирования ошибки в консоли*
Затем состояние ответа устанавливают с помощью `res.status`, а сообщение записывают в `res.json`:
```
app.use((error, req, res, next) => {
// Установка кода состояния ответа
res.status(error.status)
// Отправка ответа
res.json({ message: error.message })
})
```
Лично я предпочитаю отправлять в подобных ответах код состояния, сообщение и результат трассировки стека. Это облегчает отладку.
```
app.use((error, req, res, next) => {
// Установка кода состояния ответа
res.status(error.status)
// Отправка ответа
res.json({
status: error.status,
message: error.message,
stack: error.stack
})
})
```
### ▍Код состояния ответа, используемый по умолчанию
Если источником ошибки не является `createError`, то у неё не будет свойства `status`. Вот пример, в котором сделана попытка прочесть несуществующий файл с помощью `fs.readFile`:
```
const fs = require('fs')
const util = require('util')
// Преобразуем readFile из функции, использующей коллбэки, в async/await-функцию.
// Подробности об этом смотрите здесь: https://zellwk.com/blog/callbacks-to-promises
const readFilePromise = util.promisify(fs.readFile)
app.get('/testing', asyncHandler(async (req, res, next) => {
const data = await readFilePromise('some-file')
})
```
У такого объекта ошибки не будет свойства `status`:
```
app.use((error, req, res, next) => {
console.log('Error status: ', error.status)
console.log('Message: ', error.message)
})
```
*Результат логирования ошибки в консоли*
В подобных случаях можно задать код ошибки, используемый по умолчанию. А именно, речь идёт об ошибке `500 Internal Server Error`:
```
app.use((error, req, res, next) => {
res.status(error.status || 500)
res.json({
status: error.status,
message: error.message,
stack: error.stack
})
})
```
### ▍Изменение кода состояния ошибки
Предположим, мы собираемся прочитать некий файл, воспользовавшись данными, предоставленными пользователем. Если такого файла не существует, это значит, что нам нужно выдать ошибку `400 Bad Request`. Ведь в том, что файл найти не удаётся, нет вины сервера.
В подобном случае нужно воспользоваться конструкцией try/catch для перехвата исходной ошибки. Затем нужно воссоздать объект ошибки с помощью `createError`:
```
app.get('/testing', asyncHandler(async (req, res, next) => {
try {
const { file } = req.body
const contents = await readFilePromise(path.join(__dirname, file))
} catch (error) {
throw createError(400, `File ${file} does not exist`)
}
})
```
### ▍Обработка ошибок 404
Если запрос прошёл через все промежуточные обработчики и маршруты, но так и не был обработан, это означает, что конечная точка, соответствующая такому запросу, не была найдена.
Для обработки ошибок `404 Not Found` нужно добавить, между маршрутами и обработчиком ошибок, дополнительный обработчик. Вот как выглядит создание объекта ошибки 404:
```
// Промежуточные обработчики...
// Маршруты...
app.use((req, res, next) => {
next(createError(404))
})
// Обработчик ошибок...
```
*Сведения об ошибке*
### ▍Замечания об ошибке ERR\_HTTP\_HEADERS\_SENT
Не впадайте в панику если видите сообщение об ошибке `ERR_HTTP_HEADERS_SENT: Cannot set headers after they are sent to the client`. Она возникает из-за того, что в одном и том же обработчике многократно вызывается метод, устанавливающий заголовки ответа. Вот методы, вызов которых приводит к автоматической установке заголовков ответа:
1. res.send
2. res.json
3. res.render
4. res.sendFile
5. res.sendStatus
6. res.end
7. res.redirect
Так, например, если вы вызовете методы `res.render` и `res.json` в одном и том же обработчике ответа, то вы получите ошибку `ERR_HTTP_HEADERS_SENT`:
```
app.get('/testing', (req, res) => {
res.render('new-page')
res.json({ message: '¯\_(ツ)_/¯' })
})
```
В результате, в том случае, если вы сталкиваетесь с этой ошибкой, тщательно проверьте код обработчиков ответа и убедитесь в том, что в нём нет ситуаций, в которых вызывается несколько вышеописанных методов.
### ▍Обработка ошибок и потоковая передача данных
Если что-то идёт не так при потоковой передаче ответа фронтенду, то можно столкнуться с той же самой ошибкой `ERR_HTTP_HEADERS_SENT`.
В подобном случае обработку ошибок нужно передать стандартным обработчикам. Такой обработчик отправит ошибку и автоматически закроет соединение.
```
app.use((error, req, res, next) => {
// Сделать это нужно только в том случае, если ответ передаётся в потоковом режиме
if (res.headersSent) {
return next(error)
}
// Остальной код обработки ошибок
})
```
Итоги
-----
Сегодня я рассказал вам всё, что знаю об обработке ошибок в Express. Надеюсь, это поможет вам писать более надёжные Express-приложения.
**Уважаемые читатели!** Как вы обрабатываете ошибки в своих Node.js-проектах?
[](https://ruvds.com/vps_start/)
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/476290/ | null | ru | null |
# Джаваскриптовая библиотека MathJax преобразует математические формулы на языке MathML или LaTeX в красивые иллюстрации
Обратите внимание на вот эту иллюстрацию:
![[итог работы MathJax]](https://habrastorage.org/r/w1560/getpro/habr/post_images/8a8/f38/e5e/8a8f38e5e94c497954dedc3b0ae38d9e.png)
Красиво, правда?
Эта иллюстрация получилась вот из какого кода математических формул, записанных на языке LaTeX вперемешку с обычным HTML:
> `The Lorenz Equations
>
>
>
> \[\begin{matrix}
>
> \dot{x} & = & \sigma(y-x) \\
>
> \dot{y} & = & \rho x - y - xz \\
>
> \dot{z} & = & -\beta z + xy
>
> \end{matrix} \]
>
>
>
> The Cauchy-Schwarz Inequality
>
>
>
>
>
> \[ \left( \sum_{k=1}^n a_k b_k \right)^2 \leq \left( \sum_{k=1}^n a_k^2 \right) \left( \sum_{k=1}^n b_k^2 \right) \]
>
>
>
> A Cross Product Formula
>
>
>
>
>
> \[\mathbf{V}_1 \times \mathbf{V}_2 = \begin{vmatrix}
>
> \mathbf{i} & \mathbf{j} & \mathbf{k} \\
>
> \frac{\partial X}{\partial u} & \frac{\partial Y}{\partial u} & 0 \\
>
> \frac{\partial X}{\partial v} & \frac{\partial Y}{\partial v} & 0
>
> \end{vmatrix} \]
>
>
>
> The probability of getting \(k\) heads when flipping \(n\) coins is:
>
>
>
>
>
> \[P(E) = {n \choose k} p^k (1-p)^{ n-k} \]
>
>
>
> An Identity of Ramanujan
>
>
>
> \[ \frac{1}{(\sqrt{\phi \sqrt{5}}-\phi) e^{\frac25 \pi}} =
>
> 1+\frac{e^{-2\pi}} {1+\frac{e^{-4\pi}} {1+\frac{e^{-6\pi}}
>
> {1+\frac{e^{-8\pi}} {1+\ldots} } } } \]`
Вот какие чудеса делает библиотека [MathJax](http://www.mathjax.org/), о которой сегодня появился [обзор](http://ajaxian.com/?p=8334) во блоге Ajaxian.
Правда, когда сам я заглянул на сайт MathJax, то демонстрационные примеры не заработали: то один джаваскрипт не грузился, то другой.
Быть может, сайт попросту перегружен неожиданной популярностью. | https://habr.com/ru/post/79059/ | null | ru | null |
# Как развлечь себя с помощью vk api
В какой-то момент моей жизни я понял, что для счастья мне нужно создать 10 страниц-копий самого себя во Вконтакте и добавиться одновременно всеми в друзья к людям из френдлиста моей основной страницы. Для подробностей реализации идеи — прошу под кат.
Цели проекта
============
* Сделать 10 страниц во Вконтакте
* Скопировать аватар c основной страницы
* Скопировать все посты с основной страницы
* Скопировать все видео с основной страницы
* Добавиться во все группы основной страницы
* Сделать полный граф дружболайков среди ботов (лайкнуть каждую запись и добавить каждого бота в друзья)
* Добавиться каждому из 80 людей из заранее составленного списка в друзья
Регистрация
===========
Для создания страниц я использовал сервис sms-reg.com, подробнее о сервисах приема SMS хорошо написано [тут](https://habr.com/ru/post/446328/).
Регистрируем все 10 страниц и записываем их логины/пароли в файл accounts.json (где id — id регистрируемой страницы, а zero\_id — id нашей основной страницы):
```
{
"zero_id": "21102****",
"accounts": [
{
"phone": "7985002****",
"password": "tTod********",
"id": 53980****
},
{
"phone": "7985317****",
"password": "tglh********",
"id": 53980****
},
...
{
"phone": "7916033****",
"password": "ZsRq********",
"id": 54038****
}
]
}
```
python + vk\_api
================
Я буду работать с библиотекой vk\_api.
```
pip install vk_api --user
```
Создадим файл bots.py, он нам пригодится для остальных скриптов:
```
import json
import vk
import vk_api
from captcha import captcha_handler
with open('accounts.json', 'r') as file:
data = json.loads(file.read())
accounts = data['accounts']
zero_id = int(data['zero_id'])
vk_apis = []
def init_apis():
current_id = 0
for account in accounts:
vk_session = vk_api.VkApi(account['phone'], account['password'], captcha_handler=captcha_handler)
vk_session.auth()
vk_apis.append(vk_session.get_api())
print('account', current_id, 'successfully inited')
current_id += 1
init_apis()
```
Он читает accounts.json и инициализирует api для каждого из аккаунтов.
Копирование аватара
-------------------
```
def change_photo(vk):
upload_url = vk.photos.getOwnerPhotoUploadServer()['upload_url']
answer = json.loads(requests.post(upload_url, files={'photo': open('avatar.jpg', 'rb')}).text)
vk.photos.saveOwnerPhoto(photo=answer['photo'], server=answer['server'], hash=answer['hash'])
counter = 0
for vk in vk_apis:
change_photo(vk)
print(counter, 'done')
counter += 1
```
Копирование видео
-----------------
```
videos = default_vk.video.get(owner_id=zero_id, count=100)
counter = 0
for vk in vk_apis:
for video in videos['items']:
vk.video.add(video_id=video['id'], owner_id=video['owner_id'])
```
Добавление в группы
-------------------
```
from time import sleep
from bots import vk_apis, zero_id, accounts, default_vk
groups = default_vk.groups.get(user_id=zero_id, count=100)
counter = 0
for vk in vk_apis:
for group in groups['items']:
print('add to', group)
vk.groups.join(group_id=group)
print(counter)
counter += 1
```
Создание полного графа друзей
-----------------------------
```
counter = 0
for vk, account in zip(vk_apis, accounts):
for friend in accounts:
if friend['id'] == account['id']:
continue
vk.friends.add(user_id=friend['id'], captcha_handler=captcha_handler)
print(counter, friend['id'], account['id'])
counter += 1
sleep(1)
```
Создание полного графа лайков
-----------------------------
| | |
| --- | --- |
```
counter = 0
for vk, account in zip(vk_apis, accounts):
for friend in accounts:
if friend['id'] != account['id']:
continue
print(counter, friend['id'], account['id'])
for post in vk.wall.get(owner_id=friend['id'])['items']:
flag = True
while flag:
try: #иногда скрипт падал из-за большого количества запросов в секунду
vk.likes.add(type='post', owner_id=post['owner_id'], item_id=post['id'])
flag = False
except:
print('failed on', counter)
sleep(10)
pass
counter += 1
```
Добавление в друзья
-------------------
создаем файл friends, в котором в каждой сточке пишем
```
id_человека #ник_человека (для себя)
```
Вконтакте позволяет добавить примерно 80 человек в день.
```
friends_str = ''
with open('friends', 'r') as file:
friends_str = file.read()
friends = [{'id': x.split(' #')[0], 'name': x.split(' #')[1]} for x in friends_str.split('\n')]
ids_ = ([x['id'] for x in (default_vk.users.get(user_ids=[x['id'] for x in friends]))])
for friend, id_ in zip(friends, ids_):
print(friend['name'])
print(friend)
for vk in vk_apis:
flag = True
while flag:
try:
vk.friends.add(user_id=int(id_))
flag = False
except:
print('error')
sleep(10)
```
Обход капчи
-----------
Внимательный читатель уже увидел строчку
```
from captcha import captcha_handler
```
Поскольку Вконтакте не всегда нравится такое количество запросов, приходится обрабатывать капчу. Есть огромное количество сервисов, которые предоставляют такую возможность. Нужно просто отправить post запрос с капчей в base64 и подождать.
```
def uncapcha(url):
imager = requests.get(url)
r = requests.post('http://rucaptcha.com/in.php', data = {'method': 'base64', 'key': RUCAPTCHA_KEY, 'body': base64.b64encode(imager.content)})
if (r.text[:3] != 'OK|'):
print('captcha failed')
return -1
capid = r.text[3:]
sleep(5)
capanswer = requests.post('http://rucaptcha.com/res.php', data = {'key': RUCAPTCHA_KEY, 'id':capid, 'action':'get'}).text
if (capanswer[:3] != 'OK|'):
print('captcha failed')
return -1
return capanswer[3:]
```
Результаты
==========
Вот несколько скриншотов того, что мне прислали люди
**Скрытый текст**
| | |
| --- | --- |
| | |
| | |
[github](https://github.com/galqiwi/vk-clones)
Главный вопрос остается открытым — зачем я это сделал? Понятия не имею. | https://habr.com/ru/post/449656/ | null | ru | null |
# ExtJS для новичков — Подготовка к работе со Store
Этот топик является продолжением [заметки](http://habrahabr.ru/sandbox/2524/), оставленой в песочнице. Тут, как и было обещано в заметке, будет более подробно рассказано о использовании обьектов **DataProxy**, **DataReader**.
Но для начала рассмотрим структуру, которая содержит в себе уже готовые данные, которыми оперирует **Store**, это **Record**.
Представте себе таблицу, сверху у нас названия колонок, а ниже идут строки значений, **Record** из себя и представляет такую строку значений, с тем отличием, что каждая такая строка содержит в себе и названия колонок-значений. У **Record**'а два основные свойства:* **fields** — содержит массив обьектов класа **Field**. Эти обьекты как раз заменяют названия колонок, и, к тому еще, расширяют их. Они предназначены для описания соответствующих им значений. Это довольно мощное средство для формирования данных нужного вида. Хочу подробнее рассмотреть его свойства
+ **allowBlank** используется при валидации значения, по умолчанию true, что значит — значение может быть пустым
+ **convert** — функция-келлбек, которая вызывается **Reader**'ом при сохранении каждого значения **Record**'a. Эта функция принимает как параметер и сам **record**, поэтому у нас есть возможность обьеденять значения, как ето показано в официальной документации (см. дальше).
+ **type** указывает на тип значения, это может быть целым числом, строкой, или датой, типов много, и от типа иногда зависит как будет отображатся это значение например в **Grid**'e
+ **dateFormat** используется для формирования даты, но только если тип значения — date
+ **defaultValue** уставливает значение по умолчанию
+ **name** указывает название значение, название колонки в нашей таблице
+ **sortDir** указывает направление сортировки
+ **sortType** — тут можна установить свою функцию для сортировки
+ **mapping** — тут мы указываем каому значению из массива источника будет соответствовать этот **Field**
* **data** — это и есть наши данные, каждому елементу массива соответствует обьект **Field** из массива **fields**
Пример создания **Record**'a (из официальной документации)
> `function fullName(v, record){
>
> return record.name.last + ', ' + record.name.first;
>
> }
>
>
>
> function location(v, record){
>
> return !record.city ? '' : (record.city + ', ' + record.state);
>
> }
>
>
>
> var Dude = Ext.data.Record.create([
>
> {name: 'fullname', convert: fullName},
>
> {name: 'firstname', mapping: 'name.first'},
>
> {name: 'lastname', mapping: 'name.last'},
>
> {name: 'city', defaultValue: 'homeless'},
>
> 'state',
>
> {name: 'location', convert: location}
>
> ]);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Вернемся к нашим ридерам и прокси.
**DataProxy**, как уже было отмечено, занимается доставкой информации обьекту класса **DataReader** (точнее обьекту класа Store, который уже с помощю **DataReader** декодирует эту информацию), для последующего разбора. В стандартной полной поставке фреймворка есть несколько класов наследующих **DataProxy**:
* **MemoryProxy** — используется для получения данных из обычного массива, созданого в приложении
* **HttpProxy** — использиется для получения данных с помощю AJAX запроса
* **ScriptTagProxy** — как и **HttpProxy**, с тем отличием, что етот клас умеет делать кросдоменный AJAX запрос (вспомним, что обычный **XmlHttpRequest** не может запрашивать данные с других доменов)
Все эти классы наследуют от **DataProxy** два основные свойства:
* **api** — список из 4-ох URL на каждое из действий обработкы данных (load, creat, save, destroy), используется только наследниками **DataProxy**, которые используют AJAX. Об етих URL мы поговорим ниже, когда будем рассматривать работу с **Store**.
* **doRequest** — наследуется как свойство, но с последующим присваеванием превращается в функцию, которая и делает основную работу — запрашивает данные у источника. Если вы захочете создать свой тип прокси, то вам придется написать и присвоить / переопределить эту функцию.
Теперь рассмотрим классы наследники **DataReader**'a. В стандартной полной поставке их, как и прокси, несколько:
* **ArrayReader** — предназначен для «читания» обычного массива, обычно использиется вместе с **MemoryProxy**
* **JsonReader** — используется для декодирования json-строки или «читания» json-массива (ассоциативного, хеш), который считается обьектом
* **XmlReader** — соответственно, для декодирования XML
Вот пример создания **ArrayReader**
> `var fields = Ext.data.Record.create([ // создаем Record с правилами-филдами. он будет использоватся ридером
>
> {name: 'name', mapping: 1}, // как мы знаем, отщет елементов массива начинается с нуля
>
> {name: 'last', mapping: 2} // потому, если тут не использовать маппинг, то name будет использовать нолевой елемент а last - первый (ето просто пример)
>
> ]);
>
>
>
> var myReader = new Ext.data.ArrayReader({}, fields);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
А тут у нас уже **JsonReader**
> `var myReader = new Ext.data.JsonReader({
>
> totalProperty: "results", // это свойство используется для получения общего количества записей
>
> // (обычно используется при загрузке данных с сервера, по несколько штук, при использовании Pager'a)
>
> root: "rows", // тут название элемента, в котором будут данные для создания Record'ов
>
> idProperty: "id" // каждый Record получaет от Reader уникальный id, по которому можна легко к нему обратится,
>
> // свойство id указывает чтоб Reader как id использовал значение из первой колонки нашей "таблички"
>
> },
>
> fields
>
> );
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Ответ от прокси для **JsonReader**'a должен быть такого типа (обратите внимание на одинаковые названия эленентов внизу, и значений вверху, для лучшего понимания):
> `{
>
> results: 2,
>
> rows: [
>
> { id: 1, name: 'Имя 1', last: 'Фамилия 1' },
>
> { id: 2, name: 'Имя 2' , last: 'Фамилия 2' }
>
> ]
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
У **XmlReader**'a немного по другому, названия свойств другие, но почти то же самое
> `var myReader = new Ext.data.XmlReader({
>
> totalRecords: "results",
>
> record: "row",
>
> id: "id"
>
> }, fields);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
При ответе от прокси
> `</fontxml version="1.0" encoding="UTF-8"?>
>
> <dataset>
>
> <results>2results>
>
> <row>
>
> <id>1id>
>
> <name>Имя 1name>
>
> <last>Фамилия 1last>
>
> row>
>
> <row>
>
> <id>2id>
>
> <name>Имя 2name>
>
> <last>Фамилия 2last>
>
> row>
>
> dataset>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Как мы знаем, в **ExtJS** довольно много сокращений, поетому создавать **Record** необязательно, можно сделать так (он создастся автоматически)
> `var myReader = new Ext.data.XmlReader({
>
> totalRecords: "results",
>
> record: "row",
>
> id: "id",
>
> fields:[
>
> {name: "id"},
>
> "name", // если не используются никакие другие параметры кроме name, то можна использовать вот такую сокращенную запись
>
> ...
>
> ]
>
> });
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Если хабралюди пожелают, то в следующем топике поговорим уже именно о работе со **Store**, используя накопленые знания :)
**UPD**: чтоб было более понятно для чего вообще этот прокси, напишу кратко как **Store** использует **DataProxy** и **DataReader** по порядку:
* **Store** запрашивает у **DataProxy**'а метод doRequest с параметром load, **DataProxy** возвращает **Store** некий обьект / строку
* этот обьект / строку **Store** передает **DataReader**'у, который все это разгребает, и возвращает для **Store** массив **Record**'ов
просто пользуется уже готовеньким :) | https://habr.com/ru/post/60549/ | null | ru | null |
# Анализ источников трафика для повышения конверсии
 В этой статье речь пойдет о том, как правильно анализировать источники трафика, например, с помощью инструментов Google Analytics или Yandex Metrica. Отключив источники с низкой либо нулевой конверсией, можно существенно поднять общую конверсию, снизить стоимость заказа и улучшить рентабельность интернет-рекламы.
Цель этой статьи — получить отзывы и замечания по описанным ниже методам, описать способы принятия обоснованных решений по блокировке некачественных источников трафика.
Итак, предположим, что мы решили организовать свой маленький бизнес по продаже, например, книг, через интернет. Мы создали замечательный юзер-френдли сайт, зайдя на который просто невозможно что-либо не купить. Погуглив отзывы, мы выбрали одну из множества рекламных сетей как источник недорогого трафика для нашего магазина. Как правило, все рекламные сети не обладают собственным трафиком, а покупают его у различных источников. Качество трафика разных источников может быть крайне разнообразным. На каких-то источниках может быть самая наглая накрутка, от которой никакой конверсии ждать не придется. С других источников идут случайные клики, а не целевые переходы. На третьих источниках аудитория интересуется семками и битами, а не книгами. На четвертых источниках, напротив, сконцентрированы любители книг, для которых наш ресурс будет просто находкой, и конверсия превысит все ожидания.
Обычно все развитые рекламные сети предоставляют доступ к своим источникам посредством UTM-разметки и дают возможность блокировать источники, которые нам не нравятся. Нам остается только научиться правильно находить те некачественные источники, без отключения которых мы будем выбрасывать деньги на ветер, а то и вовсе обанкротимся. Кроме того, грамотная оптимизация источников позволит нам снизить затраты на рекламу, мы сможем понизить цену товара и стать значительно более конкурентоспособными на рынке.
Хотелось бы подчеркнуть, что под источниками в данной статье подразумеваются не каналы, например Google AdWords, Яндекс Директ или тизерная реклама, а источники (площадки) внутри самого канала. К примеру, мы выбрали какую-то рекламную сеть, у которой покупаем трафик. Эта сеть поставляет нам трафик из сотен независимых источников и задача заключается в том, что бы понять, какие именно из источников не подходят для нашего проекта. Можно, конечно, сравнивать между собой таким способом и каналы, но их обычно бывает не так много и с ними можно разобраться вручную.
Приходилось неоднократно сталкиваться с плохо обоснованным подходом к анализу источников, который называется «на глаз». В одной из разновидностей этого способа просто отключаются источники, которые не дают никакой конверсии, например, со 100 визитов (это число прикидывается в уме). Либо, например, это число визитов дают конверсию ниже 0.1% (число также прикидывается в уме). На самом деле это правильные подходы, кроме «прикидывания в уме», которое может привести к разным ошибкам. Особую остроту приобретает ситуация, когда приходится нести персональную ответственность за принятые решения. В этом случае очень важно уметь обосновать, почему эти источники были заблокированы, а те — не были. “Показалось” здесь будет крайне неуместным. В этой статье будет описано, как обосновать эти значения и минимизировать риски отключить вполне хороший источник.
Для начала нам следует определиться с допустимыми погрешностями. В статистике рассматривают [ошибку первого рода и ошибку второго рода](http://ru.wikipedia.org/wiki/%D0%9E%D1%88%D0%B8%D0%B1%D0%BA%D0%B8_%D0%BF%D0%B5%D1%80%D0%B2%D0%BE%D0%B3%D0%BE_%D0%B8_%D0%B2%D1%82%D0%BE%D1%80%D0%BE%D0%B3%D0%BE_%D1%80%D0%BE%D0%B4%D0%B0).
В нашем случае ошибка первого рода — это когда по случайно сложившимся обстоятельствам мы не отключим плохой источник. Для нас ошибка этого рода не критична: не заблокировали сегодня — заблокируем завтра, когда случайные обстоятельства подуют в правильную сторону.
Более критичной для нас является ошибка второго рода. В нашем случае это момент, когда мы из-за случайностей заблокируем хороший источник. Критично это потому, что после блокировки трафик с него остановится, и у него уже больше не будет шансов доказать, что на самом деле был хорошим.
Вероятность такой ошибки B обычно выбирают 5% или 1% в зависимости от ситуации. Если ситуация критична, реклама не окупается, уходят серьезные суммы, то можно вооружиться вероятностью блокировки хорошего источника в 5% или даже 10%. Если же ситуация стабильна, но просто хочется оптимизировать источники, то лучше выбрать 1%, чтобы минимизировать потери хороших источников. Уровень допустимых ошибок в 1% потребует от нас значительно больше трафика для статистики, чем уровень 5%.
Хотелось бы заметить, что если мы выбрали уровень ошибки, например, 5%, то это совсем не значит, что мы потеряем 5% хороших источников. Это означает, что при граничных (и маловероятных) ситуациях мы потеряем не более 5% хороших источников из тех, что заблокируем.
Следующим этапом следует определить критический уровень конверсии Ccr — трафик с конверсией, ниже которого мы не готовы покупать. Источники с конверсией ниже этого значения будут отключены. А вот источники с конверсией выше этого значения ни в коем случае не должны быть отключены (вернее, вероятность отключения таких источников не должна быть выше допустимой B). Если мы занимаемся оптимизацией источников, мы можем выбрать Ccr как 30% от текущего среднего значения конверсии.
После того как мы определились с базовыми значениями, мы можем запускать рекламу и наблюдать ситуацию в Аналитиксе или в Метрике. Для того чтобы собрать статистику, требуется заложить под это определенный бюджет.
Первый способ обнаружения некачественных источников особенно эффективен на первом этапе — это определение источников, которые не принесли ни одной конверсии, но уже набрали достаточное количество визитов. Рассчитаем пороговое значение количества визитов, выше которого уже можно блокировать источники (если они не принесли ни одной конверсии).
Предположим, что у некоторого источника как раз и есть тот критический уровень конверсии Сcr. Тогда вероятность того, что заказа не произойдет при визите, будет 1-Ccr. А вероятность того, что не произойдет ни одного заказа при N визитах, будет
Приравняем эту вероятность к допустимому уровню вероятности ошибки B, который мы определили в самом начале. Тогда при критическом значении Ncr мы как раз получим это значение.
Чтобы найти Ncr, нам следует логарифмировать обе части выражения и, собственно, найти Ncr
 (1)
Вместо натурального логарифма в вычислениях можно использовать также двоичный или десятичный, если это проще. Итак, определив критическое значение числа визитов Ncr, мы можем смело отключать все источники, которые превысили это число визитов и не дали ни одной конверсии, и при этом можно не волноваться — риск того, что мы выключим хороший источник, не более того, что мы себе задали.
Отключив некачественные источники первым способом и ощутив радость улучшения конверта и горечь уменьшения объемов трафика, мы можем перейти ко второму, более сложному (в вычислительном отношении) способу поиска некачественных источников.
Предположим, что некоторые источники значительно превысили критическое значение Ncr, принесли заказы, но их конверсия кажется нам низкой. Мы их не можем заблокировать по первому способу, но, может быть, их истинная конверсия (которой мы не знаем) все-таки ниже той критической, которую мы для себя установили. Попробуем найти такие источники с допустимыми рисками B.
Мы не можем блокировать источники только потому, что их конверсия ниже Сcr, т.к. такую конверсию случайно могут показать и источники с конверсией выше Ccr. Чтобы исключить это, мы должны блокировать источники, у которых конверсия несколько ниже Ccr и должна быть меньше некоторой граничной величины Cx. Изменяя величину Cx, мы сможем добиться того, что вероятность блокировки источников, конверсия которых выше Ccr, будет не выше оговоренной нами B. Попробуем рассчитать эту граничную величину Cx.
Количество заказов на фиксированной выборке с фиксированной конверсией (а у нас как раз именно эти условия) будут подчиняться [биномиальному распределению](http://ru.wikipedia.org/wiki/%D0%91%D0%B8%D0%BD%D0%BE%D0%BC%D0%B8%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D1%80%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5)
Как известно, при значительных n (число визитов) биномиальное распределение стремится к нормальному с математическим ожиданием m=n\*p и дисперсией D=s^2=n\*p\*q (p, в нашем случае это конверсия, а q = 1-p).
Предположим, что некоторый источник имеет критическое значение конверсии Ccr. Тогда вероятность К того, что при n визитах он покажет конверсию Cx или менее, равна:
По таблицам нормального распределения или с помощью пакета [numpy](http://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.norm.html#scipy.stats.norm) в python находим соответствующие квантили K — такие значения нормальной функции, при которых вероятности будут соответствовать допустимым ошибкам B:
```
>>>from scipy.stats import norm
>>> norm.ppf(0.05)
-1.6448536269514729
>>> norm.ppf(0.01)
-2.3263478740408408
```
Тогда получаем:
Откуда:
 (2)
Таким образом, если текущая конверсия источника при соответствующем количестве визитов ниже граничной Cx, то источник нужно блокировать.
Если n мало, то Cx может получится отрицательной. Это значит, что данного количества визитов недостаточно для оценки источников. Из формулы видно, что при увеличении числа визитов n Сx будет стремиться к Ccr снизу, что логически ожидаемо.
Вручную расчитывать для каждого источника его Cx весьма затруднительно, поэтому привожу исходный код простого python-скрипта, который обрабатывает csv выгрузку из Аналитикса и дописывает колонку с граничными Cx для последующего анализа и поиска источников для блокировки:
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import csv
import math
from scipy.stats import norm
# Исходный файл, например, выгрузка из Аналитикса
file_in = 'in.csv'
# Файл в который будет записан результат
file_out = 'out.csv'
# Критическое значение конверсии !ВНИМАНИЕ! в % , ниже которого источник должен быть удален
Ccr = 1.0
# Погрешность - вероятность блокировки хорошего источника (конверт которого на самом деле выше критического)
B = 0.05
# Колонка, в которой находится название источника (первая колонка - 1)
column_source = 1
# Колонка, в которой находится количество визитов
column_n = 2
# Колонка, в которой находится процент конверсий источника
column_c = 4
K = norm.ppf(B)
Ccr = float(Ccr) / 100
# У компьютеров индексы массивов начинают считаются не как у людей, а с 0, поэтому:
column_source -=1
column_n -=1
column_c -=1
out_data = []
with open(file_in, 'rb') as csvfile:
reader = csv.reader(csvfile, delimiter=',')
for i, row in enumerate(reader):
#Обрабатываем заголовки, которые всегда есть в выгрузках Аналитикса
if not i:
out_data.append([row[column_source], row[column_n], row[column_c], 'Cx, %'])
continue
n = row[column_n]
n = n.replace(' ', '')
n = int(n)
C = row[column_c]
# В выгрузках Аналитикса зачем-то в каждую ячейку записывают знак процента,
# вероятно для того, что бы усложнить использование формул
C.replace('%', '')
C.replace(',', '.')
Cx = Ccr + K * math.sqrt(Ccr * (1 - Ccr) / n)
Cx = round(Cx * 100, 3)
out_data.append([row[column_source], str(n), C, str(Cx)])
with open(file_out, 'wb') as csvfile:
writer = csv.writer(csvfile, delimiter=',', quoting=csv.QUOTE_MINIMAL)
for row in out_data:
writer.writerow(row)
```
Рассмотрим ниже простой пример анализа источников. Предположим, у нас есть 8 источников с такими данными:
| Источник | Визиты | Заказы | Конверсия, % |
| --- | --- | --- | --- |
| 1 | 844 | 3 | 0.355 |
| 2 | 751 | 47 | 6.258 |
| 3 | 520 | 1 | 0.192 |
| 4 | 397 | 40 | 10.076 |
| 5 | 315 | 0 | 0 |
| 6 | 301 | 0 | 0 |
| 7 | 162 | 8 | 4.938 |
| 8 | 12 | 0 | 0 |
Возможно, пример выглядит несколько искусственным, потому что тут и “на глаз” видно, где что нужно блокировать. Это так, потому что, во-первых, здесь их мало, во-вторых, их свойства ярко выражены. На практике масса граничных случаев, когда даже самый опытный “глаз” обязательно примет неправильное решение.
Итак, общая конверсия этой системы = Сm = Сумма всех заказов / Сумма всех визитов = 2.998%
Выберем критическое значение как 0.3\*Сm = 1%
По формуле (1) рассчитаем пороговое значение, которым можно отделить источники с нулевой конверсией.
Ncr = ln(0.05)/ln(1-0.01) = 298
Теперь ищем источники, у которых конверсия 0 и количество визитов более 298. Таких у нас 2 источника: 5 и 6. Их мы блокируем по первому признаку.
Источник 8 по этому признаку мы отключить не можем, потому что, несмотря на то, что там конверсия 0 — посетителей было очень мало, и мы не можем быть уверены, что ее истинная конверсия на самом деле ниже критической. Быть может, на самом деле ее конверсия еще выше, чем у источника 7, не смотря на то, что тот показывает очень неплохие результаты.
Теперь перейдем к второму признаку.
Посчитаем граничное значение конверсии для первого источника по формуле (2):
Cx = 0.01 + (-1.64) \* sqrt(0.01\*(1-0.01)/844) = 0.00438 = 0.438%
Таким образом, текущая конверсия этого источника ниже граничной, и мы можем с вероятностью ошибки не более 5% утверждать, что конверсия этого источника ниже критической. Таким образом, этот источник подлежит блокировке.
Чтобы не считать вручную оставшиеся 7 конверсий, я использую приведенный выше скрипт. Сохраняем исходные данные в файл in.csv. Внимательно просматриваем и настраиваем переменные в начале скрипта, запускаем calc.py и смотрим результаты в out.csv, который покажет нам следующий результат:
| Источник | Визиты | Конверсия, % | Cx, % |
| --- | --- | --- | --- |
| 1 | 844 | 0.355 | 0.437 |
| 2 | 751 | 6.258 | 0.403 |
| 3 | 520 | 0.192 | 0.282 |
| 4 | 397 | 10.076 | 0.179 |
| 5 | 315 | 0 | 0.078 |
| 6 | 301 | 0 | 0.057 |
| 7 | 162 | 4.938 | -0.286 |
| 8 | 12 | 0 | -3.724 |
Сравнив текущую и граничные конверсии, мы можем увидеть, что источник 3 также подлежит блокировке.
Интересно также отметить, что источники 5 и 6 снова попадают под блокировку. Это понятно, так как метод 2 не противоречит методу 1, но расширяет его на случай, когда текущая конверсия источника не 0.
Граничная конверсия источников 7 и 8 ниже нуля. Это значит, что при том количестве визитов, которые на данный момент имеют те источники, они не могут быть заблокированы ни при каком количестве заказов (ну, разве что при отрицательном). Их количества визитов недостаточно, чтобы делать какие-либо прогнозы с допустимой вероятностью ошибки.
Вот таким образом мы можем подвести математическое обоснование под свои решения по блокировке источников. Следует, конечно, заметить, что для успешного блокирования источников с вероятностью ошибки не выше заданной, необходимо достаточно высокое количество посетителей из анализируемого источника. Для примера, если Сcr задать в 0.38%, то отключения этого источника по отсутствию конверта потребуется уже не менее 787 переходов. А, к примеру, для граничной конверсии Cx=0.119 при тех же значениях требуется уже около 1500 визитов с этого источника. Но визиты, анализируются не за один день, иногда даже за месяц, поэтому такие трудности могут ожидать только недавно начавшиеся рекламные кампании. Кроме того, есть способы значительного улучшения чувствительности, но это тема, вероятно, уже другой статьи.
Буду признателен за указание ошибок и неточностей. Успешных рекламных кампаний! | https://habr.com/ru/post/210946/ | null | ru | null |
# Использование runit для своих сервисов
Супервизор сервисов [**runit**](http://smarden.org/runit/) позиционируется как замена стандартным скриптам инициализации Unix.
Но на практике оказалось, что runit идеален для управления сервисами безотносительно инициализации и т.п.
#### Введение
Супервизор берёт на себя такой функционал, как:
* превращение любого процесса в демон;
* логгирование вывода процесса и ротирование логов;
* запуск, остановка, рестарт, запрос состояния, управляющие скрипты для init.d;
* выключение и запуск сервисов автоматически при появлении новых сервисов в списке либо удалении старых из списка;
* возможность ведения нескольких независимых списков сервисов одновременно (например, для каждого пользователя отдельно и для системы в целом);
* удобный API для управления сервисами.
Для большинства операционных систем runit уже входит в репозитории пакетов (apt-get install runit). Кроме того, мы имеем уже [готовый набор рецептов](http://smarden.org/runit/runscripts.html) для популярных сервисов (nginx, apache etc.).
Далее рассмотрим стандартную схему runit (которая используется по умолчанию):
#### Демонизация
Каждый сервис описывается отдельным каталогом /etc/sv/<название сервиса>.
обычно достаточно иметь в этом каталоге исполняемый скрипт **run** вида
```
#!/bin/bash
exec 2>&1
exec your_running_command
```
Важно, чтобы your\_running\_command не демонизировала себя (не отсоединялась от стандартных потоков stdin, stdout, stderr).
Переадресация ошибок в стандартный вывод нужна для их логгирования. Выполняется логгирование, если в каталоге /etc/sv/<название сервиса>/log/ разместить файл **run** вида
```
#!/bin/bash
LOG_FOLDER=/var/log/<название сервиса>
mkdir -p $LOG_FOLDER
exec svlogd -tt $LOG_FOLDER
```
Сервисы, расположенные в каталоге /etc/sv/, не выполняются, пока ссылки на них не будут размещены в каталоге /etc/service/.
Как только вы сделаете `ln -s /etc/sv/<название сервиса> /etc/service/<название сервиса>`, сервис runsvdir увидит новый сервис, и запустит его. Более того, в случае остановки сервиса он будет автоматически перезапущен. Это даёт гораздо более быструю реакцию на остановку сервиса по сравнению с использованием сервисов мониторинга (god или monit).
#### Ротирование логов
При использовании svlogd логи размещаются в папке, которую Вы указали при её запуске. При этом текущий лог находится в файле current, и периодически выполняется ротирование логов в этой папке.
#### Управление
Запускать, останавливать, перезапускать сервисы можно с помощью команды `sv (start|stop|restart...) <название сервиса>`.
Кроме того, при запуске сервиса появится каталог /etc/service/<название сервиса>/supervise, в котором будут расположены очень полезные файлы и потоки:
* pid — идентификатор процесса Unix;
* stat — человеко-читаемое состояние сервиса
* status — машинно-читаемое состояние процесса
* control — поток управления
* и так далее...
Можно отметить, что для остановки или запуска процесса достаточно открыть поток control на запись, и отправить туда символ d (от down) или u (от up) соответственно.
##### В стиле init.d
Нет ничего проще, чем поддержать управление в стиле init.d.
Просто делаем `ln -s /usr/bin/sv /etc/init.d/<название сервиса>`. sv поймёт, что его вызвали в стиле init.d, и готов будет принимать команды вида `/etc/init.d/<название сервиса> start` etc. Совсем немного магии, правда?
#### Настройка сервисов
В комплекте с runit поставляется утилита **chpst**, которая позволяет выполнять сервисы с дополнительной настройкой (ограничивать размер памяти, запускать из под определенного пользователя, с другим уровнем nice и т.д.).
#### Резюме
**runit** оказался настолько удобен и надёжен для организации своих сервисов, что мы стараемcя переводить все наши демоны под runit, заодно отказываясь от различного геморроя в виде пакетов демонизации а ля daemons gem. Также на части машин мы избавились от Monit (где требовался лишь мониторинг процессов).
Крайне рекомендую к прочтению [комментарий](http://habrahabr.ru/blogs/sysadm/83775/#comment_2497207) от [powerman](https://habrahabr.ru/users/powerman/), а также статью про [Web-интерфейс к runit](http://habrahabr.ru/blogs/sysadm/84627/). | https://habr.com/ru/post/83775/ | null | ru | null |
# Русификация библиотеки openGLCD для Arduino
Написание русскоязычного текста на графических дисплеях с контролером ks0108 или его аналогами все еще представляет существенные трудности. Библиотека openGLCD, которую рекомендуют официальные сайты Arduino, в [оригинальной комплектации](https://bitbucket.org/bperrybap/openglcd) последней на данный момент версии не содержит никаких кириллических шрифтов, кроме шрифта cp437font8x8. На практике он малопригоден, потому что в русскоязычной части поддерживает [кодировку Win-1251](https://ru.wikipedia.org/wiki/Windows-1251). Следовательно, чтобы выводить символы таким шрифтом, их нужно либо вставлять в текст восьмеричными или шестнадцатеричными кодами (и при этом остаются неясности со строчной буквой «я», как указывает в комментарии сам создатель шрифта), либо все равно писать отдельную функцию перекодировки, как [это сделал arduinec](http://arduino.ru/forum/programmirovanie/rusifikatsiya-biblioteki-adafruit-gfx-i-vyvod-russkikh-bukv-na-displei-v-kodi) для библиотеки Adafruit-GFX.
Кроме всего прочего, cp437font8x8 крупноват для экранчиков 128х64 точки. Оптимальным размером шрифта для вспомогательных надписей на таком дисплее остается System5x7. Мы здесь сосредоточимся на русификации именно системного шрифта, хотя читатель может по этому образцу самостоятельно русифицировать и любой другой шрифт (особенно, если у него экран побольше).
А в чем проблема?
-----------------
Для начала давайте вникнем в корни проблемы. Среда Arduino IDE — это обычный текстовый редактор Windows, который работает в универсальной [кодировке UTF-8](https://ru.wikipedia.org/wiki/UTF-8), как любой другой в современных версиях Windows (Блокнот, например). UTF-8 представляет собой экономичную версию многобайтовой кодировки UNICODE. В UTF-8 англоязычные символы, цифры, точки-запятые-скобки и всякие прочие значки представлены одним байтом, совпадающим со стандартной [кодировкой ASCII](https://ru.wikipedia.org/wiki/ASCII). Поэтому их представление в коде скетча не представляет никаких трудностей: строка англоязычных символов после компиляции передается в загружаемый hex-файл без изменений и оказывается понятна 8-разрядному контролеру, как говорится, «без перевода».
В процессе этого преобразования каждый символ, как и в любой программе на любом языке программирования, представляется непосредственно в виде его кода, то есть порядкового номера в таблице шрифта, из которой программа извлекает графическое начертание соответствующего символа. В файле шрифта *System5x7.h* библиотеки openGLCD количество символов представлено переменной *font\_Char\_Count* типа *uint8\_t*, то есть не может превышать величины одного байта. Поэтому кириллические символы, которые [в UTF-8 занимают два байта](http://i.voenmeh.ru/kafi5/Kam.loc/inform/UTF-8.htm), не могут быть переданы контроллеру обычным образом.
**Предыдущие попытки решения**Заметим, что это было не всегда так. Версии Arduino 1.0.x (и, по слухам, 1.6.0) усекали двухбайтовый код до однобайтового, банально отбрасывая старший байт (который для кириллицы, как следует из таблицы UTF-8 по ссылке выше, равен либо 0xD0, либо 0xD1). Потому для доработки шрифта в этих версиях среды годится [старая библиотека GLCD v3](http://playground.arduino.cc/Code/GLCDks0108), в которой массив шрифта просто дополнялся символами кириллических букв так, чтобы их позиции совпадали с младшим байтом кодировки UTF-8 (байты с 0x80 по 0xBF). Более подробно такая модернизация описана в статье автора [«Работа с текстом на графическом дисплее»](http://blog.amperka.ru/%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%B0-%D1%81-%D1%82%D0%B5%D0%BA%D1%81%D1%82%D0%BE%D0%BC-%D0%BD%D0%B0-%D0%B3%D1%80%D0%B0%D1%84%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%BC-%D0%B4%D0%B8%D1%81%D0%BF%D0%BB#more-1767). Повторяю — для нее нужна одна из версий Arduino IDE 1.0.x в совокупности с библиотекой GLCD v3, а не их более современные варианты.
В новых версиях Arduino IDE стало все сложнее. Библиотека решительно отказывается понимать двухбайтовые номера символов, выводя вместо них пустое место, потому простой переделкой шрифта тут не обойдешься. Приходится дополнить его функцией перекодировки двухбайтовых символов в однобайтовые.
Решение
-------
Автор не стал лезть в недра библиотечных функций, а написал для openGLCD надстройку в виде функции *outstr()*, которая перебирает все элементы входной строки, пропуская их через оператор выбора *Switch*. Он вылавливает из строки кириллические символы и заменяет их однобайтовыми кодами, соответствующими модернизированному файлу шрифта *System5x7R.h*.
Например, для заглавной русской буквы «Ф» строка замены будет такой:
```
case 'Ф': GLCD.PutChar(0xA4); break;
```
Здесь 0xA4 — младший байт кодировки буквы «Ф» в UTF-8 (см. ссылку выше). В соответствии с этой кодировкой составлен новый файл шрифта *System5x7R.h*. В принципе при таком подходе в шрифте можно применять любую кодировку русских символов и любых других глифов, которые вздумается вставить в шрифт. Лишь бы их общее количество не превышало 128 штук: от начала таблицы до символа 0x7F (127 — последний символ стандартной таблицы ASCII) целесообразно оставить шрифт в неприкосновенности.
Правда, пару вольностей с таблицей ASCII я себе разрешил. Дело в том, что в оригинальном шрифте *System5x7.h* значок градуса вынесен в последнюю строку таблицы, занимая символ 0x80, который у нас уже относится к кириллице. Чтобы не нарушать порядок построения кириллической таблицы в соответствии с UTF-8, эта строка выброшена из файла. А значок градуса пристроен вместо символа ASCII «~» (номер 0x7E), который в шрифте все равно не использовался по назначению. Зато такая замена позволяет вводить значок градуса в тексте скетча прямо с клавиатуры в виде символа «~».
Еще одна вольность связана с тем, что автор на дух не переносит перечеркнутый ноль — архаику времен АЦПУ и монохромных текстовых дисплеев. Потому ноль в модернизированном шрифте заменен на глиф буквы «О». Те, кто придерживается пуристических принципов, могут просто удалить в файле шрифта *System5x7R.h* эту вставку (старый глиф перечеркнутого нуля там оставлен закомментированным, его код 0x30).
В модернизированной библиотеке *openGLCD*, которую вы можете скачать по ссылке в конце статьи, внесено еще одно исправление — изменен порядок подключения выводов для дисплеев с контроллером ks0108. Почему автором библиотеки выбран такой порядок (см. таблицу [по ссылке на официальном сайте Arduino](http://playground.arduino.cc/Code/GLCDks0108)), неизвестно. В модернизированном варианте подключение дисплея (для примера выбран популярный MT-12864J) осуществляется согласно вот такой схеме:
**Схема подключения MT-12864J**
Переменный резистор R1 здесь подключается согласно [рекомендации производителя](http://files.amperka.ru/datasheets/MT-12864J.pdf), а резистор R2 служит для ограничения тока подсветки, если она подключена не к напряжению 5 В, а прямо ко входному источнику питания (вывод Vin Arduino) с более высоким напряжением.
Пример вывода на дисплей MT-12864J русского алфавита вперемешку с латинским, а также цифр и значка градуса, представлен на фото:
Текст скетча для этого примера:
**Текст скетча с выводом русского алфавита**
```
#include //подключим библиотеку
#include //файл с функцией вывода русских букв
#include //файл с кодами русских букв
void setup() {
GLCD.Init(); //инициализация
GLCD.ClearScreen();
}
void loop()
{
GLCD.SelectFont(System5x7R); //выбираем шрифт
GLCD.CursorTo(0,0); //установим курсор в начальную позицию
//выводим смешанные англо-русские строки:
outstr("ABC АВГДЕЖЗИКЛМНОП\n");
outstr("PRQ РСТУФХЦЧШЩЪЫЬЭЮЯ\n");
outstr("nts абвгдежзийклмноп\n");
outstr("xyz рстуфхцчшщъыьэюя\n");
GLCD.println("1234567890");
GLCD.CursorTo(19,4); //установим курсор в предпоследнюю позицию 5-й строки
GLCD.print("~C"); //градус С
GLCD.println("@;/.,|<>()=-\_{}\"'");
GLCD.CursorTo(4,7); //установим курсор в поз 4 строки 8
GLCD.print("MT-12864J");
}
```
Так как файлы с функцией *outstr.h* и шрифтом *System5x7R.h* размещены в корневом каталоге модернизированной библиотеки, то на них надо размещать отдельные ссылки в начале скетча с помощью директивы *#include*. Для англоязычных надписей удобно по-прежнему пользоваться стандартными функциями *println/print*, а вот при необходимости перевода строки в русском тексте необходимо явно указывать символ «\n».
Подправленный вариант библиотеки вы можете скачать [здесь](http://revich.lib.ru/AVR/openGLCD.zip). Распакованную библиотеку (папку *openGLCD*) следует поместить в папку *Arduino\libraries*, как обычно. Пример скетча находится в том же архиве отдельно (в не в папке Examples библиотеки). Подключение дисплея с контроллером ks0108 в соответствии с этой библиотекой отражено на схеме выше. Если вам захочется дополнительно изменить порядок подключения выводов, то разыщите в папке *Arduino\libraries\openGLCD\config\ks0108* файл *PinConfig\_ks0108-Uno.h* и отредактируйте в нем строки под заголовком «Data pin definitions» и далее, ориентируясь на исправления автора.
В следующей публикации мы попытаемся разобраться с русификацией строчных дисплеев. Как вы увидите, с ними все одновременно и проще и сложнее. | https://habr.com/ru/post/400749/ | null | ru | null |
# Опыт настройки и использования WSL (подсистемы Linux в Windows 10)
К написанию данной статьи меня побудил вопрос на Тостере, связанный с WSL. Я, после нескольких лет использования систем на ядре Linux, около полугода назад перешел к использованию Windows 10 на домашнем ПК. Зависимость от терминала и Linux окружения в моей работе практически сразу привели меня к вопросу: или ставить виртуалку или попробовать WSL. Я выбрал второе, и остался вполне доволен.
Под катом я расскажу как установить и настроить WSL, на какие я наткнулся проблемы и ограничения, как запускать Linux приложения из Windows и наоборот, а так же как интегрировать элементы окружения Xfce в окружение рабочего стола Windows.
Никогда не думал, что однажды вернусь на Windows, но повод попробовать мне дали стечения обстоятельств: жена, далекая от IT, дергала почти каждый раз, когда у нее возникала необходимость воспользоваться компом; проснулась ностальгия по одной игре, но она никак не хотела адекватно работать под wine; а тут еще мне подарили коробочную Windows 10 Pro. WSL я поставил чуть ли не сразу после установки системы, поигрался несколько вечеров, понял, что продукт для моих задач годный, но хочется более привычный терминал и вообще некоторых удобств.
### Установка WSL и дистрибутива
Сразу оговорюсь, в интернете можно найти описание установки с помощью выполнения команды `lxrun /install` в командной строке или консоли PowerShell. Данный способ больше не работает (после выхода WSL в стабильный релиз). Насколько мне известно, сейчас WSL можно установить только из Microsoft Store вместе с предпочитаемым дистрибутивом.
Так же отмечу, что когда установку производил я, на выбор были доступны дистрибутивы OpenSUSE, SUSE Linux Enterprise и Ubuntu 16.04 — последний я и установил. Сейчас также доступны Ubuntu 18.04, Debian 9 и Kali Linux, возможно появятся и другие дистрибутивы. Действия по установке могут отличаться. Так же, часть проблем описанных в статье может быть уже исправлена.
Находим в магазине желаемый дистрибутив и устанавливаем. Установка пройдет быстро, так как скачает только эмулятор ядра Linux и утилиту для запуска подсистемы, которая окажется в системной папке в трех экземплярах: wsl.exe, bash.exe и ubuntu.exe (вместо ubuntu будет имя Вашего дистрибутива). Все они равнозначны и делают одно и то же — запускают собственный эмулятор терминала, в нем linux'овый bash работающий под эмулятором ядра. При первом же запуске нас попросят придумать логин и пароль для пользователя по умолчанию, а после произойдет непосредственно установка дистрибутива. В качестве пользователя по умолчанию указываем root без пароля — это потребуется для дальнейших шагов. Безопасность не пострадает, кроме того при подготовке материалов к статье, в англоязычном туториале, я наткнулся на информацию, что новые версии WSL теперь делают пользователем по умолчанию root без пароля без лишних вопросов.
Дожидаемся установки. Далее первым делом стоит обновить зеркала apt на ближайшие. Для этого понадобится CLI текстовый редактор. В комплекте только vi, я же больше предпочитаю nano, поэтому ставлю его:
```
apt install nano
```
sudo вводить не требуется, так как мы уже под root'ом. Отредактируем файл /etc/apt/sources.list:
```
nano /etc/apt/sources.list
```
У меня лучше всего работают зеркала Яндекса, поэтому мой файл выглядит так:
```
deb http://mirror.yandex.ru/ubuntu/ xenial main universe restricted
deb-src http://mirror.yandex.ru/ubuntu/ xenial main universe restricted
deb http://mirror.yandex.ru/ubuntu/ xenial-security main universe restricted
deb-src http://mirror.yandex.ru/ubuntu/ xenial-security main universe restricted
deb http://mirror.yandex.ru/ubuntu/ xenial-updates main universe restricted
deb-src http://mirror.yandex.ru/ubuntu/ xenial-updates main universe restricted
```
Нажимаем Ctrl+O для сохранения и Ctrl+X для выхода. Теперь можно обновить систему до актуального состояния:
```
apt update && apt upgrade
```
После обновления можно создать нашего основного пользователя. В данной статье я назову его user1, Вы же можете задать привычное имя:
```
addgroup --gid 1000 user1
adduser --home /home/user1 --shell /bin/bash --uid 1000 -G user1,sudo user1
```
Далее переходим в папку юзера, зайдем под ним, установим пароль и отредактируем файл ~/.bashrc:
```
cd /home/user1
su user1
passwd
nano .bashrc
```
**Мой базовый .bashrc выглядит так**
```
# If not running interactively, don't do anything
case $- in
*i*) ;;
*) return;;
esac
# don't put duplicate lines or lines starting with space in the history.
# See bash(1) for more options
HISTCONTROL=ignoreboth
# append to the history file, don't overwrite it
shopt -s histappend
# for setting history length see HISTSIZE and HISTFILESIZE in bash(1)
HISTSIZE=1000
HISTFILESIZE=2000
# check the window size after each command and, if necessary,
# update the values of LINES and COLUMNS.
shopt -s checkwinsize
# If set, the pattern "**" used in a pathname expansion context will
# match all files and zero or more directories and subdirectories.
#shopt -s globstar
# make less more friendly for non-text input files, see lesspipe(1)
[ -x /usr/bin/lesspipe ] && eval "$(SHELL=/bin/sh lesspipe)"
# set variable identifying the chroot you work in (used in the prompt below)
if [ -z "${debian_chroot:-}" ] && [ -r /etc/debian_chroot ]; then
debian_chroot=$(cat /etc/debian_chroot)
fi
# set a fancy prompt (non-color, unless we know we "want" color)
case "$TERM" in
xterm|xterm-color|*-256color) color_prompt=yes;;
esac
# uncomment for a colored prompt, if the terminal has the capability; turned
# off by default to not distract the user: the focus in a terminal window
# should be on the output of commands, not on the prompt
#force_color_prompt=yes
if [ -n "$force_color_prompt" ]; then
if [ -x /usr/bin/tput ] && tput setaf 1 >&/dev/null; then
# We have color support; assume it's compliant with Ecma-48
# (ISO/IEC-6429). (Lack of such support is extremely rare, and such
# a case would tend to support setf rather than setaf.)
color_prompt=yes
else
color_prompt=
fi
fi
if [ "$color_prompt" = yes ]; then
if [[ ${EUID} == 0 ]] ; then
PS1='${debian_chroot:+($debian_chroot)}\[\033[01;31m\]\h\[\033[01;34m\] \W \$\[\033[00m\] '
else
PS1='${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h\[\033[00m\] \[\033[01;34m\]\w \$\[\033[00m\] '
fi
else
PS1='${debian_chroot:+($debian_chroot)}\u@\h \w \$ '
fi
unset color_prompt force_color_prompt
# If this is an xterm set the title to user@host:dir
case "$TERM" in
xterm*|rxvt*)
PS1="\[\e]0;${debian_chroot:+($debian_chroot)}\u@\h \w\a\]$PS1"
;;
*)
;;
esac
# enable color support of ls and also add handy aliases
if [ -x /usr/bin/dircolors ]; then
test -r ~/.dircolors && eval "$(dircolors -b ~/.dircolors)" || eval "$(dircolors -b)"
alias ls='ls --color=auto'
#alias dir='dir --color=auto'
#alias vdir='vdir --color=auto'
alias grep='grep --color=auto'
alias fgrep='fgrep --color=auto'
alias egrep='egrep --color=auto'
fi
# colored GCC warnings and errors
#export GCC_COLORS='error=01;31:warning=01;35:note=01;36:caret=01;32:locus=01:quote=01'
# some more ls aliases
alias ll='ls -alF'
alias la='ls -A'
alias l='ls -CF'
# Add an "alert" alias for long running commands. Use like so:
# sleep 10; alert
alias alert='notify-send --urgency=low -i "$([ $? = 0 ] && echo terminal || echo error)" "$(history|tail -n1|sed -e '\''s/^\s*[0-9]\+\s*//;s/[;&|]\s*alert$//'\'')"'
# Alias definitions.
# You may want to put all your additions into a separate file like
# ~/.bash_aliases, instead of adding them here directly.
# See /usr/share/doc/bash-doc/examples in the bash-doc package.
if [ -f ~/.bash_aliases ]; then
. ~/.bash_aliases
fi
# enable programmable completion features (you don't need to enable
# this, if it's already enabled in /etc/bash.bashrc and /etc/profile
# sources /etc/bash.bashrc).
if ! shopt -oq posix; then
if [ -f /usr/share/bash-completion/bash_completion ]; then
. /usr/share/bash-completion/bash_completion
elif [ -f /etc/bash_completion ]; then
. /etc/bash_completion
fi
fi
```
Все, подсистема готова к использованию… почти...
### Установка X-сервера, Xfce и прочих GUI'шных приложений
Первая же проблема, на которую я натолкнулся — bash-completion в предлагаемом эмуляторе терминала работал, мягко говоря, некорректно. Кроме того, данный эмулятор не умеет вкладки, а каждый его экземпляр запускает все в новом пространстве процессов, с отдельным init'ом (который кстати не заменить). Мне захотелось нормальный эмулятор терминала, некоторых других GUI приложений, а так же панельку, чтоб это все быстро запускать.
Когда я гуглил этот вопрос, я наткнулся на множество проблем, вроде необходимости перевода dbus на tcp протокол. На данный момент всех этих проблем нет. В подсистеме нормально работают unix-domain-socket'ы и все спокойно общается через них.
Первым делом нам понадобится X-сервер, притом установленный в основную систему (в Windows). Лично я использую для этих целей VcXsrv — порт X11 на Windows. Официальный сайт указанный в about самой утилиты его сейчас не предоставляет, поэтому гуглим установщик и устанавливаем все по умолчанию.
Пока идет установка возвращаемся в терминал WSL, командой exit выходим обратно в root'а. Первым делом настроим русские локали:
```
locale-gen ru_RU
locale-gen ru_RU.UTF-8
update-locale
```
Далее установим некоторые компоненты Xfce. Можно конечно установить его целиком из мета-пакета, но большинство компонентов нам не понадобится, а модульная архитектура Xfce позволяет нам поставить только необходимое:
```
apt install -y xfce4-session xfce4-notifyd xfce4-appfinder xfce4-panel xfce4-quicklauncher-plugin xfce4-whiskermenu-plugin xfce4-xkb-plugin xfce4-settings xfce4-terminal xfce4-taskmanager mousepad
```
Запускать каждый раз окружение руками не очень удобно, поэтому я автоматизировал данный процесс. Для этого в основной системе создадим в удобном для нас месте папку, а в ней 3 файла для запуска:
1. **config.xlaunch** — файл настроек для VcXsrv
```
xml version="1.0" encoding="UTF-8"?
```
2. **x-run.vbs** — WSL всегда запускается со своим эмулятором терминала, если его закрыть — завершатся все его дочерние процессы. Чтоб данное окно не мозолило глаза, неплохо его запускать скрытым. К счастью в Windows встроен интерпретатор VBScript, который позволяет это сделать в одну строчку:
```
WScript.CreateObject("Shell.Application").ShellExecute "wsl", "cd /home/user1; DISPLAY=:0 LANG=ru_RU.UTF-8 su user1 -c xfce4-session", "", "open", 0
```
Поясню, что здесь происходит. Мы говорим VBscript выполнить приложение wsl с параметром `cd /home/user1; DISPLAY=:0 LANG=ru_RU.UTF-8 su user1 -c xfce4-session`, папка запуска нам не важна, поэтому пустая строка, действие open — запуск, 0 — скрытый режим. Самому wsl мы отдаем команду на выполнение: переход в папку пользователя, затем с установкой переменных окружения DISPLAY (дисплей X-сервера) и LANG (используемая локаль) мы запускаем xfce4-session от имени нашего пользователя user1 (благодаря команде su)
3. **start.bat** — batch файл для запуска, по желанию его можно засунуть в автозагрузку
```
start config.xlaunch
wscript x-run.vbs
```
Далее можем запустить наш start.bat и настроить панель Xfce под себя. Замечу, что здесь я наткнулся на еще одну проблему — панель прекрасно отображается поверх всех окон, но вот выделить себе место, как панель на рабочем столе Windows она не может. Если кто знает решение данной проблемы, поделитесь в комментариях.
Ну и под конец данной части, скриншот моего рабочего стола:
### Взаимодействие окружения Windows и окружения подсистемы Linux
Запускать Linux приложения напрямую из Windows можно через те же 3 команды — bash, wsl или ubuntu. Не забываем, что по умолчанию запуск идет от root, поэтому стоит понижать привилегии через `su`, так же нужно не забывать передавать переменную окружения DISPLAY=:0 если приложению требуется X-сервер. Так же нужно менять папку, из которой должно работать приложение, через cd внутри WSL. Пример, посчитаем md5 для file.txt на диске D средствами Linux'овой md5sum:
```
wsl md5sum < d:\file.txt
```
Доступ к файловой системе Linux так же имеется, лежит она в `%localappdata%\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs`. Читать таким образом файлы можно, а вот писать — не желательно, можно поломать файловую систему. Думаю проблема в том, что Windows не умеет работать с правами и владельцами файловой системы Linux.
Из Linux так же можно запускать Windows приложения. Просто запускаем exe-шник и он выполнится в основной системе.
Диски Windows монтируются в `/mnt` в соответствии со своими буквами в нижнем регистре. Например диск D будет смонтирован в `/mnt/d`. Из Linux можно свободно читать и писать файлы Windows. Можно делать на них симлинки. Права у таких файлов всегда будут 0777, а владельцем будет root.
Сетевой стек у подсистемы общий с Windows. Сервер поднятый в Linux будет доступен на localhost в Windows и наоборот. Однако unix-domain-socket для Windows будет просто пустым файлом, работать с этим можно только внутри Linux. Выход во внешнюю сеть у Linux так же есть, в том числе можно слушать порты, если этого не запрещает фаервол.
ifconfig в Linux и ipconfig в Windows выдают одинаковую информацию о сетевых интерфейсах.
Из диспетчера задач Windows можно спокойно прибить процесс внутри подсистемы Linux. Однако Linux увидит только свои процессы.
### Особенности, ограничения и подводные камни
Ядро Linux в WSL не настоящее. Это всего лишь прослойка-эмулятор, которая часть Linux-специфичных задач выполняет сама, а часть проксирует напрямую в ядро winNT. Большая часть api в нем реализована, но не все. Свое ядро собрать не получится, как и не получится подключить модули ядра (.ko, Kernel Object).
Init процесс у WSL тоже свой и заменить его, например, на system.d не выйдет. У меня давно есть желание написать менеджер демонов на go, который бы работал с файлами юнитов system.d и предоставлял бы схожий интерфейс, да все руки не доходят.
Нет поддержки openFUSE, соответственно примонтировать виртуальную или удаленную файловую систему не получится. Так же нельзя сделать mount из файла, mount вообще ничего кроме bind здесь, похоже, не умеет.
Так же нет никакой возможности разбить файловую систему Linux на несколько разделов/дисков.
Прямой доступ к железу практически отсутствует. Все таки мы находимся в песочнице Windows, а не в полноценном Linux. /dev и /sys заметно пустуют, в них лишь проц да виртуальные устройства. Доступ к GPU — только через X-сервер, напрямую — никак, так что нейросети обучать придется в Windows.
В JS разработке столкнулся с тем, что electron.js отказался запускаться в WSL, пришлось дублировать окружение node.js в Windows.
### Итоги
Статья получилась довольно длинной, надеюсь, что она окажется еще и полезной.
WSL для меня лично оказался инструментом вполне юзабельным, решающим мои задачи ~~fullstack~~ backend разработчика. Виртуалка с Linux за полгода так и не понадобилась. По общим ощущениям Windows+WSL намного функциональнее, чем Linux+Wine.
Пока писал статью, обнаружил, что в Microsoft Store появилась сборка WSL с Debian 9.3, данный дистрибутив мне более симпатичен, чем Ubuntu, поэтому буду пробовать ставить. | https://habr.com/ru/post/412633/ | null | ru | null |
# SSR: когда, зачем и для чего. На примере Vue
([*Иллюстрация*](http://vk.com/phkdesign))
~~Once upon a time~~ Несколько лет назад, когда я только начинал работать с вебом на Java, мы работали с JSP. Вся страница генерировалась на сервере и отправлялась клиенту. Но потом встал вопрос о том, что ответ приходит слишком долго…
Мы начали использовать подход, при котором отдается пустой темплейт страницы, а все данные уже постепенно подгружались Аяксом. Все были счастливы, странички показывались. Пока мы не поняли, что наделали себе за шиворот, так как CSR отрицательно сказывается на поисковой оптимизации и производительности на мобильных устройствах. Но потом я снова услышал про поддержку SSR JS-фреймворками.
**И что же получается, история повторяется?**
**Какие есть принципы работы SSR?**
1. Prerendering. В простейшем случае генерируется N HTML-файлов, которые кладутся на сервер и возвращаются как есть — то есть возвращается статика, во время запроса мы ничего не генерируем.
2. Как и в случае с JSP, на сервере генерируется полный HTML со всем контентом и возвращается клиенту. Но, чтобы не генерировать страницу на каждый запрос (коих может быть миллион и наш сервер загнется), давайте добавим кэш прокси. Например, варниш.
**Когда может быть применим каждый из этих способов:**
1. Когда имеет смысл генерировать пачку HTML-файлов? Очевидно, в том случае, когда данные на сайте меняются чуть реже чем никогда. Например, корпоративный сайт ларька по ремонту обуви, что за углом (да-да, тот дяденька, который меняет набойки в ларьке 2х2 метра, тоже захотел сайт фирмы — и, конечно же, со страницей миссии компании). Для такого сайта вообще не надо заморачиваться на предмет фреймворков, SSR и прочих свистелок, но это сферический пример. Что делать, если у нас блог, в котором 1к постов? Иногда мы их актуализируем, иногда добавляем новые. Сгенерировать 1к+ статичных файлов… Что-то не то. А если мы изменяем пост, то надо перегенерировать определенный файлик. Хм…
2. И вот тут нам подходит второй способ. Где мы генерируем первый раз на лету, а потом кэшируем ответ в проксирующем сервисе. Время кэширования может быть час/два/день — как угодно. Если у нас 10 000 заходов в час на пост (невероятно, правда?), то только первый запрос дойдет до сервера. Остальные получат в ответ кэшированную копию, и наш сервер с большей вероятностью будет жить. В случае обновления какого-то поста нам просто нужно сбросить закэшированную запись, чтобы по следующему реквесту сгенерировалась уже актуальная страница.
От слов к делу:
===============
Hello world repo.
0) generate hello world
Для быстрого старта сообщество Nuxt подготовило [базовые темплейты](https://github.com/nuxt-community?utf8=%E2%9C%93&q=template&type=&language=), установить любой из них можно командой:
```
$ vue init
```
По умолчанию предлагается started-template, его и возьмем для нашего примера. Хотя в реальном приложении мы выбрали express-template. Назовем проект незамысловато:
```
$ vue init nuxt-community/starter-template habr-nuxt-example
$ cd habr-nuxt-example
$ yarn # или npm install, как будет угодно
$ yarn dev
```
~~Вжух~~, мы сгенерировали hello world. Перейдя по урлу, можно увидеть сгенерированную страницу:
1) Webpack и Linting
Nuxt из коробки имеет настроенные вебпак с поддержкой ES6 (babel-loader), Vue однофайловые компоненты (vue-loader), а также SCSS, JSX и прочее.
Если этих возможностей недостаточно, конфиг вебпака можно расширить. Идем в nuxt.config.js, и в build.extend мы имеем возможность модифицировать конфиг.
Для примера добавим линтинг стилей по аналогии с линтингом кода — важный, на наш взгляд, пункт, для поддержания единообразной кодовой базы. Это хорошая привычка, которая поможет избежать многих подводных камней.
Пример расширения конфига (подключение конфиг-файла для дева на основе переменной окружения):
```
config.plugins.push(
new StylelintPlugin({
files: [
'**/*.vue',
'assets/scss/**/*.scss'
],
configFile: './.stylelintrc.dev.js'
})
)
```
Остальные изменения можно посмотреть в репо по [тегу](https://github.com/umbrellaitcom/habr-nuxt-example/releases/tag/stylelint), эти изменения помогут нам держать стили в порядке.
И пример конфиг-файла линтера: используем Standard JS, как общепринятое в Vue/Nuxt решение:
```
...
extends: [
- 'plugin:vue/essential'
+ 'standard',
+ 'plugin:vue/recommended'
],
…
```
2) Для примера работы с данными будем использовать [вот это API](https://jsonplaceholder.typicode.com/):
Подключим Axios как плагин, создаем новый файл в директории plugins:
```
import * as axios from 'axios'
let options = {}
// The server-side needs a full url to works
if (process.server) {
options.baseURL = `http://${process.env.HOST || 'localhost'}:${process.env.PORT || 3000}`
}
export default axios.create(options)
```
И пример использования:
```
import axios from '~/plugins/axios'
export default {
async asyncData ({ params }) {
const { data } = await axios.get('https://jsonplaceholder.typicode.com/posts')
return { data }
}
}
```
Остальное в репе по [тегу](https://github.com/umbrellaitcom/habr-nuxt-example/releases/tag/getting-data).
Цифры загрузки:
1) SSR + Varnish
Первый запрос:
Второй:
2) No-ssr
Второй реквест с фастли
Пустая страница пришла быстро, но потребовалось 2 секунды на то, чтобы сгенерировать на ней контент.
Conclusion
==========
Что в итоге? Мы разобрались, как получить минимально сконфигурированное запускаемое SSR-приложение. Добавили Linting для сохранения стиля кода с самого начала жизни проекта, а также обозначили общую архитектуру. Можно писать свой гугол.
 | https://habr.com/ru/post/425053/ | null | ru | null |
# Свой мессенджер Matrix-synapse в связке с Jitsi-meet. Часть 3
Всем Приветь. Как вы уже обратили внимание, порядок публикации нарушен. Изначально планировалось выпустить эту статью в качестве третьей части цикла, однако она стала второй. Это объясняется тем, что поднять один новый сервер для Matrix дешевле, чем несколько для высоконагруженного сервиса Jitsi-meet. Без паники, все будет. А пока займемся Matrix.
Сразу хочу отметить тот факт, что данный мануал не является полностью моим. Это перевод [оригинального](https://matrix.org/blog/2020/04/06/running-your-own-secure-communication-service-with-matrix-and-jitsi#jitsi) мануала разработчиков с моими дополнениями и адаптацией. И вошел он в данную серию статей, ибо связан с jitsi-meet (ну или их можно связать вместе).
Прежде чем мы погрузимся в команды, конфигурацию и "танцы" поговорим немного на тему "а зачем и кому это надо"....
А зачем и кому это надо...
--------------------------
Причин может быть много: от личной паранойи до требований безопасности в компании. Matrix-synapse - это мессенджер, который вы можете не только скачать или открыть в браузере, пройти регистрацию и общаться, но и поднять собственный сервер, установить на него серверную часть matrix, а потом общаться в нем с полной уверенностью, что ваша переписка не только шифруется, но и хранится не у кого-то, а у вас на сервере. Если уж совсем паранойить, то все это можно запихуть в VPN и доступ к серверу будет только у тех, у кого есть подключение к VPN (тут мы такое рассматривать не будем, а настроим только matrix в связке с jitsi).
В [прошлой статье](https://habr.com/ru/post/512236/) мы уже настроили два сервера: jitsi-meet - для видеоконференций и jibri - для записи и/или трансляции этих видеоконференций. Сейчас мы будем расширять наши возможности. Мы поднимем сервер со своим мессенджером и привяжем его к нашему jitsi, дабы совершать видеовызовы через него.
Сервера поднимал [тут](https://vdsina.ru/?partner=q12vzdd5w7).
Команды, конфигурация и "танцы".Я все делаю на debian 9, если это противоречит вашим религиозным взглядам, то использованные тут команды подстраивайте под свою ОС. Если вы хотите, то можете поднимать Matrix на том же сервере, где у вас поднят Jitsi-meet или на отдельном: этот мануал подойдет для обоих вариантов.
Начнем мы с того, что создадим DNS записи. Нам понадобится их три: dnsname.com, matrix.dnsname.com и riot.dnsname.com - на IP нашего сервера.
### Веб-сервер и SSL
Я использовал nginx для jitsi и не буду отходить от своей традиции и буду настраивать его и для matrix.
Если nginx еще не установлен, то:
```
# apt update
# apt install nginx -y
```
Если nginx установлен, то создаем конфигурацию (скопируем default и перенастроим):
```
# cd /etc/nginx/sites-available
# cp default dnsname.com
```
Теперь редактируем конфигурацию:
```
# vim dnsname.com
```
И меняем следующие директивы:
```
server_name dnsname.com;
...
root /var/www/dnsname.com;
```
Сохраняем и закрываем.
Тоже самое делаем для riot.dnsname.com:
```
# vim riot.dnsname.com
server_name riot.dnsname.com;
...
root /var/www/riot.dnsname.com/riot;
```
Конфигурацию matrix.dnsname.com приводим к следующему виду:
```
# vim matrix.dnsname.com
server {
# редактируем этот блок
server_name matrix.dnsname.eu;
root /var/www/dnsname.eu;
index index.html;
location / {
proxy_pass http://localhost:8008;
}
....
```
Теперь пора заняться SSL сертификатами. Мы создадим и подпишем бесплатные трехмесячные сертификаты Let's Encrypt. Для этого делаем следующее:
```
# apt install -y python3-certbot-nginx
# certbot --nginx -d dnsname.com -d riot.dnsname.com -d matrix.dnsname.com
```
Этой же командой спустя три месяца можно продлить сертификаты.
Теперь нужно включить виртуальные хосты и перезагрузить nginx:
```
# ln -s dnsname.com /etc/nginx/sites-enable/
# ln -s matrix.dnsname.com /etc/nginx/sites-enable/
# ln -s riot.dnsname.com /etc/nginx/sites-enable/
# systemctl restart nginx
```
### Matrix-synapse и Postgresql
Из коробки Matrix использует SQLite - при малом количестве пользователей этого достаточно, однако рекомендуется использовать Postgresql (я настоятельно рекомендую сразу начать использовать Postgresql). Для тех, кто просто хочет "пощупать" Matrix, этот шаг можно пропустить, ну а мы, все же, сразу поставим Postgresql, ибо миграция c SQLite на Postgresql - в некоторых случаях может стать теми еще "танцами". Поехали...
Переходим к установке matrix.
```
# apt install -y lsb-release wget apt-transport-https
# wget -O /usr/share/keyrings/matrix-org-archive-keyring.gpg https://packages.matrix.org/debian/matrix-org-archive-keyring.gpg
# echo "deb [signed-by=/usr/share/keyrings/matrix-org-archive-keyring.gpg] https://packages.matrix.org/debian/ $(lsb_release -cs) main" |
tee /etc/apt/sources.list.d/matrix-org.list
# apt update
# apt install matrix-synapse-py3 -y
```
В процессе установки будет запрошено DNS имя - указываем dnsname.com.
Устанавливаем Postgresql, создаем пользователя и БД для matrix-synapse:
```
# apt install postgresql postgresql-contrib -y
# su - postgres
# psql
postgres=# \password postgres
postgres=# \q
# createuser --pwprompt synapse_user
# psql
postgres=#CREATE DATABASE synapse
postgres-# ENCODING 'UTF8'
postgres-# LC_COLLATE='C'
postgres-# LC_CTYPE='C'
postgres-# template=template0
postgres-# OWNER synapse_user;
postgres=# \q
# exit
```
```
# cp /etc/matrix-synapse/homeserver.yaml /etc/matrix-synapse/homeserver.yaml.back
# cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 32 | head -n 1
```
Открываем конфигурационный файл Matrix:
```
# vim /etc/matrix-synapse/homeserver.yaml
```
Находим строку #server*name: "server*name" и меняем значение на "dnsname.com", убираем "#", тоже самое делаем со строкой #registration\_shared\_secret: "UIBfgsjkdfhj3568JHGIUIEBfy3764JH" и вставляем в кавычках ключ, который мы получили ранее. Дальше ищем опцию `#enable_registration: false, убираем "#" и меняем false на true`
Так же находим блок database снимаем "#" и подставляем свои значения:
```
database:
name: psycopg2
args:
user: synapse-user
password: password
database: synapse
host: localhost
cp_min: 5
cp_max: 10
```
А блок database, где прописана SQLite (она ниже) - комментируем (ставим "#").
Далее идем и вставляем строку `host synapse synapse_user ::1/128 md5`как у меня:
```
# vim /etc/postgresql/9.6/main/pg_hba.conf
...
# "local" is for Unix domain socket connections only
local all all peer
# IPv4 local connections:
host all all 127.0.0.1/32 md5
host synapse synapse_user ::1/128 md5
# IPv6 local connections:
host all all ::1/128 md5
...
```
`Перезапускаем Matrix и Postgresql:`
```
# systemctl restart postgresql
# systemctl enable postgresql
# systemctl restart matrix-synapse
# systemctl enable matrix-synapse
```
Зарегистрируем пользователя с правами администратора:
```
# register_new_matrix_user -c /etc/matrix-synapse/homeserver.yaml http://localhost:8008
```
Будут запрошены данные: логин, пароль и права администратора.
Если у вас уже работает Matrix с SQLite, то можно мигрировать на Postgresql. Для этого нам надо сделать копию homeserver.yaml, сделать две копии homeserver.db (одну мы сохраним для "потомков", ну или если что-то пойдет не туда, а со второй будем работать). Подправить конфиг, мигрировать и перезагрузиться сервисы.
```
# cp /etc/matrix-synapse/homeserver.yaml /etc/matrix-synapse/homeserver-postgresql.yaml
# chown matrix-synapse:nogroup /etc/matrix-synapse/homeserver-postgresql.yaml
```
Теперь с файлом homeserver-postgresql.yaml надо сделать [это](#db).
Останавливаем Matrix:
```
# systemctl stop matrix-synapse
```
Далее копируем базы и мигрируем.
```
# cp /var/lib/matrix-synapse/homeserver.db /etc/matrix-synapse/homeserver.db.snapshot
# chown matrix-synapse:nogroup /etc/matrix-synapse/homeserver.db.snapshot
# cp /var/lib/matrix-synapse/homeserver.db /tmp/
# cd /etc/matrix-synapse/
# synapse_port_db --curses --sqlite-database homeserver.db.snapshot --postgres-config /etc/matrix-synapse/homeserver-postgresql.yaml
# mv homeserver.yaml homeserver-old-sqlite.yaml
# mv homeserver-postgresql.yaml homeserver.yaml
# systemctl restart postgresql
# systemctl start matrix-synapse
```
Если остались какие-то вопросы, то можно посмотреть [сюда](https://github.com/matrix-org/synapse/blob/develop/docs/postgres.md).
Так же можно рассказать всем пользователям Matrix о своем сервере, но я не буду тут это расписывать, а дам [ссылку](https://matrix.org/blog/2020/04/06/running-your-own-secure-communication-service-with-matrix-and-jitsi#jitsi), где можно это посмотреть.
Теперь мы можем перейти в браузере по адресу https://matrix.dnsname.com и увидеть, что это работает.
Осталось совсем немного и мы сможем погрузиться в мир "черт, как же это все работает....".
Мы уже сделали виртуальный хост riot.dnsname.com и указали директорию /var/www/riot.dnsname.com/riot;, однако такой директории еще нет. Давайте ее создадим и загрузим туда веб-приложение Riot (Element) из [git](https://github.com/vector-im/element-web/releases):
```
# mkdir /var/www/riot.dnsname.com
# cd /var/www/riot.dnsname.com
# wget https://github.com/vector-im/element-web/releases/download/v1.7.23/element-v1.7.23.tar.gz
# apt install -y gnupg
# wget https://github.com/vector-im/element-web/releases/download/v1.7.23/element-v1.7.23.tar.gz.asc
# gpg --keyserver keyserver.ubuntu.com --search-keys releases@riot.im
# wget https://packages.riot.im/riot-release-key.asc
# gpg --import riot-release-key.asc
# gpg --verify element-v1.7.23.tar.gz.asc
# tar -xzvf element-v1.7.23.tar.gz
# ln -s element-v1.7.23 riot
# chown www-data:www-data -R riot
# cd riot
# cp config.sample.json config.json
```
Далее нам надо привести содержимое конфигурационного файла config.json к следующему виду (меняем "base\_url": "[https://matrix.dnsname.com"](https://matrix.profsupport.eu), "server\_name": "[dnsname.com](https://matrix.profsupport.eu)", "jitsi": { "preferredDomain": "jitsi.dnsname.com" - последняя настройка свяжет наш matrix и jitsi):
```
# vim /var/www/riot.dnsname.com/riot/config.json
{
"default_server_config": {
"m.homeserver": {
"base_url": "https://matrix.dnsname.com",
"server_name": "dnsname.com"
},
"m.identity_server": {
"base_url": "https://vector.im"
}
},
"disable_custom_urls": false,
"disable_guests": false,
"disable_login_language_selector": false,
"disable_3pid_login": false,
"brand": "Element",
"integrations_ui_url": "https://scalar.vector.im/",
"integrations_rest_url": "https://scalar.vector.im/api",
"integrations_widgets_urls": [
"https://scalar.vector.im/_matrix/integrations/v1",
"https://scalar.vector.im/api",
"https://scalar-staging.vector.im/_matrix/integrations/v1",
"https://scalar-staging.vector.im/api",
"https://scalar-staging.riot.im/scalar/api"
],
"bug_report_endpoint_url": "https://element.io/bugreports/submit",
"defaultCountryCode": "GB",
"showLabsSettings": false,
"features": {
"feature_new_spinner": false
},
"default_federate": true,
"default_theme": "light",
"roomDirectory": {
"servers": [
"matrix.org"
]
},
"piwik": {
"url": "https://piwik.riot.im/",
"whitelistedHSUrls": ["https://matrix.org"],
"whitelistedISUrls": ["https://vector.im", "https://matrix.org"],
"siteId": 1
},
"enable_presence_by_hs_url": {
"https://matrix.org": false,
"https://matrix-client.matrix.org": false
},
"settingDefaults": {
"breadcrumbs": true
},
"jitsi": {
"preferredDomain": "jitsi.dnsname.com"
}
}
```
Осталось только перезагрузить службы (или сервер целиком):
```
# systemctl restart nginx
# systemctl restart matrix-synapse
```
### Регистрация и чаты
Осталось понять, как этим пользоваться. Я не буду детально обрисовывать использование, а расскажу, как зарегистрироваться, установить приложение, добавить "друга по переписке". Поехали:
Переходим в браузере на https://riot.dnsname.com
Создаем аккаунт.
Меняем домашний сервер. Придумываем логин и пароль. Дальше надо будет создать ключи шифрования, просто следуйте инструкциям riot.
Искать пользователя надо в данном формате.
### Обновление Riot
Периодически [тут](https://github.com/vector-im/element-web/releases) выкатывают обновления серверной части Riot. Обновиться очень просто. Идем на Гит (ссылка выше) и берем там ссылки необходимой версии релиза, а именно нам нужны element-vx.x.xx.tar.gz и element-vx.x.xx.tar.gz.asc. Далее идем:
```
# cd /var/www/riot.dnsname.com/
# wget https://github.com/vector-im/element-web/releases/download/vx.x.xx/element-vx.x.xx.tar.gz
# wget https://github.com/vector-im/element-web/releases/download/vx.x.xx/element-vx.x.xx.tar.gz.asc
# gpg --keyserver keyserver.ubuntu.com --search-keys releases@riot.im
# wget https://packages.riot.im/riot-release-key.asc
# gpg --import riot-release-key.asc
# gpg --verify element-vx.x.xx.tar.gz.asc
# tar -xzvf element-vx.x.xx.tar.gz
# rm riot
# ln -s element-vx.x.xx riot
# chown www-data:www-data -R riot
# cd riot
# cp config.sample.json config.json
```
Теперь надо обновить файл конфигурации как мы делали ранее [тут](#1).
[Репозиторий](https://github.com/vector-im/element-web/releases) с релизами Riot.
Клиентское приложение [element](https://element.io/get-started).
[Свой сервер видеоконференций Jitsi. Часть 1](https://habr.com/ru/post/512236/)
[Jitsi-meet: авторизация по JWT-токену](https://habr.com/ru/company/timeweb/blog/666156/) | https://habr.com/ru/post/540894/ | null | ru | null |
# Как мы пытались с NoSQL работать как с SQL с помощью Hibernate и Apache Phoenix
TL;DR;
------
Мы хотели реализовать пагинацию, и для этого нам пришлось форкнуть диалект для Hibernate.
В тот день ничего не предвещало *~~еды~~ ~~беды~~* увлекательных приключений. Всё началось с сообщения в *~~файлообменнике~~* Skype.
“Мы будем делать новый проект!” - говорили они. “Там всё просто.” - говорили они.
Наши приключения начались в тот момент, когда мы узнали, что у заказчика есть определенный стек, в который требуется вписать новый проект. Ядро стека составляли известные слова на букву “ха”: Hadoop, HBase, Hive. Добавьте сюда немного Kafka и так любимых в мире enterprise “гибких и готовых к использованию” интеграционных решений.
Начало
------
Итак, нашей команде предстояло реализовать проект на технологиях, которые мы впервые видим, но, ничего, [мы же эксперты](https://youtu.be/UoKlKx-3FcA). Нам нужно было изучить две NoSQL СУБД (Hive и HBase) и выбрать наиболее подходящее. В итоге остановились на HBase + Apache Phoenix. Почему:
1. Hive оказался медленным для наших задач
2. Hive поддерживал транзакционность очень слабо
3. HBase быстр, но пользоваться им напрямую нам показалось неудобным
4. Apache Phoenix добавлял SQL интерфейс к NoSQL (HBase)
5. Apache Phoenix поддерживал транзакционность
Расплата
--------
Самое основное:
1. Apache Phoenix не поддерживает создание view на несколько таблиц ಠ\_ಠ
2. Нет ограничений по уникальности (кроме первичного ключа)
3. Внешние ключи тоже не поддерживает ¯\\_(ツ)\_/¯
При чем тут Hibernate
---------------------
Мы решили пойти легким (как нам тогда казалось) путем и использовать стандартный подход для работы с базой данных: Spring Data / Hibernate диалект для СУБД. Найти диалект для Apache Phoenix оказалось подозрительно легко. [Jorge Ruesga](https://github.com/jruesga) разработал диалект и опубликовал его на [Github](https://github.com/jruesga/phoenix-hibernate-dialect). Мы взяли диалект и пошли фигачить CRUD запросы.
Работа на полчаса
-----------------
Сначала всё шло хорошо. А хорошо - потому что мы брали по одной сущности или сразу все сущности из таблицы. Сюрприз поджидал нас в один из пятничных вечеров. Ну знаете, в такие вечера, в которые ты уже более менее расслабился и думаешь, что скоро спокойно пойдешь домой, потому что тут работы на полчаса.
Всё началось с того, что мы захотели доставать не все данные из таблицы, а часть. Короче говоря, реализовать стандартную пагинацию.
“Ну что может быть сложного?” - спросите вы. Вот и мы так думали. Просто берешь и делаешь что-то типа такого:
```
public interface UserRepository extends CrudRepository {
Page find(Pageable pageable);
}
```
И всё должно работать. Ну ведь да? Все мы знаем, что под капотом этого метода формируется запрос с OFFSET и LIMIT. Но что, если я вам скажу, что в итоговом запросе OFFSET и LIMIT перепутаны местами?
True изменения
--------------
Как и все другие интересные истории про задачи “на полчаса” наша задача казалась нам какой-то мелочью, которую можно поправить “на раз-два взяли”. Скажу лишь, что в итоге мы потратили на нее почти пять часов, прежде чем до нас дошло, что что-то идет не так.
Оказалось, что чудесный Hibernate использует специальный класс при формировании конструкции с OFFSET и LIMIT: [LimitHandler](https://docs.jboss.org/hibernate/orm/5.2/javadocs/org/hibernate/dialect/pagination/LimitHandler.html). А наш не менее чудесный диалект реализует этот класс таким образом, что в итоге значения для OFFSET и LIMIT оказываются перепутаны.
В итоге, чтобы это поправить нам пришлось форкнуть этот диалект, дописав в него всего несколько строк:
```
@Override
public boolean bindLimitParametersInReverseOrder() {
return true;
}
```
Итог
----
Мы хотели реализовать пагинацию и для этого нам пришлось форкнуть диалект для Hibernate. | https://habr.com/ru/post/533724/ | null | ru | null |
# WebRTC стриминг в виртуальной реальности и вокруг нее
Виртуальная реальность нынче на пике моды. Оборудование, что во времена "Газонокосильщика" было уделом ~~сумасшедших ученых~~ гиков с большими деньгами ~~от Минобороны~~, сейчас и простому человеку по карману, а те, у кого карман совсем пуст, могут собрать VR-гарнитуру из картона и смартфона по множеству рецептов.
И пользы VR может принести гораздо больше. чем 3-4-5-6-7-далее-по-вкусу-D кинотеатр. Допустим, Вы проживаете в Москве и хотите вложить честно заработанные ресурсы в самую твердую из валют — недвижимость где-нибудь на берегу Средиземного моря. Как известно, выбирать жилье лучше на месте и самостоятельно, но что, если Вы не можете уделить этому достаточно времени? Вот здесь и нужна виртуальная реальность. Представьте: агент устанавливает специальную камеру в комнате, и Вы, не сходя с любимого кресла, можете эту комнату осмотреть, покрутить головой и даже на потолок с плафоном 18 века "Греческие боги предаются ~~разврату~~ отдохновению" глянуть!
Затем, все так же не сходя с места, Вы интересуетесь, а чему же предаются Ваши чада в детском саду? И снова: камера в игровой комнате, и Вы с эффектом присутствия можете осмотреть все углы, куда Ваши чада ~~расставлены~~ прячутся.
Ну а мы разберемся, как сделать, чтобы в подобных случаях все работало, и ~~риэлтеры~~ дети не успели разбежаться.
Нюансы VR-картинки
------------------
*"Василий Иванович, объясните, что же такое нюанс?"*
*"Видите ли, Петр..."*
Из диалога двух выдающихся джентльменов
Технически, VR-медиапоток не отличается от обыкновенного: дорожка видео плюс дорожка аудио. Но есть нюанс.
VR-поток предполагает стерео-картинку. Специальная камера смотрит в мир двумя широко, на 180 градусов, открытыми ~~глазами~~ объективами, примерно, как этот робот
картинки склеиваются в один кадр,
поэтому на устройстве зрителя должен работать специальный плеер, который из двух картинок сделает одну. Как видно, соотношение сторон кадра составляет 2:1, по FullHD картинке на каждый глаз.
Нюансы VR-трансляции
--------------------
*Да-да-да, могу все мели*
*Счесть, как пальцы на руке*
Песенка из классического кино
Итак, речь идет о трансляции 4K потоков с высоким битрейтом. Что у нас есть? А есть у нас RTMP и WebRTC.
RTMP — ~~дешево,~~ надежно и практично. Под капотом использует TCP, что полезно при не очень хороших каналах. Есть разнообразные программные решения для публикующего клиента, как платные, так и бесплатные. Но, при всех достоинствах, RTMP дает высокие задержки. В одной из предыдущих статей мы отмечали задержку в 2-3 секунды для потока 720p. В каких-то случаях задержки приемлемы, но виртуальность будет уже немного отставать от реальности, и дети уже успеют разбежаться.
WebRTC — стильно, модно, молодежно. При хороших каналах задержки измеряются миллисекундами, реальность останется реальностью. Но есть нюансы.
Во-первых, по умолчанию WebRTC бегает поверх UDP, что при малейших ухудшениях качества канала приводит к потерям. А для 4K потока любой чих на канале — уже ухудшение. С этим можно справиться, перейдя на TCP транспорт, но дальше нас подстерегает...
Во-вторых, WebRTC транслируется из браузера, а мы с вами знаем, какой браузер сейчас самый популярный на планете (спойлер — давно не IE6). И в этом популярном браузере, причем на уровне движка, зашит максимальный битрейт публикации 2500 кбит/с. Этого вполне достаточно ~~по мнению Google~~ для FullHD, но маловато для 4K, и если битрейт не разогнать до 5 — 10 Мбит/с, зрители увидят вместо виртуальной реальности движущиеся акварельные пятна. К счастью, есть специальные настройки для разгона битрейта, которые работают в~~о всех~~ большинстве браузеров на движке Chromium. Затем, преодолев это препятствие, мы упремся...
В третьих, мы упремся в пропускную способность каналов. Чтобы публиковать и играть VR-картинку, при упомянутом выше битрейте клиенту потребуются каналы от 20 Мбит, а лучше от 50, а еще лучше от 100 Мбит, причем в обе стороны — и на загрузку, и на выгрузку. Причем это должны быть не те параметры, о которых рассказывает провайдер в рекламных буклетах, а реальная пропускная способность от клиента до сервера. Кстати, здесь можно прочитать, как ее можно [измерить без iperf и знания командной строки](https://flashphoner.com/indikator-kachestva-kanala-servernogo-webrtc-cherez-tcp/?lang=ru). На стороне сервера, таким образом, желательно иметь 10 Гбит, если рассчитывать на большое количество потоков.
Ну и в четвертых, что следует из требований к каналам. Транскодирование 4K потока займет слишком много ресурсов процессора на сервере. Поэтому нужно либо выбирать царь-сервер, что накладно по бюджету, либо использовать кодирование на видеокартах, что также весьма затратно, либо избегать транскодирования. То есть ни в коем случае не менять разрешение, частоту кадров и битрейт потоков при трансляции.
Итак, все мели сочтены, теперь
Давайте попробуем
-----------------
*Что тут думать, трясти надо!*
Персонаж из детского мультика
Возьмем:
* специальную камеру
* специальный плеер
* сервер, умеющий [транслировать WebRTC из браузера](https://flashphoner.com/brauzernaya-translyaciya-s-veb-kamery/?lang=ru)
Устанавливаем камеру на столе или штативе
Подключаем к ПК по USB 3.0 с питанием 1A, как для внешних дисков
Надо сказать, камера весьма чувствительна к оборудованию, и если на ноутбуке 2 порта USB 3.0, с одним из них она вполне может отказаться работать. Кабель для подключения также должен быть не совсем китайским, все пины, предусмотренные стандартом, должны быть на месте. И даже при идеальном подключении, камера может выдавать помеху, как старый пузатый телевизор в грозу. Зато для Windows 10 драйверов не требуется, честный Plug-n-Play.
На стороне сервера установим необходимые границы битрейта
```
webrtc_cc_min_bitrate=5000000
webrtc_cc_max_bitrate=10000000
```
Откроем в браузере Chrome [страницу](https://demo.flashphoner.com:8888/client2/examples/demo/streaming/media_devices_manager/media_device_manager.html) примера, позволяющего выставить нужные параметры для захвата потока с камеры, и установим
* разрешение 3072x1536
* FPS 24 (при трансляции из браузера камера поддерживает только такой FPS)
* транспорт TCP
и настроим параметры SDP для того, чтобы браузер не резал нам ~~осетра~~ битрейт, на стороне клиента
```
x-google-max-bitrate=10000;x-google-min-bitrate=5000
```
или на стороне сервера (в этом случае настройки будут действовать для всех публикующих клиентов)
```
webrtc_sdp_min_bitrate_bps=5000000
webrtc_sdp_max_bitrate_bps=10000000
```
Опубликуем поток с камеры
Теперь попробуем проиграть поток обычным WebRTC плеером
Все хорошо… Почти. Виртуальность какая-то не совсем виртуальная. Что ж, теперь играем этот же поток в специальном плеере, внедренном на страницу
Так гораздо лучше (и котики есть). Если играть поток на мобильном устройстве или в VR-очках, можно покрутить головой, а мы в браузере на ПК покрутим мышкой. Где-то в этой комнате спрятался ребенок. Посмотрим налево
Теперь направо
И вверх
А где же малыш? Да вот он, за шторкой прячется. Но котик все видит!
Кода, нужно больше кода!
------------------------
На стороне клиента кода немного.
Публикуем поток со страницы браузера
```
session.createStream({
name: streamName,
display: localVideo,
cacheLocalResources: true,
transport: "TCP",
sdpHook: rewriteSdp,
constraints: {
audio:true,
video: {
width: 3072,
height: 1536,
frameRate: 24
}
}
}).publish();
```
Функция замены параметров SDP браузера
```
function rewriteSdp(sdp) {
var sdpStringFind = "a=fmtp:(.*) (.*)";
var sdpStringReplace = "a=fmtp:$1 $2;x-google-max-bitrate=10000;x-google-min-bitrate=5000";
var newSDP = sdp.sdpString.toString();
newSDP = newSDP.replace(new RegExp(sdpStringFind,"g"), sdpStringReplace);
return newSDP;
}
```
Пример страницы с VR-плеером
```
WebRTC Delight
\
Play
Stop
Flashphoner.init({flashMediaProviderSwfLocation: '../../../../media-provider.swf'});
var SESSION\_STATUS = Flashphoner.constants.SESSION\_STATUS;
var STREAM\_STATUS = Flashphoner.constants.STREAM\_STATUS;
var STREAM\_STATUS\_INFO = Flashphoner.constants.STREAM\_STATUS\_INFO;
var playBtn = document.getElementById('playBtn');
var display = document.getElementById('display');
var dl8video = null;
var url = setURL();
document.addEventListener('x-dl8-evt-ready', function () {
dl8video = document.getElementById('remoteVideo');
$('#playBtn').prop('disabled', false).click(function() {
playStream();
});
});
function playStream() {
$('#playBtn').prop('disabled', true);
$('#stopBtn').prop('disabled', false);
var video = dl8video.contentElement;
Flashphoner.createSession({urlServer: url}).on(SESSION\_STATUS.ESTABLISHED, function (session) {
var session = Flashphoner.getSessions()[0];
session.createStream({
name: document.getElementById('playStream').value,
display: display,
remoteVideo: video,
transport: "TCP"
}).on(STREAM\_STATUS.PLAYING, function (stream) {
dl8video.start();
$('#stopBtn').prop('disabled', false).click(function() {
$('#playBtn').prop('disabled', false);
$('#stopBtn').prop('disabled', true);
stream.stop();
dl8video.exit();
});
}).play();
})
}
```
Обычно при создании стрима для плеера (вызов `session.createStream()`) мы передаем div-элемент, в который будет вмонтирован video-элемент для воспроизведения стрима по WebRTC. Но VR-плеер использует свой video-элемент, и нам нужно каким-то образом пробросить его в код используемого API. Для этого мы напрямую передаем video-элемент стороннего плеера в функцию session.createStream() параметром `remoteVideo`
В качестве серверной части используется demo.flashphoner.com, примеры веб-приложений доступны в подвале по ссылкам.
Удачи в осмотре на месте, не сходя с места!
Ссылки
------
1. [Индикатор качества канала серверного WebRTC через TCP](https://flashphoner.com/indikator-kachestva-kanala-servernogo-webrtc-cherez-tcp/?lang=ru) — Контроль качества каналов от клиента до сервера
2. [Видеотрансляции с веб-камеры браузера или мобильного устройства](https://flashphoner.com/brauzernaya-translyaciya-s-veb-kamery/?lang=ru) — WebRTC стриминг из браузера
3. [Документация по использованию WCS совместно с VR-плеером](https://docs.flashphoner.com/pages/viewpage.action?pageId=9241519)
4. [WCS](https://flashphoner.com) — сервер для передачи VR 360 видео по WebRTC | https://habr.com/ru/post/481698/ | null | ru | null |
# svn + bash = пишем консольный svn браузер
Для тех кто пользуется svn в командной строке, а так же для тех кто интересуется программированием bash-скриптов, в топике рассмотрен пример написания интерактивного bash-скрипта «svn-браузера», работающего в терминале и позволяющего делать несколько «ежедневных» операций с деревом репозитория, а именно:* Серфить по репозиторию
* Просматривать логи
* Копировать директории для создания tags/branchs
* Создавать/удалять/переименовывать директории
* Извлекать/экспортировать (checkout/export)
При этом любая операция делается нажатием одной-двух кнопок, не считая ввода комментариев, и не требует помнить/вводить длинные пути, такие как:
```
$svn cp "http://workserver.com/_main_repository/embedded_system/product_xxx/_trunk/main_task/ http://workserver.com/_main_repository/embedded_system/product_xxx/_tags/"
``` | https://habr.com/ru/post/104062/ | null | ru | null |
# Легко и просто проверяем Firefox с помощью PVS-Studio Standalone
Три года назад мы уже проверяли Mozilla Firefox с помощью анализатора PVS-Studio. Тогда это было неудобно и затруднительно. Для Firefox отсутствует проектный файл для Visual Studio. Сборка осуществляется с помощью make-файлов. Поэтому просто взять и проверить проект нельзя. Требовалось интегрировать PVS-Studio в систему сборки, что оказалось трудной задачей. В результате, как мне помнится, была проанализирована только часть проекта. Но всё поменялось, когда появился PVS-Studio Standalone. Теперь можно отследить все запуски компиляторов и легко проверить проект.
Mozilla Firefox
---------------
Думаю, рассказывать про Firefox нет необходимости. Однако, формат статьи требует всё-таки написать немного о проверенном проекте. Поленюсь и воспользуюсь [описанием](http://www.viva64.com/go.php?url=761) из Wikipedia:
Mozilla Firefox — свободный браузер на движке Gecko, разработкой и распространением которого занимается Mozilla Corporation. Третий по популярности браузер в мире и первый среди свободного ПО — в августе 2013 года его рыночная доля составила 19,26%. В браузере присутствует интерфейс со многими вкладками, проверка орфографии, поиск по мере набора, «живые закладки», менеджер закачек, поле для обращения к поисковым системам. Новые функции можно добавлять при помощи расширений.
Мы уже пытались проверить Firefox. Частично это нам даже удалось. По результатам проверки была написана статья "[Как уменьшить вероятность ошибки на этапе написания кода. Заметка N4](http://www.viva64.com/ru/a/0078/)". Сложность заключалась в том, что нужно вставить вызов command-line версии PVS-Studio в make-файлы. Сделать это в большом незнакомом проекте бывает затруднительно. Именно поэтому мы в дальнейшем не делали попыток перепроверить Firefox. Ситуация изменилась с появлением PVS-Studio Standalone.
PVS-Studio Standalone
---------------------
PVS-Studio Standalone может быть использован в 3 режимах:1. Удобная работа с файлом отчета (\*.plog), который содержит информацию о найденных ошибках на компьютере, где не установлен Visual Studio.
2. Проверка каким-либо образом препроцессированных \*.i файлов.
3. Отслеживание запуска компилятора и сбор всей необходимой информации для дальнейшей проверки файлов. Нам сейчас интересен именно этот режим работы.
Теперь не обязательно интегрировать command-line версию PVS-Studio в make-файлы. Можно проверить Firefox намного проще. Мы именно так и сделали. Последовательность действий:1. Запускаем программу PVS-Studio Standalone;
2. Выполняем команду «Compiler Monitoring»;
3. Компилируем проект Firefox;
4. Останавливаем процедуру слежения («Stop Monitoring»);
5. Запускается проверка файлов;
6. Изучаем предупреждения, выданные анализатором кода.
Более подробно, как использовать этот режим, можно прочитать [здесь](http://www.viva64.com/ru/b/0243/).
Результаты проверки Mozilla Firefox
-----------------------------------
Проект Firefox очень качественный. В добавок, как я понимаю, при его разработке уже применяются инструменты статического анализ кода: Coverity и Klocwork. По крайней мере, я встречал упоминания этих анализаторов в некоторых файлах.
Поэтому найти хоть что-то — это уже достижение. Давайте посмотрим, какие предупреждения анализатора PVS-Studio показались мне интересными.
**Опечатка N1**
```
NS_IMETHODIMP
nsNativeThemeWin::WidgetStateChanged(....)
{
....
if (aWidgetType == NS_THEME_WINDOW_TITLEBAR ||
aWidgetType == NS_THEME_WINDOW_TITLEBAR_MAXIMIZED ||
aWidgetType == NS_THEME_WINDOW_FRAME_LEFT ||
aWidgetType == NS_THEME_WINDOW_FRAME_RIGHT ||
aWidgetType == NS_THEME_WINDOW_FRAME_BOTTOM ||
aWidgetType == NS_THEME_WINDOW_BUTTON_CLOSE ||
aWidgetType == NS_THEME_WINDOW_BUTTON_MINIMIZE || <<<===
aWidgetType == NS_THEME_WINDOW_BUTTON_MINIMIZE || <<<===
aWidgetType == NS_THEME_WINDOW_BUTTON_RESTORE) {
*aShouldRepaint = true;
return NS_OK;
....
}
```
Предупреждение PVS-Studio: V501 There are identical sub-expressions 'aWidgetType == 237' to the left and to the right of the '||' operator. nsnativethemewin.cpp 2475
Переменная 'aWidgetType' два раза сравнивается с константой NS\_THEME\_WINDOW\_BUTTON\_MINIMIZE. Это опечатка. Второй раз переменную нужно сравнить с константой NS\_THEME\_WINDOW\_BUTTON\_MAXIMIZE.
**Опечатка N2**
```
bool nsHTMLCSSUtils::IsCSSEditableProperty(....)
{
....
if (aAttribute && aAttribute->EqualsLiteral("align") &&
(nsEditProperty::ul == tagName <<<<====
|| nsEditProperty::ol == tagName
|| nsEditProperty::dl == tagName
|| nsEditProperty::li == tagName
|| nsEditProperty::dd == tagName
|| nsEditProperty::dt == tagName
|| nsEditProperty::address == tagName
|| nsEditProperty::pre == tagName
|| nsEditProperty::ul == tagName)) { <<<<====
return true;
}
....
}
```
Предупреждение PVS-Studio: V501 There are identical sub-expressions 'nsEditProperty::ul == tagName' to the left and to the right of the '||' operator. nshtmlcssutils.cpp 432
Переменная 'tagName' два раза сравнивается с nsEditProperty::ul. Возможно, одна проверка лишняя. Или забыли сравнить с чем-то ещё.
**Опечатка N3**
```
void Reverb::process(....)
{
....
bool isCopySafe =
destinationChannelL &&
destinationChannelR &&
size_t(destinationBus->mDuration) >= framesToProcess &&
size_t(destinationBus->mDuration) >= framesToProcess;
....
}
```
Предупреждение PVS-Studio: V501 There are identical sub-expressions 'size\_t (destinationBus->mDuration) >= framesToProcess' to the left and to the right of the '&&' operator. reverb.cpp 192
Переменная 'framesToProcess' два раза сравнивается с 'size\_t(destinationBus->mDuration)'.
**Опечатка N4**
```
float
PannerNode::ComputeDopplerShift()
{
....
double scaledSpeedOfSound = listener->DopplerFactor() /
listener->DopplerFactor();
....
}
```
Предупреждение PVS-Studio: V501 There are identical sub-expressions 'listener->DopplerFactor()' to the left and to the right of the '/' operator. pannernode.cpp 529
Очень подозрительное выражение, которое стоит проверить.
**Опечатка N5**
```
bool DataChannelConnection::SendDeferredMessages()
{
....
if ((result = usrsctp_sendv(mSocket, data, ...., 0) < 0)) {
....
}
```
Предупреждение PVS-Studio: V593 Consider reviewing the expression of the 'A = B < C' kind. The expression is calculated as following: 'A = (B < C)'. datachannel.cpp 1105
Не там поставлена скобка. Упростим выражение, чтобы ошибка была лучше заметна:
```
if ((result = foo() < 0))
```
Это выражение вычисляется так. Результат, который вернула функция, сравнивается с 0. Затем true или false записывается в переменную 'result'. Ошибка в том, что не там закрывается одна из скобок. На самом деле, программист хотел написать выражение:
```
if ((result = foo()) < 0)
```
Теперь значение, которое вернула функция, записывается в переменную 'result'. И только потом это значение сравнивается с нулём.
**Опечатка N6**
```
void nsRegion::SimplifyOutwardByArea(uint32_t aThreshold)
{
....
topRects = destRect;
bottomRects = bottomRectsEnd;
destRect = topRects;
....
}
```
Предупреждение PVS-Studio: V587 An odd sequence of assignments of this kind: A = B; B = A;. Check lines: 358, 360. nsregion.cpp 360
Код подозрителен. Наверное, здесь есть какая-то опечатка.
**Некорректная проверка N1**
```
enum nsBorderStyle {
eBorderStyle_none = 0,
....
};
....
NS_IMETHODIMP
nsWindow::SetNonClientMargins(nsIntMargin &margins)
{
if (!mIsTopWidgetWindow ||
mBorderStyle & eBorderStyle_none ||
mHideChrome)
return NS_ERROR_INVALID_ARG;
....
}
```
Предупреждение PVS-Studio: V616 The 'eBorderStyle\_none' named constant with the value of 0 is used in the bitwise operation. nswindow.cpp 2278
Выражение «mBorderStyle & eBorderStyle\_none» не имеет смысла. Отсутствие стилей (eBorderStyle\_none) кодируется значением 0. По все видимости, код условие следует записать так:
```
if (!mIsTopWidgetWindow ||
mBorderStyle != eBorderStyle_none ||
mHideChrome)
```
**Некорректная проверка N2**
```
NS_IMETHODIMP nsWindowsRegKey::ReadStringValue(....)
{
....
DWORD type;
....
if (type != REG_SZ && type == REG_EXPAND_SZ &&
type == REG_MULTI_SZ)
return NS_ERROR_FAILURE;
....
}
```
Предупреждение PVS-Studio: V547 Expression is always false. Probably the '||' operator should be used here. nswindowsregkey.cpp 292
Переменная 'type' не может быть одновременно равна двум разным значениям. Упростим код, чтобы легче понять, что не нравится анализатору:
```
if (... && type == 2 && type == 7)
```
Это условие всегда ложно.
Скорее всего, код должен быть таким:
```
if (type != REG_SZ && type != REG_EXPAND_SZ &&
type != REG_MULTI_SZ)
```
**Некорректная проверка N3**
```
const SafepointIndex *
IonScript::getSafepointIndex(uint32_t disp) const
{
....
size_t minEntry = 0;
....
size_t guess = ....;
....
while (--guess >= minEntry) {
guessDisp = table[guess].displacement();
JS_ASSERT(guessDisp >= disp);
if (guessDisp == disp)
return &table[guess];
}
....
}
```
Предупреждение PVS-Studio: V547 Expression '-- guess >= minEntry' is always true. Unsigned type value is always >= 0. ion.cpp 1112
Цикл остановится только тогда, когда будет найден нужный элемент. Если такого элемента нет, условие остановки цикла никогда не выполнится, и произойдёт выход за границы массива.
Причина в том, что переменная 'guess' имеет беззнаковый тип. Это значит, что условие (--guess >= 0) всегда истинно.
**Невнимательность N1**
```
void WinUtils::LogW(const wchar_t *fmt, ...)
{
....
char* utf8 = new char[len+1];
memset(utf8, 0, sizeof(utf8));
....
}
```
Предупреждение PVS-Studio: V579 The memset function receives the pointer and its size as arguments. It is possibly a mistake. Inspect the third argument. winutils.cpp 146
Выражение 'sizeof(utf8)' возвращает размер указателя, а не размер выделенного буфера памяти. Правильный вариант кода:
```
memset(utf8, 0, sizeof(*utf8) * (len+1));
```
**Невнимательность N2**
Как всегда встречается код, где указатель в начале используется, а только затем проверяется на равенство нулю. Приведу в статье только один такой случай. Остальные ошибки авторы Firefox смогут найти, запустив анализатор.
```
void
nsHttpTransaction::RestartVerifier::Set(
int64_t contentLength, nsHttpResponseHead *head)
{
if (mSetup)
return;
if (head->Status() != 200) <<<<====
return;
mContentLength = contentLength;
if (head) { <<<<====
....
}
```
Предупреждение PVS-Studio: V595 The 'head' pointer was utilized before it was verified against nullptr. Check lines: 1915, 1920. nshttptransaction.cpp 1915
В начале указатель 'head' разыменовывается в выражении «head->Status()». А затем он проверяется на равенство нулю.
**Невнимательность N3**
```
NPError NPP_New(....)
{
....
InstanceData* instanceData = new InstanceData;
....
NPError err = pluginInstanceInit(instanceData);
if (err != NPERR_NO_ERROR) {
NPN_ReleaseObject(scriptableObject);
free(instanceData);
return err;
}
....
}
```
Предупреждение PVS-Studio: V611 The memory was allocated using 'new' operator but was released using the 'free' function. Consider inspecting operation logics behind the 'instanceData' variable. nptest.cpp 1029
Память выделяется с помощью оператора 'new', а освобождается вызовом функции 'free'. Результат — неопределённое поведение программы. Впрочем, это не страшно, так как код относится к тестам.
**Невнимательность N4**
Ещё один фрагмент кода, относящийся к тестам. Переменная 'device' может остаться неинициализированной:
```
static ID3D10Device1* getD3D10Device()
{
ID3D10Device1 *device;
....
if (createDXGIFactory1)
{
....
hr = createD3DDevice(...., &device);
....
}
return device;
}
```
Предупреждение PVS-Studio: V614 Potentially uninitialized pointer 'device' used. nptest\_windows.cpp 164
Более тщательная проверка
-------------------------
Целью статьи не ставилось описать все ошибки, которые может выявить PVS-Studio. Наверняка, я что-то пропустил. Про кое что не стал писать сознательно. Например, анализатор выдавал много предупреждений [V610](http://www.viva64.com/ru/d/0225/), относящихся к сдвиговым операциям, которые приводят к неопределённому поведению. Эти предупреждения однотипны, и писать про них не интересно.
Цель статьи показать возможности статического анализа, и привлечь внимание людей к нашему инструменту. Более тщательный анализ Firefox могут осуществить сами разработчики. Им будем намного легче понять, является что-то ошибкой или нет.
Примечание для разработчиков Firefox. Проект весьма большой, поэтому анализатор PVS-Studio выдаёт много ложных срабатываний. Однако, большинство из них относятся к специфическим макросам. Можно очень быстро сократить количество ложных предупреждений в несколько раз, расставив соответствующие комментарии в коде. Как подавить предупреждения, относящиеся к определённым макросам, описано в документации (см. раздел "[Подавление ложных предупреждений](http://www.viva64.com/ru/d/0021/)"). Если разработчики Firefox заинтересуются приобретением лицензии на PVS-Studio, мы со своей стороны также готовы принять участие в сокращении ложных срабатываний.
Заключение
----------
Подозрительных участков кода нашлось мало. Причина в том, что ошибки уже были найдены с помощью других методов тестирования и других статических анализаторов. Статические анализаторы кода наиболее полезны при регулярном использовании, так как позволяют выявить ошибку ещё на этапе написания кода. Подробнее это рассматривается в статье "[Лев Толстой и статический анализ кода](http://www.viva64.com/ru/b/0105/)".
Желаю всем успехов в программировании и поменьше ошибок.
Дополнительные ссылки
---------------------
1. Анализатор [PVS-Studio](http://www.viva64.com/ru/pvs-studio/). Найди массу глупых ошибок в процессе написания кода. Сэкономь время команды. У вас не делают глупых ошибок? [Ха-ха](http://www.viva64.com/ru/b/0116/)!
2. Приглашаем вас подписаться на наш твиттер: [@Code\_Analysis](https://twitter.com/Code_Analysis). Регулярно публикуем ссылки на интересные статьи по программированию и о проверке новых проектов.
Эта статья на английском
------------------------
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey Karpov. [Firefox Easily Analyzed by PVS-Studio Standalone](http://www.viva64.com/en/b/0262/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio и CppCat, версия 2014](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/226247/ | null | ru | null |
# Почему для SQL Server важна статистика
*Считанные дни остаются до старта нового потока по курсу [“MS SQL Server разработчик”](https://otus.pw/FSTK/). В преддверии старта курса продолжаем делиться с вами полезным материалом.*
За годы работы с SQL Server я обнаружила, что есть несколько тем, которые часто игнорируются. Их что боятся, думают, что они сложные или что они не такие важные. Также есть мнение, что эти знания не нужны, так как SQL Server "все делает за меня". Я слышала это об индексах. Я слышала это о статистике.
Итак, давайте поговорим, почему статистика важна и почему знание о том, что она важна, поможет вам существенно повлиять на производительность ваших запросов.
Есть несколько случаев, когда статистика обрабатывается автоматически:
* SQL Server автоматически создает статистику для индексов
* SQL Server автоматически создает статистику для столбцов, когда ему требуется больше информации для оптимизации запроса
+ ВАЖНО! Это происходит только тогда, когда включен параметр базы данных **auto\_create\_statistics**. Этот параметр включен по умолчанию во всех версиях и редакциях SQL Server. Однако иногда встречаются рекомендации его выключить. Я категорически против этого.
* SQL Server автоматически обновляет статистику для индексов и столбцов, когда она становится “неактуальной”, если это необходимо для оптимизации запроса.
+ ВАЖНО! Это происходит только тогда, когда включен параметр базы данных **auto\_update\_statistics**. Этот параметр включен по умолчанию во всех версиях и редакциях SQL Server. Иногда также встречаются рекомендации его выключить. Обычно я против этого. Узнать больше об автоматическом обновлении вы можете в статье (англ.) [Updating SQL Server Statistics Part I – Automatic Updates](https://www.sqlskills.com/blogs/erin/sqlskills-sql101-updating-sql-server-statistics-part-i-automatic-updates/), а про ручное обновление статистики (но с помощью более избирательного подхода) в статье [Updating SQL Server Statistics Part II – Scheduled Updates](https://www.sqlskills.com/blogs/erin/sqlskills-sql101-updating-sql-server-statistics-part-ii-scheduled-updates/).
Однако, важно знать, что, хотя статистика обрабатывается автоматически, этот процесс не всегда работает так хорошо как вы ожидаете. Для действительно эффективной оптимизации SQL Server’у нужны определенные шаблоны и наборы данных. Для понимания этого, я хочу немного поговорить о доступе к данным и о процессе оптимизации.
### Доступ к данным
Обычно, когда вы отправляете запрос к SQL Server для получения данных, вы пишете код на Transact-SQL в виде простого SELECT или, возможно, в виде хранимой процедуры (да, есть и другие варианты). Однако главное в том, что вы говорите какой набор данных вы хотите получить, а не описываете то, как эти данные должны быть извлечены. Как же SQL Server “доберется“ до данных?
### Обработка данных
В получении и обработке данных SQL Server’у помогает статистика. Статистика предоставляет информацию о том, **какой объем данных нужно будет обработать** при выполнении запроса. Если нужно будет обработать небольшой объем данных, то обработка может быть проще (возможно, другим способом), чем если бы запрос обрабатывал миллионы строк.
В частности, SQL Server использует оптимизатор запросов на основе стоимости (cost based). Существуют и другие варианты оптимизации, но сегодня, чаще всего, используются оптимизаторы, основанные на стоимости. Почему? Оптимизаторы, основанные на стоимости, используют информацию о запрашиваемых данных, чтобы сформировать более эффективные, оптимальные и целенаправленные планы, с учетом информации об этих данных. Как правило, этот процесс работает хорошо. Хотя с планами, которые сохраняются для последующих выполнений (кэшированные планы), могут быть проблемы. Тем не менее, в других способах оптимизации есть еще более серьезные недостатки.
ВАЖНО! Я здесь не говорю о кеше планов… Я говорю о начальном процессе оптимизации и о том, как SQL Server определяет, какой объем данных ему надо будет получить. Последующее выполнение кэшированного плана может привести к дополнительным проблемам с ним (известными как parameter sniffing). Об этом много написано в других статьях.
Чтобы объяснить оптимизацию на основе стоимости, позвольте мне рассказать о других видах оптимизации. Это поможет понять преимущества стоимостной оптимизации.
Оптимизация на уровне синтаксиса
--------------------------------
SQL Server может обработать запрос, используя только его текст и не тратить время на поиск наилучшего порядка обработки таблиц. Оптимизатор может просто соединить (join) ваши таблицы в том порядке, в котором вы их указали во FROM. Хотя для того чтобы начать выполнять запрос не требуется никаких затрат, но выполнение самого запроса может быть далеко не оптимальным. В общем случае, соединение больших таблиц с маленькими менее оптимально, чем соединение маленьких таблиц с большими. Давайте посмотрим на эти два примера:
```
USE [WideWorldImporters];
GO
SET STATISTICS IO ON;
GO
SELECT [so].*, [li].*
FROM [sales].[Orders] AS [so]
JOIN [sales].[OrderLines] AS [li] ON [so].[OrderID] = [li].[OrderID]
WHERE [so].[CustomerID] = 832 AND [so].[SalespersonPersonID] = 2
OPTION (FORCE ORDER);
GO
SELECT [so].*, [li].*
FROM [sales].[OrderLines] AS [li]
JOIN [sales].[Orders] AS [so] ON [so].[OrderID] = [li].[OrderID]
WHERE [so].[CustomerID] = 832 AND [so].[SalespersonPersonID] = 2
OPTION (FORCE ORDER);
GO
```
Сравните стоимости планов. Второй запрос значительно дороже.
*Стоимость одинаковых запросов с FORCE ORDER с разным порядком соединения.*
Да, это чрезмерное упрощение способов оптимизации соединения, но дело в том, что вы вряд ли укажете самостоятельно оптимальный порядок таблиц во FROM. Хорошая новость в том, что если у вас есть проблемы с производительностью, то вы можете применить такие оптимизации, как соединение таблиц в указанном порядке (см. пример выше). Есть много других хинтов (hint), которые вы можете использовать:
* [QUERY Hints](https://docs.microsoft.com/en-us/sql/t-sql/queries/hints-transact-sql-query?view=sql-server-ver15) (принудительное использование уровня параллелизма [MAXDOP], оптимизация запроса для быстрого получения первых строк, а не всего набора данных с помощью FAST n и т.д.)
* [TABLE Hints](https://docs.microsoft.com/en-us/sql/t-sql/queries/hints-transact-sql-table?view=sql-server-ver15) (принудительное использование индекса [INDEX], поиска в индексе [FORCESEEK] и т.д.)
* [JOIN Hints](https://docs.microsoft.com/en-us/sql/t-sql/queries/hints-transact-sql-join?view=sql-server-ver15) (принудительное использование типа соединения LOOP / MERGE / HASH)
Надо сказать, что использование хинтов всегда должно быть последним способом оптимизации. Следует попробовать другие способы оптимизации, прежде чем использовать хинты. Применяя их, вы не позволяете SQL Server оптимизировать ваши запросы при добавлении или изменении индексов, при добавлении или изменении статистики и при обновлении SQL Server. Конечно, если только вы не задокументировали используемые хинты и не протестировали их, чтобы убедиться, что они останутся полезными для вашего запроса после выполнения заданий по обслуживанию БД, модификации данных и обновлений SQL Server. Честно говоря, я не вижу, чтобы это делалось так часто, как хотелось бы. Большинство хинтов добавляются так, как будто они всегда будут работать отлично, и остаются в запросе до тех пор, пока не возникнут серьезные проблемы.
Всегда важно посмотреть, на другие способы улучшения производительности, прежде чем применять хинты. Да, легко поставить хинт сейчас, но время, которое вы потратите на поиск других решений, может окупиться сполна в долгосрочной перспективе.
Для проблем с конкретным запросом с его конкретными значениями стоит посмотреть:
* Является ли статистика точной/актуальной? Исправит ли обновление статистики проблему?
* Статистика основана на частичной выборке? Исправит ли FULLSCAN проблему?
* Можете ли вы переписать запрос и улучшить план?
+ Есть ли плохие условия поиска? Столбцы всегда должны находиться с одной стороны выражения:
- Так хорошо: `MonthlySalary > expression / 12`
- Так плохо: `MonthlySalary * 12 > expression`
+ Есть ли проблемы с транзитивностью, с которыми вы можете помочь SQL Server’у? Это интересный вопрос, и он становится все более проблематичным с возрастанием количества таблиц. Добавление, казалось бы, избыточного условия может помочь оптимизатору увидеть то, чего он не учел в исходном запросе (см. дополнительное условие `AND t2.colX = 12` ниже в WHERE):
FROM table2 AS t1
JOIN table2 AS t2 ON t1.colX = t2.colX
WHERE t1.colX = 12 AND **t2.colX = 12**
* Иногда простой переход от соединения к подзапросу или от подзапроса к соединению исправляет проблему (нет, одно не всегда лучше другого, но иногда переписывание может помочь оптимизатору).
* Иногда использование производных (derived) таблиц (подзапросов в FROM (...) AS J1) может помочь оптимизатору более оптимально соединить таблицы.
* Есть ли у вас условия OR? Можете ли вы переписать их через UNION или UNION ALL для получения такого же результата (это самое главное) с лучшим планом выполнения? Будьте осторожны, семантически это разные запросы. Вам нужно хорошо понимать различие между всеми ими.
+ OR удаляет дубликаты строк (на основе ID строки)
+ UNION удаляет дубликаты на основе столбцов, указанных в SELECT
+ UNION ALL объединяет множества (что может быть намного быстрее, чем удаление дубликатов), но это может быть (а может и не быть) проблемой:
- иногда дубликатов нет (вы должны знать свои данные)
- иногда допустимо вернуть дубликаты (вы должны знать ваших пользователей / аудиторию / приложение)
Это совсем небольшой список, но он может помочь вам повысить производительность без использования хинтов. Это значит, что при последующих изменениях в данных, индексах, статистике, в версии SQL Server, оптимизатор сможет учитывать эти изменения!
Но все-таки здорово, что хинты есть, и если мы действительно нуждаемся в них, то можем ими воспользоваться. Бывают ситуации, когда оптимизатор может не быть в состоянии придумать эффективный план. Для этих случаев можно воспользоваться хинтами. Так что да, мне нравится, что они есть. Я просто не хочу, чтобы вы использовали их, пока не определите, истинную причину проблемы.
**Так что, да, вы можете добиться оптимизации на уровне синтаксиса… если вам это нужно.**
Оптимизация с использованием правил (эвристика)
-----------------------------------------------
Я упоминала, что оптимизация на основе стоимости требует статистики. Но что, если у вас нет статистики?
На это также можно посмотреть с другой стороны — почему SQL Server не может просто использовать "набор правил" для быстрой оптимизации запросов без необходимости просматривать/анализировать информацию о ваших данных? Разве это не было бы быстрее? SQL Server может делать так, но часто это бывает не самое лучшее решение. Для демонстрации этого надо запретить SQL Server при обработке запроса использовать статистику. Я могу показать пример, когда это действительно работает хорошо, и гораздо больше примеров, когда работает плохо.
Эвристика — это правила. Простые, статичные, фиксированные правила. Тот факт, что они простые, является их преимуществом. Не нужно смотреть на данные. Делается простая и быстрая оценка запроса на основе предикатов. Например, “меньше” и “больше” имеют внутреннее правило “30%”. Проще говоря, когда вы запускаете запрос с предикатом “больше” или “меньше” и нет информации о данных (статистики), SQL Server будет использовать правило, которое говорит, что условию будут соответствовать 30% данных. Оптимизатор будет использовать это в своих оценках и придумает план, соответствующий этому правилу.
Чтобы это "заработало", нужно сначала отключить **auto\_create\_statistics** и проверить существующие индексы и статистику:
```
USE [WideWorldImporters];
GO
ALTER DATABASE [WideWorldImporters]
SET AUTO_CREATE_STATISTICS OFF;
GO
EXEC sp_helpindex '[sales].[Customers]';
EXEC sp_helpstats '[sales].[Customers]', 'all';
GO
```
Посмотрите `sp_helpindex` и `sp_helpstats`. В базе данных `WideWorldImporters` в таблице `Customers` на столбце `DeliveryPostalCode` по умолчанию нет индексов и статистики. Если вы добавили что-то самостоятельно (или SQL Server создал автоматически), то следует их удалить перед выполнением следующих примеров.
Для первого запроса мы поставим `ZipCode`, равный 90248 и используем предикат “меньше”. Посмотрим как SQL Server оценит количество строк без использования статистики и возможности ее автоматического создания.
```
SELECT [c1].[CustomerID],
[c1].[CustomerName],
[c1].[PostalCityID],
[c1].[DeliveryPostalCode]
FROM [sales].[Customers] AS [c1]
WHERE [c1].[DeliveryPostalCode] < '90248';
```
*Столбцы без статистики будут использовать эвристику.*
Если не найти «идеальное» значение, то большую часть времени эти правила будут неправильными!
Для первого запроса оценка работает хорошо (30% от 663 = 198,9), так как фактическое количество строк для запроса составляет 197. Один важный момент, на который стоит обратить внимание — это предупреждение рядом с таблицей `Customers` и около самого левого оператора SELECT. Оно говорит нам о том, что здесь что-то не так. Хотя, оценка количества строк «правильная».
Для второго запроса мы возьмем значение `ZipCode` равное 90003. Запрос точно такой же, за исключением значения ZipCode. Как сейчас SQL Server оценит количество строк?
```
SELECT [c1].[CustomerID],
[c1].[CustomerName],
[c1].[PostalCityID],
[c1].[DeliveryPostalCode]
FROM [sales].[Customers] AS [c1]
WHERE [c1].[DeliveryPostalCode] < '90003';
```
Столбцы без статистики используют эвристику (простые правила). Часто они сильно ошибаются!
Для второго запроса оценка также равна 198,9, а фактически строк только 1. Почему? Потому что без статистики эвристика для “меньше” (и “больше”) составляет 30%. Тридцать процентов от 663 — это 198,9. Конкретное значение меняется при модификации данных, но процент остается постоянным 30%.
Если этот запрос будет более сложным (с соединениями и/или дополнительными предикатами), то наличие некорректной информации — это уже проблема для последующих шагов оптимизации. Да, время от времени вам может везти с эвристиками, но это маловероятно. Более того эвристика для BETWEEN и “равно” отличается от значений для “меньше” и “больше” (равной равна 30%). На самом деле, некоторые из них даже меняются в зависимости от используемой вами модели оценки кардинальности (например, для “равно”). А меня, вообще, это должно беспокоить? На самом деле, нет! В действительности я никогда не хочу их использовать.
**Итак, SQL Server может использовать оптимизацию на основе правил… но только тогда, когда у него нет лучшей информации.**
Я не хочу эвристику! Я хочу статистику!
Статистика — это одно из немногих мест в SQL Server, которой не может быть мало. Нет, я не говорю о том, чтобы создавать статистику для каждого столбца таблицы, но есть некоторые случаи, когда можно предварительно создать статистику. Но это тема для отдельной статьи.
Итак, почему статистика так важна для стоимостной оптимизации?
Оптимизация на основе стоимости
-------------------------------
Что же на самом деле делает оптимизация на основе стоимости? Если кратко, то SQL Server **быстро** получает приблизительную оценку того, сколько данных будет обработано. Затем, используя эту информацию, он оценивает стоимость различных алгоритмов, которые могут быть использованы для доступа к данным. После этого, основываясь на “стоимости” этих алгоритмов, SQL Server выбирает тот, который, по его расчетам, является наименее дороги. Затем он его компилирует и выполняет.
Это звучит здорово, но есть много факторов, когда это может работать не так хорошо, как хотелось бы. Самое главное, что базовая информация, используемая для выполнения оценки (статистика), может быть некорректной:
* Статистика может быть устаревшей
* Статистика может быть не точной из-за ограниченной выборки
* Статистика может быть не точной из-за размера таблицы и ограничений того, что храниться в ней.
Некоторые спросят меня — может ли SQL Server иметь более подробную статистику (более подробные гистограммы и т.п.)? Да, может. Но тогда процесс чтения / доступа к этой, все большей и большей, статистике будет становиться все дороже (и занимать больше времени, больше кеша и т. д.). Что, в свою очередь, сделает процесс оптимизации более дорогим. Это сложная проблема. Везде есть плюсы и минусы, компромиссы. На самом деле, все не так просто, как “подробные гистограммы”.
Наконец, в процессе оптимизации нельзя проанализировать все возможные комбинации планов. Это сделало бы сам процесс оптимизации настолько дорогим, что это было бы непозволительно!
Итог
----
Лучший способ думать о процессе оптимизации — это как найти **“хороший план быстро”**. Иначе процесс оптимизации стал бы настолько сложным и затянулся бы настолько, что не достиг бы своей цели!
Итак, почему статистика очень важна:
* Она используется на всем протяжении процесса стоимостной оптимизации (а вы хотите оптимизацию на основе стоимости)
* Она должна присутствовать, иначе вы будете вынуждены использовать эвристику
+ как правило, я настоятельно рекомендую включить параметр **auto\_create\_statistics**, если вы его выключили
* Она должна быть актуальной, чтобы давать более точные оценки (ее важно обновлять и некоторая статистика может больше нуждаться в вашей «помощи», чем другая, чтобы оставаться актуальной)
* Ей может понадобиться дополнительная помощь (с тем, **как** она обновляется, **когда** обновляется, или с **дополнительной** статистикой)
**СТАТИСТИКА — КЛЮЧ К ЛУЧШЕЙ ОПТИМИЗАЦИИ И, СЛЕДОВАТЕЛЬНО, ЛУЧШЕЙ ПРОИЗВОДИТЕЛЬНОСТИ** *(но это все еще пока далеко от идеала!)*
Я надеюсь, что эта статья мотивирует вас изучить больше о статистике. Статистика в SQL Server на самом деле проще, чем вы думаете и, очевидно, она очень, очень важна!
Довольно старая, но все еще полезная статья — [Statistics Used by the Query Optimizer in Microsoft SQL Server 2008](http://msdn.microsoft.com/en-us/library/dd535534.aspx)
*Узнать подробнее о курсе можно в [записи дня открытых дверей](https://otus.pw/FSTK/).* | https://habr.com/ru/post/489366/ | null | ru | null |
# Когда «Zoë» !== «Zoë», или почему нужно нормализовывать Unicode-строки
Никогда не слышали о нормализации Unicode? Вы не одиноки. Но об этом надо знать всем. Нормализация способна избавить вас от множества проблем. Рано или поздно нечто подобное тому, что показано на следующем рисунке, случается с любым разработчиком.
[](https://habr.com/ru/company/ruvds/blog/445274/)*«Zoë» — это не «Zoë»*
И это, кстати, не пример очередной [странности](https://github.com/denysdovhan/wtfjs) JavaScript. Автор материала, перевод которого мы сегодня публикуем, говорит, что может показать, как та же проблема проявляется при использовании практически каждого из существующих языков программирования. В частности, речь идёт о Python, Go, и даже о сценариях командной оболочки. Как с этим бороться?
Предыстория
-----------
Я впервые столкнулся с проблемой Unicode много лет назад, когда писал приложение (на Objective-C), которое импортировало список контактов из адресной книги пользователя и из его социальных сетей, после чего исключало дубликаты. В определённых ситуациях оказывалось так, что некоторые люди присутствуют в списке дважды. Происходило это из-за того, что их имена, по мнению программы, не являлись одинаковыми строками.
Хотя в вышеприведённом примере две строки выглядят абсолютно одинаково, то, как они представлены в системе, те байты, в виде которых они сохранены на диске, различаются. В первом имени `"Zoë"` символ ë (e с умлаутом) представляет собой одну кодовую точку Unicode. Во втором случае мы имеем дело с декомпозицией, с подходом к представлению знаков с помощью нескольких символов. Если вы, в своём приложении, работаете с Unicode-строками, вам нужно учитывать то, что одни и те же символы могут быть представлены разными способами.
Как мы пришли к эмодзи: в двух словах о кодировании символов
------------------------------------------------------------
Компьютеры работают с байтами, которые представляют собой всего лишь числа. Для того чтобы получить возможность обрабатывать на компьютерах тексты, люди договорились о соответствии символов и чисел, и пришли к соглашениям о том, как должно выглядеть визуальное представление символов.
Первое подобное соглашение было представлено кодировкой ASCII (American Standard Code for Information Interchange). Эта кодировка использовала 7 бит и могла представлять 128 символов, в состав которых входили латинский алфавит (прописные и строчные буквы), цифры и основные знаки пунктуации. В ASCII также входило множество «непечатаемых» символов, таких, как символ перевода строки, знак табуляции, символ возврата каретки и другие. Например, в ASCII латинская буква M (прописная m) кодируется в виде числа 77 (4D в шестнадцатеричном представлении).
Проблема ASCII заключается в том, что хотя 128 знаков может быть достаточно для представления всех символов, которыми обычно пользуются люди, работающие с англоязычными текстами, этого количества символов недостаточно для представления текстов на других языках и разных особых символов вроде эмодзи.
Решением этой проблемы стало принятие стандарта Unicode, который был нацелен на возможность представления каждого символа, используемого во всех современных и древних текстах, включая и символы вроде эмодзи. Например, в совсем недавно вышедшем стандарте Unicode 12.0 насчитывается более 137000 символов.
Стандарт Unicode может быть реализован с использованием множества способов кодирования символов. Самые распространённые — это UTF-8 и UTF-16. Надо отметить, что в веб-пространстве сильнее всего распространён стандарт кодирования текстов UTF-8.
Стандарт UTF-8 использует для представления символов от 1 до 4 байт. UTF-8 представляет собой надмножество ASCII, поэтому первые его 128 символов совпадают с символами, представленными в кодовой таблице ASCII. Стандарт UTF-16, с другой стороны, использует для представления 1 символа от 2 до 4 байт.
Почему существуют и тот и другой стандарты? Дело в том, что тексты на западных языках обычно эффективнее всего кодируются с использованием стандарта UTF-8 (так как большинство символов в таких текстах могут быть представлены в виде кодов размером в 1 байт). Если же говорить о восточных языках, то можно сказать, что файлы, хранящие тексты, написанные на этих языках, обычно получаются меньше при использовании UTF-16.
Кодовые точки Unicode и кодирование символов
--------------------------------------------
Каждому символу в стандарте Unicode назначен идентификационный номер, который называется кодовой точкой. Например, кодовой точкой эмодзи  является [U+1F436](http://www.fileformat.info/info/unicode/char/1F436/index.htm).
При кодировании этого значка он может быть представлен в виде различных последовательностей байтов:
* UTF-8: 4 байта, `0xF0 0x9F 0x90 0xB6`
* UTF-16: 4 байта, `0xD83D 0xDC36`
В JavaScript-коде, представленном ниже, все три команды выводят в консоль браузера один и тот же символ.
`// Так соответствующая последовательность байтов просто включается в код
console.log('') // => 
// Тут используется кодовая точка Unicode (ES2015+)
console.log('\u{1F436}') // => 
// Тут используется представление этого символа в стандарте UTF-16
// с применением двух кодовых единиц (по 2 байта каждая)
console.log('\uD83D\uDC36') // => `
Во внутренних механизмах большинства JavaScript-интерпретаторов (включая Node.js и современные браузеры) используется UTF-16. Это означает, что рассматриваемый нами значок с собакой хранится с использованием двух кодовых единиц UTF-16 (по 16 бит каждая). Поэтому то, что выводит следующий код, не должно показаться вам непонятным:
`console.log(''.length) // => 2`
Комбинирование символов
-----------------------
Теперь вернёмся к тому, с чего мы начали, а именно, поговорим о том, почему символы, выглядящие для человека одинаково, имеют различное внутреннее представление.
Некоторые символы в кодировке Unicode предназначены для модификации других символов. Их называют комбинируемыми символами (combining characters). Они применяются к базовым символам (base characters) Например:
* `n + ˜ = ñ`
* `u + ¨ = ü`
* `e + ´ = é`
Как видно из предыдущего примера, комбинируемые символы позволяют добавлять к базовым символам диакритические знаки. Но на этом возможности Unicode по трансформации символов не ограничиваются. Например, некоторые последовательности символов могут быть представлены в виде лигатур (так ae может превратиться в æ).
Проблема заключается в том, что особенные символы могут быть представлены различными способами.
Например, букву é можно представить двумя способами:
* С помощью одной кодовой точки [U+00E9](http://www.fileformat.info/info/unicode/char/e9/index.htm).
* С помощью комбинации буквы e и знака акута, то есть — с помощью двух кодовых точек — [U+0065](http://www.fileformat.info/info/unicode/char/65/index.htm) и [U+0301](http://www.fileformat.info/info/unicode/char/0301/index.htm).
Символы, получившиеся в результате применения любого из этих способов представления буквы é, будут выглядеть одинаково, но при их сравнении окажется, что символы это разные. Строки, содержащие их, будут иметь разную длину. Убедиться в этом можно, выполнив следующий код в консоли браузера.
```
console.log('\u00e9') // => é
console.log('\u0065\u0301') // => é
console.log('\u00e9' == '\u0065\u0301') // => false
console.log('\u00e9'.length) // => 1
console.log('\u0065\u0301'.length) // => 2
```
Это может привести к неожиданным ошибкам. Например, они могут выражаться в том, что программа, по непонятным причинам, не способна найти в базе данных некоторые записи, в том, что пользователь, вводя правильный пароль, не может войти в систему.
Нормализация строк
------------------
У вышеописанных проблем есть простое решение, которое заключается в нормализации строк, в приведении их к «каноническому представлению».
Существуют четыре стандартных формы (алгоритма) нормализации:
* NFC: Normalization Form Canonical Composition.
* NFD: Normalization Form Canonical Decomposition.
* NFKC: Normalization Form Compatibility Composition.
* NFKD: Normalization Form Compatibility Decomposition.
Чаще всего используется форма нормализации NFC. При использовании этого алгоритма все символы сначала подвергаются декомпозиции, после чего все комбинирующиеся последовательности подвергаются повторной композиции в порядке, определяемом стандартом. Для практического применения можно выбрать любую форму. Главное — применять её последовательно. В результате поступление на вход программы одних и тех же данных всегда будет приводить к одному и тому же результату.
В JavaScript, начиная со стандарта ES2015 (ES6), имеется встроенный метод для нормализации строк — [String.prototype.normalize([form])](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize). Пользоваться им можно в среде Node.js и практически во всех современных браузерах. Аргумент `form` этого метода представляет собой строковой идентификатор формы нормализации. По умолчанию используется форма NFC.
Вернёмся к ранее рассмотренному примеру, применив на этот раз нормализацию:
```
const str = '\u0065\u0301'
console.log(str == '\u00e9') // => false
const normalized = str.normalize('NFC')
console.log(normalized == '\u00e9') // => true
console.log(normalized.length) // => 1
```
Итоги
-----
Если вы разрабатываете веб-приложение и используете в нём то, что вводит пользователь, всегда выполняйте нормализацию полученных текстовых данных. В JavaScript для выполнения нормализации можно воспользоваться стандартным методом строк [normalize()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize).
**Уважаемые читатели!** Сталкивались ли вы с проблемами, возникающими при работе со строками, решить которых можно с помощью нормализации?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/445274/ | null | ru | null |
# Процедурная генерация лабиринтов в Unity
> *Примечание:* этот туториал написан для Unity 2017.1.0 и предназначен для опытных пользователей. Подразумевается, что вы уже хорошо знакомы с программирование игр в Unity.
Вы, как Unity-разработчик, наверно, имеете достаточный опыт в создании уровней вручную. Но хотели ли вы когда-нибудь генерировать уровни на лету? Процедурная генерация мешей для полов и стен, в отличие от простого расположения заранее созданных моделей, обеспечивает гораздо большую гибкость и реиграбельность игры.
В этом туториале вы научитесь следующему:
* Процедурно генерировать уровни на примере создания игры про бег в лабиринте.
* Генерировать данные лабиринтов.
* Использовать данные лабиринтов для построения меша.
Приступаем к работе
-------------------
В большинстве алгоритмов (таких, например, как [этот](http://www.astrolog.org/labyrnth/algrithm.htm) и [этот](http://www.jamisbuck.org/mazes/)) создаются «идеальные» плотные лабиринты, то есть такие, у которых есть только один верный путь и нет петель. Они похожи на лабиринты, публикуемые в газетных разделах «Головоломки».
Однако в большинство игр приятнее играть, когда лабиринты неидеальны и в них есть петли. Они должны быть обширными и состоящими их открытых пространств, а не из узких извилистых коридоров. Это особенно справедливо для жанра rogue-like, в котором процедурные уровни являются не столько «лабиринтами», а скорее подземельями.
В этом туториале мы реализуем один из простейших алгоритмов лабиринтов, описанный [здесь](http://www.robotron2084guidebook.com/home/games/berzerk/mazegenerator/). Я выбрал его для того, чтобы реализовать лабиринты в игре с минимальным количеством усилий. Такой простой подход хорошо работает в классических играх, перечисленных по ссылке, поэтому мы можем использовать его для создания лабиринтов в игре под названием *Speedy Treasure Thief*.
В этой игре каждый уровень — это новый лабиринт, в котором спрятан сундук с сокровищем. Однако у вас не так много времени на его поиски и побег до того, как вернутся стражники! На каждом уровне есть ограничение по времени и вы можете играть, пока вас не поймают. Набранные очки зависят от количества украденных вами сокровищ.
Для начала создадим в Unity новый пустой проект.
Скачайте *[заготовку проекта](https://koenig-media.raywenderlich.com/uploads/2017/11/proc-mazes-starter.zip)*, распакуйте её и импортируйте в новый проект \*\*proc-mazes-starter.unitypackage\*\*. В заготовке проекта есть следующее содержимое:
1. Папка *Graphics*, в которой содержится вся необходимая для игры графика.
2. Сцена *Scene* — исходная сцена для этого туториала, содержащая игрока и UI.
3. Папка *Scripts*, содержащая два вспомогательных скрипта. Остальные скрипты мы напишем в процессе выполнения туториала.
И этого достаточно, чтобы приступить к работе. Каждый из этих пунктов мы рассмотрим подробнее позже.
Задаём архитектуру кода
-----------------------
Начнём с добавления в сцену пустого проекта. Выберите *GameObject ▸ Create Empty*, назовите его *Controller* и поместите в (X:0, Y:0, Z:0). Этот объект будет просто точкой присоединения скриптов, управляющих игрой.
В папке *Scripts* проекта создайте скрипт C# с названием *GameController*, а затем создайте ещё один скрипт и назовите его *MazeConstructor*. Первый скрипт будет управлять игрой в целом, а второй — заниматься генерированием лабиринта.
Замените все строки в *GameController* следующим кодом:
```
using System;
using UnityEngine;
[RequireComponent(typeof(MazeConstructor))] // 1
public class GameController : MonoBehaviour
{
private MazeConstructor generator;
void Start()
{
generator = GetComponent(); // 2
}
}
```
Вкратце расскажу, что мы только что создали:
1. Атрибут `RequireComponent` обеспечивает добавление компонента *MazeConstructor* при добавлении этого скрипта к GameObject.
2. Частная переменная хранит ссылку, возвращаемую `GetComponent()`.
Добавьте этот скрипт в сцену: перетащите скрипт *GameController* из окна *Project* на GameObject *Controller* в окне *Hierarchy*.
Заметьте, что к *Controller* также добавился MazeConstructor; это происходит автоматически благодаря атрибуту `RequireComponent`.
Теперь замените всё в *MazeConstructor* на следующий код:
```
using UnityEngine;
public class MazeConstructor : MonoBehaviour
{
//1
public bool showDebug;
[SerializeField] private Material mazeMat1;
[SerializeField] private Material mazeMat2;
[SerializeField] private Material startMat;
[SerializeField] private Material treasureMat;
//2
public int[,] data
{
get; private set;
}
//3
void Awake()
{
// default to walls surrounding a single empty cell
data = new int[,]
{
{1, 1, 1},
{1, 0, 1},
{1, 1, 1}
};
}
public void GenerateNewMaze(int sizeRows, int sizeCols)
{
// stub to fill in
}
}
```
Вот, что здесь происходит:
1. Все эти поля доступны нам в *Inspector*. `showDebug` переключает отображение отладки, а различные ссылки *Material* являются материалами для генерируемых моделей. Кстати, атрибут `SerializeField` отображает поле в *Inspector*, даже несмотря на то, что переменная является `private`.
2. Далее идёт свойство `data`. Объявления доступа (например, объявление свойства как `public`, но затем назначение его `private set`) делает его read-only за пределами класса. Таким образом, данные лабиринта невозможно будет изменять извне.
3. Последняя часть интересного кода находится в `Awake()`. Функция инициализирует `data` с массивом 3 x 3 из единиц, окружающих ноль. 1 означает стену, а 0 — пустое пространство, то есть сетка по умолчанию выглядит как окружённая стеной комната.
Это уже неплохой фундамент для кода, но пока мы ничего ещё не увидим!
Для отображения данных лабиринта и проверки того, как он выглядит, добавим в *MazeConstructor* следующий метод:
```
void OnGUI()
{
//1
if (!showDebug)
{
return;
}
//2
int[,] maze = data;
int rMax = maze.GetUpperBound(0);
int cMax = maze.GetUpperBound(1);
string msg = "";
//3
for (int i = rMax; i >= 0; i--)
{
for (int j = 0; j <= cMax; j++)
{
if (maze[i, j] == 0)
{
msg += "....";
}
else
{
msg += "==";
}
}
msg += "\n";
}
//4
GUI.Label(new Rect(20, 20, 500, 500), msg);
}
```
Рассмотрим каждый из откомментированных разделов:
1. Этот код проверяет, включено ли отображение отладки.
2. Инициализация нескольких локальных переменных: локальная копия сохранённого лабиринта, максимальная строка и столбец, а также строка.
3. Два вложенных цикла проходят по строкам и столбцам двухмерного массива. Для каждой строки/столбца массива код проверят сохранённое значение и добавляет "...." или "==" в зависимости от того, равно ли значение нулю. Также после прохождения по всем столбцам в строке код добавляет новую строку, чтобы каждая строка массива начиналась с новой строкиline.
4. Наконец, `GUI.Label()` выводит создаваемую строку. В этом проекте используется новая система GUI вывода данных игроку, но старая система проще для создания быстрых отладочных сообщений.
Не забудьте включить *Show Debug* для компонента MazeConstructor. Нажмите *Play*, и на экране отобразятся сохранённые данные лабиринта (которые пока являются лабиринтом по умолчанию):
Неплохое начало! Однако код пока не генерирует сам лабиринт. В следующем разделе я расскажу, как решить эту задачу.
Генерирование данных лабиринта
------------------------------
Заметьте, что в `MazeConstructor.GenerateNewMaze()` пока пусто; это заготовка, которую мы заполним позже. В конце метода `Start()` скрипта *GameController* добавьте следующую строку. Она будет вызывать этот метод-заготовку:
```
generator.GenerateNewMaze(13, 15);
```
«Волшебные» числа 13 и 15 — это параметры метода, определяющие размеры лабиринта. Хотя мы пока их не используем, эти параметры размера задают количество строк и столбцов сетки.
На этом этапе мы можем приступить к генерированию данных для лабиринта. Создайте новый скрипт *MazeDataGenerator*; этот класс инкапсулирует логику генерирования данных, и будет использоваться в *MazeConstructor*. Откройте новый скрипт и замените всё на следующий код:
```
using System.Collections.Generic;
using UnityEngine;
public class MazeDataGenerator
{
public float placementThreshold; // chance of empty space
public MazeDataGenerator()
{
placementThreshold = .1f; // 1
}
public int[,] FromDimensions(int sizeRows, int sizeCols) // 2
{
int[,] maze = new int[sizeRows, sizeCols];
// stub to fill in
return maze;
}
}
```
Заметьте, что этот класс не наследует от MonoBehaviour. Он не будет использоваться непосредственно как компонент, а только внутри *MazeConstructor*, поэтому не обязан обладать функционалом MonoBehaviour.
1. `placementThreshold` будет использоваться алгоритмом генерирования данных для определения того, пусто ли пространство. В конструкторе класса этой переменной назначается значение по умолчанию, но она сделана `public`, чтобы другой код мог управлять настройкой генерируемого лабиринта.
2. Один из методов (в этом случае `FromDimensions()`) снова пока пуст и оставлен заготовкой, которую мы заполним позже.
Далее мы добавим в *MazeConstructor* несколько разделов кода, чтобы он мог вызывать метод-заготовку. Для начала добавим частную переменную для хранения генератора данных:
```
private MazeDataGenerator dataGenerator;
```
Затем создадим его экземпляр в `Awake()`, сохранив генератор в новую переменную добавлением следующей строки вверху метода `Awake()`.
```
dataGenerator = new MazeDataGenerator();
```
Наконец, вызовем `FromDimensions()` в `GenerateNewMaze()`, передавая размер сетки и сохраняя получившиеся данные. Найдите в `GenerateNewMaze()` строку, в которой написано `// stub to fill in`, и замените её следующим:
```
if (sizeRows % 2 == 0 && sizeCols % 2 == 0)
{
Debug.LogError("Odd numbers work better for dungeon size.");
}
data = dataGenerator.FromDimensions(sizeRows, sizeCols);
```
Здесь добавлено предупреждение о том, что лучше использовать для размеров нечётные числа, потому что сгенерированный лабиринт будет окружён стенами.
Запустите игру, чтобы увидеть пустые данные лабиринта, но уже с правильными размерами:
Отлично! Всё готово к сохранению и отображению данных лабиринта! Настало время реализовать внутри `FromDimensions()` алгоритм генерации лабиринта.
Описанный выше алгоритм обходит каждую вторую ячейку в сетке (то есть не каждую ячейку!) располагая стену и выбирая соседнее пространство для блокировки. Программируемый здесь алгоритм будет слегка отличаться от него, он также решает, нужно ли пропускать пространство, что может приводить к возникновению в лабиринте открытых пространств. Поскольку алгоритм не должен хранить много информации или знать много об остальной части лабиринта, например, о точках ветвления, по которым нужно пройти, то код становится очень простым.
Для реализации этого алгоритма генерации лабиринта добавьте в `FromDimensions()` из *MazeDataGenerator* следующий код, заменив строку с `// stub to fill in`.
```
int rMax = maze.GetUpperBound(0);
int cMax = maze.GetUpperBound(1);
for (int i = 0; i <= rMax; i++)
{
for (int j = 0; j <= cMax; j++)
{
//1
if (i == 0 || j == 0 || i == rMax || j == cMax)
{
maze[i, j] = 1;
}
//2
else if (i % 2 == 0 && j % 2 == 0)
{
if (Random.value > placementThreshold)
{
//3
maze[i, j] = 1;
int a = Random.value < .5 ? 0 : (Random.value < .5 ? -1 : 1);
int b = a != 0 ? 0 : (Random.value < .5 ? -1 : 1);
maze[i+a, j+b] = 1;
}
}
}
}
```
Как вы видите, код получает границы 2D-массива, а затем обходит его:
1. Для каждой ячейки сетки код сначала проверяет, выходит ли текущая ячейка за пределы сетки (то есть находится ли какой-то из индексов на границе массива). Если это так, то он ставит стену, присваивая 1.
2. Далее код проверяет, делятся ли координаты на 2 нацело, чтобы выполнять действия в каждой *второй* ячейке. Также здесь есть дополнительная проверка на описанное выше значение `placementThreshold` для пропуска случайным образом этой ячейки и продолжения обхода массива.
3. Наконец, код присваивает значение 1 текущей ячейке и случайно выбранной соседней ячейке. Код использует несколько тернарных операций для прибавления к индексу массива 0, 1 или -1, получая таким образом индекс соседней ячейки.
Отобразим данные лабиринта снова, чтобы посмотреть, как выглядит сгенерированный лабиринт:
Перезапустите игру, чтобы увидеть, что данные лабиринта каждый раз новые. Отлично!
Следующая серьёзная задача — генерация 3D-меша из 2D-данных лабиринта.
Генерирование меша лабиринта
----------------------------
Теперь после генерирования всех данных лабиринта мы можем на основании этих данных построить меш.
Создайте ещё один новый скрипт *MazeMeshGenerator*. Так же, как *MazeDataGenerator* инкапсулировал логику генерирования лабиринта, *MazeMeshGenerator* будет содержать логику генерирования меша и использоваться *MazeConstructor* для выполнения этого этапа генерирования лабиринта.
Точнее, он *позже* будет содержать логику генерирования меша. Сначала мы просто создадим для демонстрации текстурированный четырёхугольник, а потом изменим этот код для генерирования всего лабиринта. Чтобы сделать это, нам нужно внести небольшие изменения в редактор Unity, и уже потом углубляться в код.
Для начала нам нужно привязать материалы, которые будут применяться к сгенерированному мешу.
Выберите в окне *Project* папку *Graphics*, затем выберите в окне *Hierarchy* Controller, чтобы отобразить в *Inspector* его компонент *Maze Constructor*.
Перетащите материалы из папки *Graphics* в слоты материалов *Maze Constructor*. Используйте *floor-mat* для Material 1 и *wall-mat* для Material 2, а *start* и *treasure* перетащите в соответствующие слоты.
Так как мы уже работаем в *Inspector*, добавим также тэг *Generated*: нажмите на меню Tag в верхней части *Inspector* и выберите *Add Tag*. При генерировании мешей мы будем назначать им этот тэг, чтобы находить их.
Внеся все необходимые изменения в редакторе Unity, откройте новый скрипт и замените всё на этот код:
```
using System.Collections.Generic;
using UnityEngine;
public class MazeMeshGenerator
{
// generator params
public float width; // how wide are hallways
public float height; // how tall are hallways
public MazeMeshGenerator()
{
width = 3.75f;
height = 3.5f;
}
public Mesh FromData(int[,] data)
{
Mesh maze = new Mesh();
//1
List newVertices = new List();
List newUVs = new List();
List newTriangles = new List();
// corners of quad
Vector3 vert1 = new Vector3(-.5f, -.5f, 0);
Vector3 vert2 = new Vector3(-.5f, .5f, 0);
Vector3 vert3 = new Vector3(.5f, .5f, 0);
Vector3 vert4 = new Vector3(.5f, -.5f, 0);
//2
newVertices.Add(vert1);
newVertices.Add(vert2);
newVertices.Add(vert3);
newVertices.Add(vert4);
//3
newUVs.Add(new Vector2(1, 0));
newUVs.Add(new Vector2(1, 1));
newUVs.Add(new Vector2(0, 1));
newUVs.Add(new Vector2(0, 0));
//4
newTriangles.Add(2);
newTriangles.Add(1);
newTriangles.Add(0);
//5
newTriangles.Add(3);
newTriangles.Add(2);
newTriangles.Add(0);
maze.vertices = newVertices.ToArray();
maze.uv = newUVs.ToArray();
maze.triangles = newTriangles.ToArray();
return maze;
}
}
```
Два поля в верхней части класса, `width` и `height`, аналогичны `placementThreshold` из *MazeDataGenerator*: это значения, которые в конструкторе задаются по умолчанию и используемые кодом генерирования меша.
Основная часть интересного кода находится внутри `FromData()`; это метод, который *MazeConstructor* вызывает для генерирования меша. В данный момент этот код просто создаёт единственный четырёхугольник для демонстрации своей работы. Вскоре мы расширим его до целого уровня.
На этой иллюстрации показано, из чего создан четырёхугольник:
Код длинный, но довольно сильно повторяющийся с небольшими вариациями:
1. Меш состоит из трёх списков: вершин, координат UV и треугольников.
2. Список вершин хранит позицию каждой вершины...
3. Перечисленные координаты UV соответствуют вершинам в этом списке...
4. А треугольники являются индексами в списке вершин (т.е. «этот треугольник состоит из вершин 0, 1 и 2»).
5. Заметьте, что создаются два треугольника; четырёхугольник состоит из двух треугольников. Также заметьте, что используются типы данных `List` (для присоединения к списку), но в конце концов для `Mesh` требуется `Arrays`.
*MazeConstructor* должен создать экземпляр *MazeMeshGenerator*, а затем вызвать метод генерирования меша. Также он также должен *отображать* меш, поэтому мы добавим следующие фрагменты кода:
Сначала добавим частное поле для хранения генератора меша.
```
private MazeMeshGenerator meshGenerator;
```
Создадим его экземляр в *Awake()*, сохранив генератор меша в новом поле добавлением следующей строки в верхней части метода *Awake()*:
```
meshGenerator = new MazeMeshGenerator();
```
Далее добавим метод *DisplayMaze()*:
```
private void DisplayMaze()
{
GameObject go = new GameObject();
go.transform.position = Vector3.zero;
go.name = "Procedural Maze";
go.tag = "Generated";
MeshFilter mf = go.AddComponent();
mf.mesh = meshGenerator.FromData(data);
MeshCollider mc = go.AddComponent();
mc.sharedMesh = mf.mesh;
MeshRenderer mr = go.AddComponent();
mr.materials = new Material[2] {mazeMat1, mazeMat2};
}
```
Наконец, для вызова *DisplayMaze()* добавим в конец *GenerateNewMaze()* следующую строку:
```
DisplayMaze();
```
Сам по себе `Mesh` — это просто данные. Он невидим, пока не назначен объекту (если конкретнее, то `MeshFilter` объекта) в сцене. Поэтому `DisplayMaze()` не только вызывает `MazeMeshGenerator.FromData()`, но и вставляет этот вызов посередине создания экземпляра нового `GameObject`, задавая тэг *Generated*, добавляя `MeshFilter` и сгенерированный меш, добавляя `MeshCollider` для коллизий с мешем, и, наконец, добавляя `MeshRenderer` и материалы.
Мы написали класс `MazeMeshGenerator` и создали его экземпляр в *MazeConstructor*, поэтому нажмите *Play*:
Мы построили затекстурированный четырёхугольник полностью с помощью кода! Это интересное и важное начало, поэтому прервитесь, чтобы проанализировать свою работу на этом этапе и понять, как работает код.
Далее мы довольно сильно рефакторизируем `FromData()`, заменив его полностью на такой код:
```
public Mesh FromData(int[,] data)
{
Mesh maze = new Mesh();
//3
List newVertices = new List();
List newUVs = new List();
maze.subMeshCount = 2;
List floorTriangles = new List();
List wallTriangles = new List();
int rMax = data.GetUpperBound(0);
int cMax = data.GetUpperBound(1);
float halfH = height \* .5f;
//4
for (int i = 0; i <= rMax; i++)
{
for (int j = 0; j <= cMax; j++)
{
if (data[i, j] != 1)
{
// floor
AddQuad(Matrix4x4.TRS(
new Vector3(j \* width, 0, i \* width),
Quaternion.LookRotation(Vector3.up),
new Vector3(width, width, 1)
), ref newVertices, ref newUVs, ref floorTriangles);
// ceiling
AddQuad(Matrix4x4.TRS(
new Vector3(j \* width, height, i \* width),
Quaternion.LookRotation(Vector3.down),
new Vector3(width, width, 1)
), ref newVertices, ref newUVs, ref floorTriangles);
// walls on sides next to blocked grid cells
if (i - 1 < 0 || data[i-1, j] == 1)
{
AddQuad(Matrix4x4.TRS(
new Vector3(j \* width, halfH, (i-.5f) \* width),
Quaternion.LookRotation(Vector3.forward),
new Vector3(width, height, 1)
), ref newVertices, ref newUVs, ref wallTriangles);
}
if (j + 1 > cMax || data[i, j+1] == 1)
{
AddQuad(Matrix4x4.TRS(
new Vector3((j+.5f) \* width, halfH, i \* width),
Quaternion.LookRotation(Vector3.left),
new Vector3(width, height, 1)
), ref newVertices, ref newUVs, ref wallTriangles);
}
if (j - 1 < 0 || data[i, j-1] == 1)
{
AddQuad(Matrix4x4.TRS(
new Vector3((j-.5f) \* width, halfH, i \* width),
Quaternion.LookRotation(Vector3.right),
new Vector3(width, height, 1)
), ref newVertices, ref newUVs, ref wallTriangles);
}
if (i + 1 > rMax || data[i+1, j] == 1)
{
AddQuad(Matrix4x4.TRS(
new Vector3(j \* width, halfH, (i+.5f) \* width),
Quaternion.LookRotation(Vector3.back),
new Vector3(width, height, 1)
), ref newVertices, ref newUVs, ref wallTriangles);
}
}
}
}
maze.vertices = newVertices.ToArray();
maze.uv = newUVs.ToArray();
maze.SetTriangles(floorTriangles.ToArray(), 0);
maze.SetTriangles(wallTriangles.ToArray(), 1);
//5
maze.RecalculateNormals();
return maze;
}
//1, 2
private void AddQuad(Matrix4x4 matrix, ref List newVertices,
ref List newUVs, ref List newTriangles)
{
int index = newVertices.Count;
// corners before transforming
Vector3 vert1 = new Vector3(-.5f, -.5f, 0);
Vector3 vert2 = new Vector3(-.5f, .5f, 0);
Vector3 vert3 = new Vector3(.5f, .5f, 0);
Vector3 vert4 = new Vector3(.5f, -.5f, 0);
newVertices.Add(matrix.MultiplyPoint3x4(vert1));
newVertices.Add(matrix.MultiplyPoint3x4(vert2));
newVertices.Add(matrix.MultiplyPoint3x4(vert3));
newVertices.Add(matrix.MultiplyPoint3x4(vert4));
newUVs.Add(new Vector2(1, 0));
newUVs.Add(new Vector2(1, 1));
newUVs.Add(new Vector2(0, 1));
newUVs.Add(new Vector2(0, 0));
newTriangles.Add(index+2);
newTriangles.Add(index+1);
newTriangles.Add(index);
newTriangles.Add(index+3);
newTriangles.Add(index+2);
newTriangles.Add(index);
}
```
Ого, какой *длинный* кусок кода! Но здесь снова повторяется почти одно и то же, только меняются некоторые числа. В частности, код генерирования четырёхугольника перемещён в отдельный метод `AddQuad()` для его повторного вызова для пола, потолка и стен каждой ячейки сетки.
1. Последние три параметра `AddQuad()` — это всё тот же список вершин, UV и треугольников. Первая строка метода получает индекс, с которого нужно начинать. При добавлении новых четырёхугольников индекс будет увеличиваться.
2. Однако первый параметр `AddQuad()` — это матрица преобразований, и эта часть может быть сложной для понимания. По сути, положение/поворот/масштаб может храниться в виде матрицы, а затем применяться к вершинам. Именно это делает вызов `MultiplyPoint3x4()`. Таким образом, код генерирования четырёхугольника можно использовать для полов, потолков, стен и т.д. Нам достаточно лишь изменять используемую матрицу преобразований!
3. Вернёмся к `FromData()`. Списки для вершин UV и треугольников создаются в верхней части. На этот раз у нас есть *два* списка треугольников. Объект `Mesh` Unity может иметь множество подмешей с различными материалами на каждом, то есть каждый список треугольников является отдельным подмешем. Мы объявляем два подмеша, чтобы можно было назначить разные материалы полу и стенам.
4. После этого мы проходим по 2D-массиву и создаём четырёхугольники для пола, потолка и стен в каждой ячейке сетки. Каждой ячейке нужен пол и потолок, кроме того, выполняются проверки соседних ячеек на необходимость стен. Заметьте, что `AddQuad()` вызывается несколько раз, но каждый раз с другой матрицей преобразований и разными списками треугольников, используемыми для полов и стен. Также заметьте, что для определения расположения и размеров четырёхугольников используются `width` и `height`.
5. О, и ещё небольшое дополнение: `RecalculateNormals()` подготавливает меш к освещению.
Нажмите Play, чтобы увидеть, как генерируется весь меш:
Поздравляю, на этом мы закончили с генерированием лабиринта и с основной частью программирования, необходимого для *Speedy Treasure Thief*! В следующем разделе мы рассмотрим оставшуюся часть игры.
Завершаем игру
--------------
Нам нужно внести в код и другие дополнения и изменения, но сначала давайте используем то, что находилось в заготовке проекта. Как я упоминал во введении, в заготовке проекта находятся два скрипта, сцена с игроком и UI, а также вся графика для игры с лабиринтом. Скрипт *FpsMovement* — это просто односкриптовая версия контроллера персонажа из [моей книги](https://www.amazon.com/gp/product/1617294969), а *TriggerEventRouter* — это вспомогательный код, удобный работы с триггерами игры.
В сцене уже настроен игрок, в том числе у него есть компонент *FpsMovement* и
к камере присоединён направленный источник света. Кроме того, в окне *Lighting Settings* отключены скайбокс и окружающее освещение. Наконец, в сцене есть холст UI с метками для очков и времени.
И это всё, что есть в заготовке проекта. Теперь мы напишем оставшийся код для игры.
Начнём с *MazeConstructor*. Для начала добавим следующие свойства для хранения размеров и координат:
```
public float hallWidth
{
get; private set;
}
public float hallHeight
{
get; private set;
}
public int startRow
{
get; private set;
}
public int startCol
{
get; private set;
}
public int goalRow
{
get; private set;
}
public int goalCol
{
get; private set;
}
```
Теперь нужно добавить новые методы. Первый — это `DisposeOldMaze()`; как понятно из названия, он удаляет существующий лабиринт. Код находит все объекты с тэгом *Generated* и уничтожает их.
```
public void DisposeOldMaze()
{
GameObject[] objects = GameObject.FindGameObjectsWithTag("Generated");
foreach (GameObject go in objects) {
Destroy(go);
}
}
```
Следующим мы добавим метод `FindStartPosition()`. Этот код начинает с 0,0 и проходит по всем данных лабиринта, пока не находит открытое пространство. Затем эти координаты сохраняются как начальная позиция лабиринта.
```
private void FindStartPosition()
{
int[,] maze = data;
int rMax = maze.GetUpperBound(0);
int cMax = maze.GetUpperBound(1);
for (int i = 0; i <= rMax; i++)
{
for (int j = 0; j <= cMax; j++)
{
if (maze[i, j] == 0)
{
startRow = i;
startCol = j;
return;
}
}
}
}
```
Аналогично, `FindGoalPosition()` по сути делает то же самое, только начинает с максимальных значений и выполняет обратный отсчёт. Добавим и этот метод тоже.
```
private void FindGoalPosition()
{
int[,] maze = data;
int rMax = maze.GetUpperBound(0);
int cMax = maze.GetUpperBound(1);
// loop top to bottom, right to left
for (int i = rMax; i >= 0; i--)
{
for (int j = cMax; j >= 0; j--)
{
if (maze[i, j] == 0)
{
goalRow = i;
goalCol = j;
return;
}
}
}
}
```
`PlaceStartTrigger()` и `PlaceGoalTrigger()` размещают объекты в сцене в позициях начала и цели. Их коллайдер является триггером, применяется соответствующий материал, а затем добавляется *TriggerEventRouter* (из заготовки проекта). Этот компонент получает функцию обработки события, которая вызывается, когда что-то входит в объём триггера. Добавим и эти два метода.
```
private void PlaceStartTrigger(TriggerEventHandler callback)
{
GameObject go = GameObject.CreatePrimitive(PrimitiveType.Cube);
go.transform.position = new Vector3(startCol * hallWidth, .5f, startRow * hallWidth);
go.name = "Start Trigger";
go.tag = "Generated";
go.GetComponent().isTrigger = true;
go.GetComponent().sharedMaterial = startMat;
TriggerEventRouter tc = go.AddComponent();
tc.callback = callback;
}
private void PlaceGoalTrigger(TriggerEventHandler callback)
{
GameObject go = GameObject.CreatePrimitive(PrimitiveType.Cube);
go.transform.position = new Vector3(goalCol \* hallWidth, .5f, goalRow \* hallWidth);
go.name = "Treasure";
go.tag = "Generated";
go.GetComponent().isTrigger = true;
go.GetComponent().sharedMaterial = treasureMat;
TriggerEventRouter tc = go.AddComponent();
tc.callback = callback;
}
```
Наконец, заменим весь метод `GenerateNewMaze()` следующим кодом:
```
public void GenerateNewMaze(int sizeRows, int sizeCols,
TriggerEventHandler startCallback=null, TriggerEventHandler goalCallback=null)
{
if (sizeRows % 2 == 0 && sizeCols % 2 == 0)
{
Debug.LogError("Odd numbers work better for dungeon size.");
}
DisposeOldMaze();
data = dataGenerator.FromDimensions(sizeRows, sizeCols);
FindStartPosition();
FindGoalPosition();
// store values used to generate this mesh
hallWidth = meshGenerator.width;
hallHeight = meshGenerator.height;
DisplayMaze();
PlaceStartTrigger(startCallback);
PlaceGoalTrigger(goalCallback);
}
```
Переписанный `GenerateNewMaze()` вызывает новые методы, которые мы только что добавили, для таких операций, как удаление старого меша и расположение триггеров.
Мы уже многое добавили в *MazeConstructor*, отличная работа! К счастью, с этим классом мы закончили. Остался ещё один фрагмент кода.
Теперь добавим новый код в *GameController*. Заменим всё содержимое файла следующим:
```
using System;
using UnityEngine;
using UnityEngine.UI;
[RequireComponent(typeof(MazeConstructor))]
public class GameController : MonoBehaviour
{
//1
[SerializeField] private FpsMovement player;
[SerializeField] private Text timeLabel;
[SerializeField] private Text scoreLabel;
private MazeConstructor generator;
//2
private DateTime startTime;
private int timeLimit;
private int reduceLimitBy;
private int score;
private bool goalReached;
//3
void Start() {
generator = GetComponent();
StartNewGame();
}
//4
private void StartNewGame()
{
timeLimit = 80;
reduceLimitBy = 5;
startTime = DateTime.Now;
score = 0;
scoreLabel.text = score.ToString();
StartNewMaze();
}
//5
private void StartNewMaze()
{
generator.GenerateNewMaze(13, 15, OnStartTrigger, OnGoalTrigger);
float x = generator.startCol \* generator.hallWidth;
float y = 1;
float z = generator.startRow \* generator.hallWidth;
player.transform.position = new Vector3(x, y, z);
goalReached = false;
player.enabled = true;
// restart timer
timeLimit -= reduceLimitBy;
startTime = DateTime.Now;
}
//6
void Update()
{
if (!player.enabled)
{
return;
}
int timeUsed = (int)(DateTime.Now - startTime).TotalSeconds;
int timeLeft = timeLimit - timeUsed;
if (timeLeft > 0)
{
timeLabel.text = timeLeft.ToString();
}
else
{
timeLabel.text = "TIME UP";
player.enabled = false;
Invoke("StartNewGame", 4);
}
}
//7
private void OnGoalTrigger(GameObject trigger, GameObject other)
{
Debug.Log("Goal!");
goalReached = true;
score += 1;
scoreLabel.text = score.ToString();
Destroy(trigger);
}
private void OnStartTrigger(GameObject trigger, GameObject other)
{
if (goalReached)
{
Debug.Log("Finish!");
player.enabled = false;
Invoke("StartNewMaze", 4);
}
}
}
```
1. Первое, что мы добавили — сериализованные поля для объектов в сцене.
2. Добавлено несколько частных переменных для отслеживания таймера и очков игры, а также того, найдена ли цель в лабиринте.
3. `MazeConstructor` инициализируется так же, как и раньше, но теперь `Start()` использует новые методы, которые не просто вызывают `GenerateNewMaze()`.
4. `StartNewGame()` используется для запуска всей игры сначала, а не для переключения уровней *внутри* игры. Таймеру присваиваются исходные значения, очки сбрасываются, после чего создаётся лабиринт.
5. `StartNewMaze()` переходит к новому уровню, не перезапуская заново всю игру. Кроме создания нового лабиринта, этот метод располагает игрока в начальной точке, сбрасывает цель и снижает лимит времени.
6. `Update()` проверяет, активен ли игрок, а затем обновляет время, оставшееся на прохождение уровня. После завершения времени игрок деактивируется и начинается новая игра.
7. `OnGoalTrigger()` и `OnStartTrigger()` — это функции обработки событий, передаваемые *TriggerEventRouter* в *MazeConstructor*. `OnGoalTrigger()` записывает, что цель была найдена, а затем увеличивает количество очков. `OnStartTrigger()` проверяет, найдена ли цель, и если это так, то деактивирует игрока и запускает новый лабиринт.
И это весь код. Теперь вернёмся к сцене в Unity. Для начала выберите *Canvas* в окне *Hierarchy* и включите его в Inspector. Canvas был отключен, чтобы не мешать отображению отладки при создании кода лабиринта. Не забывайте, что добавлены сериализованные поля, так что перетащите их объекты сцены (*Player*, метку *Time* из Canvas и метку *Score*) в слоты в Inspector. Также можно отключить *Show Debug*, а затем нажать на Play:
Отличная работа! Процедурная генерация лабиринтов может быть сложной задачей, но в результате мы получаем захватывающий и динамичный игровой процесс.
Куда двигаться дальше?
----------------------
Если вы повторяли за мной, то уже создали готовую игру. Если хотите, можете скачать [отсюда](https://koenig-media.raywenderlich.com/uploads/2017/11/proc-maze-tutorial.zip) готовый проект Unity.
Далее вы можете исследовать другие алгоритмы генерации лабиринтов, заменив код в `FromDimensions()`. Также можно попробовать генерировать другие окружения; начните с изучения [генерирования пещер с помощью клеточных автоматов](https://www.raywenderlich.com/66062/procedural-level-generation-games-using-cellular-automaton-part-1).
Случайная генерация предметов и врагов на карте может оказаться очень интересным занятием! | https://habr.com/ru/post/353104/ | null | ru | null |
# Автоматическая установка и настройка PostgreSQL при помощи Wix#
Привет Хабр!
В связи со сложностью проекта, над которым я сейчас работаю, появилась необходимость развертывания и настройки PostgreSQL на каждой машине клиента. Клиентов у нашей компании много, поэтому было решено автоматизировать процесс настройки PostgreSQL и создать MSI инсталлятор.
Недавно на хабре я прочитал переводную статью про Wix #, о нем и пойдет речь.
Как уже было сказано в [статье](http://habrahabr.ru/post/253819/), Wix # — это часть движка с открытым кодом, позволяющего выполнять C# скрипты.
После [загрузки](https://wixsharp.codeplex.com) Wix # в архиве можно обнаружить множество примеров, начиная с простого копирования файлов и создания ярлыков на рабочем столе и заканчивая собственными диалогами для инсталлятора на WPF.
**Задача состоит в следующем**:
На первых двух пунктах подробно останавливаться не будем, все есть в примерах. Для настройки СУБД требуется заменить файл pg\_hba.conf, импортировать базу данных из сохраненной копии. Все это нужно сделать без участия пользователя, запустившего инсталлятор.
Первым делом создаем простой инсталлятор для разворачивания проекта. Далее расскажу как сделать такой инсталлятор на примере Visual Studio, хотя это совсем необязательно — можно использовать любой текстовый редактор.
Cоздаем простое консольное приложение на C#,
и устанавливаем для решения WixSharp через менеджер проектов NuGet.
Перед началом установки пользователю обычно предлагается несколько компонентов для инсталляции на выбор, в Wix# для этого существует объект **Feature**.
Создаем компоненты для установки,
```
Feature fSoftware = new Feature("<Ваше ПО>");
Feature fPostgreSQL = new Feature("Настройка PostgreSQL");
// у этого объекта много разных интересных свойств,
// например, их можно сделать вложенными и тд, добавим описания
fSoftware.Description = "Установка программного обеспечения";
fPostgreSQL.Description = "Установка и настройка PostgreSQL";
```
В Wix# существуют разные объекты для построения проектов, например, Project или ManagedProject. Последний отличается тем, что к нему можно добавить свой код на C#, который будет выполнен в процессе установки.
Определим каталог, где будут находиться файлы, включенные в пакет инсталлятора.
```
var filesPath =Path.Combine(
Path.GetFullPath(
Path.Combine(System.Reflection.Assembly
.GetExecutingAssembly().Location, @"..\..\..\")), "Files");
```
Создаем объект проекта и описываем необходимые файлы для установки.
```
var project = new ManagedProject("Название вашего ПО",
// Id не обязателен, но может пригодиться
// если использовать Custom Actions и тп
new Dir(new Id("INSTALL_DIR"), @"%ProgramFiles%\<Ваше ПО>",
// копируем все файлы из папки с устанавливаемым ПО
new Files(fSoftware, Path.Combine(
filesPath, @"<Папка с файлами вашего ПО>\*.*"))),
// PostgreSQL будем устанавливать в папку С:\PostgreSQL
// (можно выбрать любую другую)
// установщик должен лежать в папке с файлами для установки
new Dir("C:\PostgreSQL",
// копируем установщик
new WixSharp.File(fServer,
Path.Combine(filesPath, @"postgresqlwin.exe")),
// дамп БД
new WixSharp.File(fServer,
Path.Combine(filesPath, @"database.backup")),
// настройки конфигурации
new WixSharp.File(fServer,
Path.Combine(filesPath, @"pg_hba.conf")),
// BAT-файл (см ниже)
new WixSharp.File(fServer,
Path.Combine(filesPath, @"installDB.bat")))
);
```
Для того, чтобы произвести различные действия после или во время установки в Wix# существуют богатые возможности — например, если необходимо установить ReportViewer, то в тело проекта необходимо добавить:
```
new InstalledFileAction("ReportViewer.exe", "/q", Return.asyncNoWait, When.After, Step.InstallFinalize, Condition.NOT_Installed)
```
Для установки и настройки PostgreSQL можно так же использовать InstalledFileAction и другие, но из-за множества команд, которые необходимо выполнить, решено сделать BAT-файл **InstallDB.bat**:
```
# устанавливаем пароль в переменной среды для PostgreSQL
SET PGPASSWORD=123456
# добавляем базу данных
C:\PostgreSQL\bin\createdb.exe --host localhost --port 5432 --username "postgres" --no-password <Имя Вашей БД>
# импортируем БД
C:\PostgreSQL\bin\pg_restore.exe --host localhost --port 5432 --username "postgres" --dbname "Имя Вашей БД" --role "postgres" --no-password --verbose "C:\PostgreSQL\database.backup"
```
Далее проект необходимо настроить:
```
project.ControlPanelInfo.Manufacturer = "<Название Вашей компании>";
project.GUID = new Guid("{F1CC4E21-0326-4107-BB5C-A834EAEF6DAE}");
project.LicenceFile = Path.Combine(filesPath, @"License.rtf");
project.UI = WUI.WixUI_Mondo;
project.Language = "ru-RU";
project.OutFileName = "SetUp";
// проверка на .Net Framework 4.0
project.SetNetFxPrerequisite("NETFRAMEWORK40FULL >= '#1'",
"Пожалуйста, установите .NET Framework 4.0.");
project.PreserveTempFiles = true;
project.DefaultFeature = fSoftware;
project.Version = new Version("1.0.0.1");
project.AfterInstall += AfterInstall;
Compiler.BuildMsi(project);
```
Теперь для события AfterInstall можно написать Custom Action для запуска установки и настройки PostgreSQL:
```
private static void AfterInstall(SetupEventArgs e)
{
try
{
if ((e.Mode == SetupEventArgs.SetupMode.Installing) || (e.Mode == SetupEventArgs.SetupMode.Modifying))
{
if (System.IO.File.Exists(@"C:\PostgreSQL\postgresqlwin.exe"))
{
var process = new Process();
process.StartInfo = new ProcessStartInfo(@"C:\PostgreSQL\postgresqlwin.exe", @"--prefix C:\PostgreSQL --mode unattended --datadir C:\PostgreSQL\data --superpassword 123456 --install_runtimes 0");
process.Start();
process.WaitForExit();
System.IO.File.Delete(@"C:\PostgreSQL\postgresqlwin.exe");
}
if (System.IO.File.Exists(@"C:\PostgreSQL\pg_hba.conf"))
{
System.IO.File.Copy(@"C:\PostgreSQL\pg_hba.conf", @"C:\PostgreSQL\data\pg_hba.conf", true);
System.IO.File.Delete(@"C:\PostgreSQL\pg_hba.conf");
}
if (System.IO.File.Exists(@"C:\PostgreSQL\database.backup"))
{
if (System.IO.File.Exists(@"C:\PostgreSQL\installDB.bat"))
{
var pgProcess = new Process();
pgProcess.StartInfo = new ProcessStartInfo(@"C:\PostgreSQL\installDB.bat", "")
{
CreateNoWindow = true,
UseShellExecute = false
};
pgProcess.Start();
pgProcess.WaitForExit();
System.IO.File.Delete(@"C:\PostgreSQL\installDB.bat");
}
else
return;
System.IO.File.Delete(@"C:\PostgreSQL\database.backup");
}
}
}
catch (Exception ex)
{
System.Windows.MessageBox.Show(" Ошибка установки: " + ex.ToString());
}
}
```
Как вариант, можно было бы скопировать установщик PostgreSQL во временную папку и запускать установку из нее.
При помощи таких простых действий PostgreSQL будет автоматически настроен для вашего ПО.
Однако, есть моменты, которые в Wix# мне не понравились:
1) Поддержка только .NET Framework 3.5
2) Вообще в Wix — невозможно запустить установщик MSI из своего установщика, для этого нужно использовать расширения WIX, что усложняет задачу. Именно поэтому ReportViewer пришлось устанавливать после завершения установки.
3) Почему то возникает проблема с таким кодом:
```
new Dir(@"C:\Test1", ..файлы),
new Dir(@"C:\Test2", ..файлы)
```
Не собирается, выдается ошибка о недопустимом пути. Если оставить только одну папку, то все работает.
Следующий код работает, но частично:
```
new Dir(@"C:\Test",
new Dir(@"Test1", файлы для feature1),
new Dir(@"Test2", файлы для feature2),
)
```
По идее, в каталоги Test1 и Test2 должны быть скопированы файлы, что и происходит, если при установке выбрать feature1 и feature2.
А если при установке выбрать только feature1, а затем добавить feature2 (Изменить установку), то папки Test2 не появится — вместо нее будет папка ABSOLUTEPATH с файлами для feature2.
Наверняка в моем скрипте что-то не было учтено.
В целом, Wix# мне понравился, особенно, если необходимо быстро сделать инсталлятор, не погружаясь в XML для WIX.
Источники:
1. [Переводная статья про Wix #](http://habrahabr.ru/post/253819/)
2. [Пошаговая инструкция по настройке разных средств разработки для Wix #](https://wixsharp.codeplex.com/wikipage?title=Building%20MSI%20with%20WixSharp%20%E2%80%93%20Step%20by%20step%20tutorial) | https://habr.com/ru/post/276175/ | null | ru | null |
# Теневые стеки для пользовательского пространства
Стек вызовов (call stack) является излюбленной целью злоумышленников, пытающихся скомпрометировать запущенный процесс; если злоумышленник найдет способ перезаписать адрес возврата в стеке, то он сможет перенаправить управление на код по своему выбору, что приведет к ситуации, которую лучше всего можно описать фразой "game over". Именно поэтому для защиты стека прикладывается очень много усилий. Одним из самых многообещающих методов является “теневой стек” (shadow stack); как следствие, множество различных процессоров должным образом поддерживают теневые стеки. С поддержкой защиты программ пользовательского пространства (user-space) с помощью теневых стеков дела обстоят не так хорошо; в настоящий момент она является предметом обсуждения в сообществе разработчиков ядра, но добавить эту функцию сложнее, чем может показаться на первый взгляд. Среди прочего, подобные патчи существуют уже достаточно долго, чтобы у них самих появились собственные проблемы с обратной совместимостью.
### Основы теневых стеков
Всякий раз, когда одна функция вызывает другую, в стек вызовов помещается информация о вызываемой функции, куда входят все параметры и адрес, по которому функция должна совершить возврат после выполнения своей работы. По мере углубления цепочки вызовов цепочка адресов возврата в стеке очень быстро разрастается. Обычно все работает без нареканий, но любое повреждение стека может привести к перезаписи одного или нескольких адресов возврата; что, в свою очередь, приведет к “возвращению” выполнения в непреднамеренное место. Если повезет, то это приведет к сбою приложения; но если же скомпрометированы данные были помещены туда преднамеренно, вместо этого выполнение может продолжиться таким образом, что это приведет к куда более худшим последствиям.
Теневые стеки задуманы с целью предупредить эту проблему, создавая вторую копию стека, которая (обычно) содержит только данные адресов возврата. Всякий раз, когда вызывается функция, адрес возврата помещается как в обычный стек, так и в теневой стек. Когда эта функция возвращает выполнение, адреса возврата извлекаются из обоих стеков и сравниваются; если они не совпадают, система переходит в режим повышенной боеготовности и (скорее всего) убивает вовлеченный процесс. Теневые стеки могут быть полностью реализованы программным обеспечением; даже если теневой стек доступен для записи, это сильно поднимает планку для злоумышленника, который теперь должен повредить две области памяти, одна из которых находится в произвольном месте. Однако аппаратная поддержка может значительно усилить теневые стеки.
Процессоры Intel, помимо всего остального, обеспечивают такую поддержку. Если теневой стек был подключен (что является привилегированной операцией), помещение адресов возврата в этот стек и сравнение при возврате функции выполняются самим процессором. Такой теневой стек обычно не доступен для записи из приложения (кроме как с помощью инструкций вызова функции и возврата) и, следовательно, не может быть скомпрометирован злоумышленником. Аппаратная поддержка также предполагает наличие специального "токена восстановления" (restore token) для теневого стека, который, среди прочего, гарантирует, что два процесса не смогут использовать один и тот же теневой стек — ситуация, которая, опять же, облегчила бы атаку.
### Поддержка теневых стеков пользовательского пространства
Актуальная версия патчей для поддержки теневых стеков была [опубликована Риком Эджкомбом](https://lwn.net/ml/linux-kernel/20220130211838.8382-1-rick.p.edgecombe@intel.com/) (Rick Edgecombe); большая часть самих патчей была написана Ю-ченг Ю (Yu-cheng Yu), которым уже было опубликовано множество более ранних версий этой работы. Для подключения этой функции требуется 35 нетривиальных патчей, но и они еще не решают проблему полностью. Кто-то может задаться вопросом, почему это так сложно, ведь теневые стеки производят впечатление функционала, который почти всегда может быть просто проигнорирован большей частью кода. Но жизнь никогда не бывает такой простой.
Как и следовало ожидать, ядро должно содержать код для управления теневыми стеками пользовательского пространства. Сюда входит включение этой функции на уровне процессора и передача ее для каждого конкретного процесса. Каждому процессу требуется собственный теневой стек с соответствующим токеном восстановления, а затем на него должен быть нацелен (привилегированный) регистр с указателем на теневой стек. Также нужно обрабатывать ошибки: как обычные отказы страниц (page faults), так и такие вещи, как обнаружение нарушения целостности (integrity-violation traps). И еще больше информации, которой нужно управлять при переключении контекста. Это все довольно стандартно для новой функции такого рода.
Память, выделенная под сам теневой стек, должна обрабатываться особым образом. Она принадлежит пользовательскому пространству, но код пользовательского пространства обычно не должен иметь права производить в нее запись. Также процессору нужно как-то распознавать память, выделенную для теневых стеков, поэтому они должны быть помечены специальным образом в таблице страниц, и здесь все становится немного интереснее. В каждой записи в таблице страниц (page-table entry — PTE) отведено несколько битов для описания применяемых средств защиты и других различных типов состояния, но архитектура x86 не включает бит “это страница теневого стека”. Но все-таки *есть* некоторые биты PTE, зарезервированные для использования операционной системой; Linux не использует их все и мог бы выделить один для этой цели, но очевидно, что некоторые другие операционные системы не располагают свободными битами PTE, поэтому присвоение одного из них в наших целях не приветствуется.
Решение, к которому пришли инженеры по аппаратному обеспечению, вполне можно назвать хаком. Если бит разрешения записи (write-enable) страницы сброшен (указывает на то, что запись невозможна), но установлен ее грязный (dirty) бит (указывает, что на нее *была* произведена запись), процессор сделает вывод, что рассматриваемая страница является частью теневого стека. Это комбинация параметров при стандартной эксплуатации не имеет смысла, поэтому, очевидно, что данное решение выглядело хорошим выходом из этой ситуации.
К сожалению, разработчики ядра Linux уже успели прийти к такому же выводу много лет назад, поэтому у Linux есть своя интерпретация этой комбинации битов PTE. Именно так ядро помечает страницы для копирования при записи (copy-on-write). Отсутствие доступа для записи вызовет ловушку, если процесс попытается записать страницу; наличие грязного бита укажет ядру сделать копию страницы и предоставить процессу к ней доступ для записи. И все работает как надо, если только процессор не применяет собственную интерпретацию этой комбинации битов. Так что большая часть патчей, о которых мы говорили выше, сосредоточена на захвате одного из этих неиспользуемых битов PTE для нового флага \_PAGE\_COW и обеспечении его использования управляющим памятью кодом.
Сложности, которые приносят теневые стеки на этом не заканчиваются. Если процесс вызывает [clone()](https://man7.org/linux/man-pages/man2/clone.2.html), для дочернего процесса должен быть выделен новый теневой стек; ядро выполняет эту задачу автоматически. Сигналы, как всегда, добавляют свои сложности, так как они уже включают в себя различные манипуляции со стеком. Дела обстоят еще хуже, если процесс установил альтернативный стек для обработчиков сигналов с помощью [sigaltstack()](https://man7.org/linux/man-pages/man2/sigaltstack.2.html) — до такой степени, что текущий набор патчей вообще не обрабатывает этот случай. Именно из таких деталей (и не только) и формируется длинная серия патчей.
### Проблемы с ABI
Использование теневых стеков должно быть полностью прозрачным для большинства приложений; в конце концов, разработчики редко продумывают все нюансы касательно стека вызовов в своей работе. Но всегда будут приложения, которые делают со своими стеками достаточно сложные вещи, начиная с многопоточных программ, которые явно управляют областью стека для каждого потока. Другие программы могут помещать в стек свои собственные специально созданные “[переходники](https://en.wikipedia.org/wiki/Thunk)” (thunks). Без особой осторожности все эти приложения будут ломаться, если они внезапно будут настроены для работы с теневым стеком. Такого рода массовая регрессия, как правило, делает средства защиты непопулярными, поэтому были приняты различные меры, чтобы избежать этого.
Тщательно продуманный план, к которому в результате пришли разработчики, заключался в том, чтобы пометить приложения (специальным свойством в разделе ELF .note.gnu.property), которые готовы к работе с теневыми стеками. Приложения, которые не предполагают никаких замысловатых манипуляций со стеком, могут быть просто перестроены и впоследствии запущены с теневыми стеками. Для более сложных случаев был определен набор операций [arch\_prctl()](https://man7.org/linux/man-pages/man2/arch_prctl.2.html), позволяющий явно манипулировать теневыми стеками. Библиотека GNU C была расширена, чтобы использовать эти вызовы для правильной настройки среды при запуске приложения, а ядро включало теневые стеки всякий раз, когда запускалась соответствующим образом помеченная программа. Некоторые дистрибутивы, включая Fedora и Ubuntu, создают свои двоичные файлы для теневых стеков; все, что им нужно, — это правильно оборудованное для работы с дополнительной степенью защиты ядро.
Всегда опасно выпускать код, использующий функции ядра, которые еще не приняты и не замержены; теневые стеки оказываются ярким примером почему. Согласно сопроводительному письму к текущей серии, API `arch_prctl()` был “заброшен по причине своей странности”. Но исполняемые файлы, готовые к работе с теневыми стеками, которые уже были развернуты в системах по всему миру, создавались с расчетом на присутствие этого API, странного или нет; если ядро учитывает маркировку в файле ELF и подключает теневые стеки для этих программ, некоторые из них не будут работать. Это заставит системных администраторов по всему миру отключить теневые стеки по крайней мере до 2040 года, что скорее сведет на нет все усилия в рамках этого замысла.
Одним из самых очевидных способов обхода этой проблемы было бы не учитывать текущий маркер ELF для теневых стеков и вместо этого создать новый маркер для маркировки двоичных файлов с использованием интерфейса, фактически поддерживаемого ядром. Однако решение, которое было принято, заключалось в полном отстранении ядра от работы по распознаванию двоичных файлов с поддержкой теневых стеков и позволить библиотеке C позаботиться об этом. Таким образом, если эта версия ABI будет принята, ядро включит теневые стеки только если пользовательское пространство само запросит это.
### Предлагаемый интерфейс
Полный контроль над функциональностью теневого стека должен осуществляться с помощью вызова `arch_prctl()` (как это ни странно):
```
status = arch_prctl(ARCH_X86_FEATURE_ENABLE, ARCH_X86_FEATURE_SHSTK);
```
Также существует операция ARCH\_X86\_FEATURE\_DISABLE, которую можно использовать для отключения теневых стеков, и ARCH\_X86\_FEATURE\_LOCK для предотвращения будущих изменений.
Хотя большинству приложений не нужно беспокоиться о теневых стеках, некоторые из них должны иметь возможность создавать таковые. Приложения, использующие [makecontext()](https://man7.org/linux/man-pages/man3/makecontext.3.html) и подобные ей функции, являются ярким примером. Для создания теневого стека требуется поддержка ядра; связанная память должна включать токен восстановления, а специальные биты страницы должны быть установлены, как было описано выше. Для этой операции есть новый системный вызов:
```
void *map_shadow_stack(unsigned long size, unsigned int flags);
```
Желаемый размер стека передается как size. Для параметра flags есть только одно значение: SHADOW\_STACK\_SET\_TOKEN, чтобы запросить сохранение токена восстановления в стеке. Возвращаемое значение в случае успеха является адресом основания этого стека.
Для использования этого нового стека должна быть выполнена инструкция RSTORSSP для переключения на него, которая зачастую выполняется как часть переключения контекста пользовательского пространства между потоками. Эта инструкция выполнит необходимую проверку прав доступа к странице и токена восстановления перед переключением. Она также помечает токен в новом теневом стеке как уже занятый, предотвращая использование этого стека каким-либо другим процессом.
Приложениям, выполняющим особо сложные задачи, может потребоваться возможность записи в теневой стек. Это обычно не разрешено по очевидным причинам, но, как [отметил](https://lwn.net/ml/linux-kernel/20220130211838.8382-35-rick.p.edgecombe@intel.com/) Эджкомб, это “чересчур ограничивает любые приложения, которые потенциально могут захотеть делать какие-либо экзотические вещи за счет небольшой безопасности”. В таком экзотическом случае можно включить другую функцию (LINUX\_X86\_FEATURE\_WRSS) с помощью `arch_prctl()`; это, в свою очередь, включает инструкцию WRSS, которая может записывать в память теневого стека. Прямая запись в эту память путем разыменования указателя в этом случае по-прежнему запрещена.
### Что дальше?
Эта работа не так уж нова; ее ранняя версия была рассмотрена в [этой статье 2018 года](https://lwn.net/Articles/758245/). В предыдущем воплощении набор патчей для теневого стека дошел до [30-й версии](https://lwn.net/ml/linux-kernel/20210830181528.1569-1-yu-cheng.yu@intel.com/). Другая половина работы по обеспечению целостности потока управления (непрямое отслеживание ветвлений), которая дошла до [29-й версии](https://lwn.net/ml/linux-kernel/20210820182245.1188-1-yu-cheng.yu@intel.com/), на данный момент отложена (хотя Питер Зийлстра (Peter Zijlstra) как раз [представил](https://lwn.net/ml/linux-kernel/20220218164902.008644515@infradead.org/) отдельную реализацию). Есть надежда, что с новым разработчиком, возглавляющим работу, сокращением объема и некоторыми запрошенными изменениями, эта работа, наконец, сможет продвинуться в основную ветку.
Во многих отношениях похоже, что эта надежда может быть реализована. Несмотря на то, что есть комментарии к различным частям набора патчей, на данный момент, похоже, не было большого возражения против того, как они работают. Однако разработчики выразили обеспокоенность по поводу отсутствия поддержки альтернативных стеков сигналов. Это функция наверняка может понадобится в какой-то момент, поэтому было бы неплохо посмотреть, как она вписывается в общую картину, прежде чем эта функциональность будет замержена.
Также был [отдельный сабтред,](https://lwn.net/ml/linux-kernel/YgDIIpCm3UITk896@lisas.de/) посвященный проблемам с [Checkpoint/restore in user space](https://criu.org/Main_Page) (CRIU), которая использует множество закулисных трюков, чтобы выполнить свою работу. Часть процесса создания контрольной точки включает в себя внедрение кода-“паразита” в процесс, для которого создается контрольная точка, получение необходимой информации, а затем выполнение специального возврата из паразита для возобновления нормального выполнения. Это как раз тот вид вмешательства в поток управления, для предотвращения которого предназначены теневые стеки. Обсуждались различные возможные решения, но на данный момент ничего не вылилось в конкретный код. Решение этой проблемы также кажется необходимым, прежде чем можно будет замержить теневые стеки; как [сказал](https://lwn.net/ml/linux-kernel/87fsozek0j.ffs@tglx/) Томас Гляйкснер (Thomas Gleixner)[:](https://lwn.net/ml/linux-kernel/87fsozek0j.ffs@tglx/) “Мы не должны ломать системы CRIU обновлениями ядра”.
Наконец, диапазон поддерживаемого оборудования почти наверняка потребуется расширить. Некоторые процессоры AMD реализуют теневые стеки, очевидно, вполне совместимым образом, но в этом наборе патчей поддерживаются только процессоры Intel; в качестве причины указывается недостаток тестирования. Очевидно, что этим необходимо заняться, чтобы работа продолжалась. Теневые стеки также не поддерживаются в 32-разрядных системах; исправить это может быть сложно, и неясно, действительно ли существует мотивация для выполнения этой работы. Тем не менее, с поддержкой 32-битных систем или без нее, очевидно, что еще предстоит проделать большую работу, прежде чем этот код войдет в основную ветку. Не следует ожидать его появления в ближайшем будущем.
---
Приглашаем всех желающих на открытый урок «Введение в docker». На занятии мы рассмотрим основы контейнеризации и ее отличие от виртуализации, плавно перейдем к рассмотрению самого популярного на данный момент инструмента контейнеризации Docker — узнаем из каких основных компонентов и сущностей он состоит, и как они взаимодействуют между собой. [Регистрация по ссылке](https://otus.pw/3gh9/). | https://habr.com/ru/post/658491/ | null | ru | null |
# Joker 2020: продолжение сезона онлайн-конференций
Только что, c 25 по 28 ноября 2020 года, прошла Java-конференция [Joker 2020](https://jokerconf.com). Это уже второй сезон конференций, проводимых [JUG Ru Group](https://jugru.org) в формате онлайн.
В онлайн-формате конференция стала лучше или хуже? Что нового организаторами было придумано? Кого из спикеров с какими докладами можно было увидеть и услышать? Что полезного и интересного было в докладах? Имеет ли смысл посещать конференцию в следующем году?
[](https://habr.com/ru/company/jugru/blog/529984/)
Второй сезон онлайн-конференций: казалось бы, что ещё можно придумать, кроме возможности просмотра докладов при вынужденных ограничениях, наложенных пандемией? Теперь часть потенциальных посетителей (стремящихся преимущественно к получению новых знаний и свежей информации в области профессиональных интересов) конференцию по-прежнему посетит и билет купит, а другая часть (которую в большей степени привлекает личное общение) — увы, больше нет. Выхода из создавшейся ситуации нет или он всё же есть? Можно ли конференции стать по-прежнему привлекательной и для второй части участников конференций, которые жаждут социальности?
В [замечательной статье](https://habr.com/ru/company/jugru/blog/527900/) из [блога компании JUG Ru Group на Хабре](https://habr.com/ru/company/jugru/) Руслан [ARG89](https://habr.com/ru/users/arg89/) Ахметзянов постарался проанализировать ситуацию ([попробуйте оценить](https://habr.com/ru/company/jugru/blog/527900/), Вы в большей степени персонаж Саша или Женя в отношении конференций). Далее там же анонсируются дополнительные механики, добавленные в стриминговую платформу конференций для того, чтобы удовлетворить вкусы как можно большего числа участников. Удалось или нет достигнуть этим поставленных целей, постараемся разобраться далее.
В преддверии конференции также вышло 8 выпусков шоу [Вторая чашка кофе с Joker](https://www.youtube.com/watch?v=m9lXNzyists&list=PLVe-2wcL84b9Ajh-1-1S5Q-4kjRFMAdwL&ab_channel=JUG.ru), в которых в эфире ведущие успели взять интервью с Алексеем Фёдоровым, Дмитрием Чуйко, Александром Белокрыловым, Дмитрием Александровым, Олегом Шелаевым, Сергеем Егоровым, Евгением Борисовым и Тагиром Валеевым.
Так что же, собственно, сама-то конференция?
### Открытие
В проведение, открытие, закрытие каждой конференции организаторы раз за разом стараются привнести что-то новое. В данном случае открытие началось с импровизаций Алексея Фёдорова и Глеба Смирнова. На правом фото Алексей Фёдоров демонстрирует возможности игрового вида конференции (о нём рассказывается далее в отдельном разделе обзора).
[](https://habrastorage.org/webt/83/j_/pg/83j_pg8s3ht_by1ot7_nbvs9tug.jpeg)
Все виды прошедших активностей, связанных с донесением технической информации посредством слайдов и видео, можно было бы условно разделить на
* интервью;
* большие доклады;
* мини-доклады партнёров;
* воркшопы.
### Интервью
В интервью **Эволюция Java и Kotlin. Что нас ждет?**, взятом у **Романа Елизарова**, можно было узнать о пути развития языка программирования *Kotlin*. Накануне конференции [официально было объявлено](https://blog.jetbrains.com/kotlin/2020/11/roman-elizarov-is-the-new-project-lead-for-kotlin/) о передаче управления и координации работ по проекту *Kotlin* от Андрея Бреслава к Роману Елизарову. По этой причине особенно интересно было узнать мнение Романа и про его изменившийся круг обязанностей, и о возможных изменениях развития языка и платформы.
[](https://habrastorage.org/webt/66/ze/sj/66zesjnilbfq0fpn9xzk29ccl5u.jpeg)
**Зачем нужно знание многопоточной разработки в enterprise** — мини-интервью **Евгения** [phillennium](https://habr.com/ru/users/phillennium/) **Трифонова** с **Юрием Бабаком**, представителем компании-партнёра конференции. Любопытными показались разнообразные примеры из собственной практики, про которые Юрий живо и интересно рассказал в ответ на очень уместные вопросы Евгения.
**Адская кухня: Как приготовить новую версию Java и не отравить пользователей LTS релизов?** — мини-интервью с **Александром Белокрыловым** из компании [BellSoft](https://bell-sw.com), хорошо известной, вероятно, большинству по дистрибутиву [Liberica JDK](https://bell-sw.com/pages/libericajdk/). Новостью стала информация о [вхождении представителей компании в исполнительный комитет JCP](https://twitter.com/bellsoftware/status/1328851200243011588?s=20).
[](https://habrastorage.org/webt/sa/g6/xs/sag6xsjgg7sqq4aqpxr0o7hmrme.jpeg)
### Доклады
Доклад **Кирилла Тимофеева** под названием **JVM-профайлер, который смог (стать кроссплатформенным)** был про добавление поддержки *Windows* в [async-profiler](https://github.com/jvm-profiling-tools/async-profiler) при его использовании из среды разработки *IntelliJ IDEA*. Андрей Паньгин (поздравляем его с [присвоением звания Java Champion](https://twitter.com/Java_Champions/status/1328386739681984513?s=20) за неделю до конференции!) выступил в качестве приглашённого эксперта доклада. Отличный докладчик (автор Windows-порта), хороший доклад с глубоким пониманием темы, идеальный эксперт (автор оригинального продукта), полезная информация о скором появлении предмета обсуждения в составе *IntelliJ IDEA*.
[](https://habrastorage.org/webt/lq/sw/pu/lqswpupgxl0ihy1kx3e7utblens.jpeg)
Предполагаю, что абсолютное большинство видевших доклад и читающих данный обзор использует *Spring Boot* — как-никак это промышленный стандарт Java-разработки сегодня. «Толстый» («fat») JAR при использовании *Spring Boot* — также абсолютно распространённая практика. Рискну предположить, что **Владимир Плизга** со своим докладом **Spring Boot «fat» JAR: Тонкие части толстого артефакта** представил информацию, которая наиболее практически применима и востребована. Неплохо дополнили доклад три Андрея — Беляев, Когунь и Зарубин.
[](https://habrastorage.org/webt/s0/im/-u/s0im-ussl4qkkjaj-_jdrk3cbis.jpeg)
Доклад **Thread Safety with Phaser, StampedLock and VarHandle** от легендарного **Heinz Kabutz** (ведущий известнейшей рассылки [JavaSpecialists](https://www.javaspecialists.eu)) и его коллеги **John Green**. Просмотр данного доклада может быть полезен тем, что в нём акцентируется внимание на менее известных concurrency-классах *Phaser*, *StampedLock* и *VarHandle* (в отличие от многим знакомых классов *CountDownLatch* и *CyclicBarrier*).
[](https://habrastorage.org/webt/8k/op/24/8kop240d-8fwm1hrucsbih3q9kk.jpeg)
**Spring Patterns для взрослых** в исполнении (сначала буквально даже в сопровождении гитары) **Евгения Борисова**. Ничто не помешало в итоге Жене (ни разряжающаяся батарея ноутбука, ни стремительно заканчивающееся время) успешно завершить доклад. В отличие от привычных докладчику стиля и тем — технической жести, хардкора и расчленёнки (только библиотек и фреймворков, естественно) — речь в этот раз шла как раз о наиболее типовом использовании *Spring Framework*. Ещё один абсолютно практически применимый доклад в блестящем исполнении с рекомендацией к просмотру.
[](https://habrastorage.org/webt/hn/fn/dp/hnfndpy06q6nthz6cy-hrj16gmy.jpeg)
Доклад **Заменят ли роботы программистов?** от **Тагира Валеева** расстроил меня — вслед за докладчиком я тоже осознал, что «роботы» (библиотеки, сервисы, плагины) в значительной части уже заменили программистов. Частично успокаивает то, что ими автоматизируется наиболее неинтересная и рутинная часть работы программиста. Полезной и приятной частью в подобных докладах является информация о каких-то сервисах, которые можно будет попробовать после конференции. В случае доклада Тагира это информация о сервисах [Mergify](https://mergify.io) (есть [приложение для GitHub](https://github.com/marketplace/mergify)) для автоматизации принятия *pull request* и сервис [Diffblue](https://www.diffblue.com) (есть [плагин для IntelliJ IDEA](https://plugins.jetbrains.com/plugin/14946-diffblue-cover-community-edition--unit-test-generator)) для автоматизации создания unit-тестов (выглядит впечатляюще, надо попробовать). Полезный, интересный и даже неожиданно, не побоюсь этого слова, философский доклад.
[](https://habrastorage.org/webt/rx/mn/lq/rxmnlqpw1pd9l50ykubrmwrcjm8.jpeg)
### Мини-доклады партнёров
На мой взгляд, мини-доклады партнёров — очень удачная форма докладов, относительно коротких и информативных одновременно. **Подводные камни загрузчиков классов в Java и как они могут повлиять на скорость работы с XML** от **Ильи Ермолина** (слева) и **Как сказать «нет» архитектору? Советы по выбору размера микросервиса** в исполнении **Андрея Даминцева** (справа) являются примерами таких докладов.
[](https://habrastorage.org/webt/ia/ig/rp/iaigrpta0zo5enkatlcafwgtre0.jpeg)
В мини-докладе **Java Licensing Tips** от **Юрия Милютина** были, например, представлены волнующие многих теперь (после изменении компанией *Oracle* модели лицензирования) данные о сокращении (или даже исключении) расходов на лицензирование используемой в промышленной эксплуатации *Java*.
После мини-доклада **Самое время попробовать машинное обучение на Java** у **Артёма Селезнева** (фото справа) взял интервью **Евгений Трифонов**. В какой-то степени были развенчаны мифы (или хотя бы изменено мнение) о слабой применимости Java для машинного обучения.
[](https://habrastorage.org/webt/op/1z/hb/op1zhbw10mlrbbxntcx324zkrls.jpeg)
### Воркшопы
Ещё одна замечательная форма донесения технической информации — воркшопы (мастер-классы). Их на конференции было два: **GraalVM** (его проводил **Thomas Wuerthinger** с **Олегом Шелаевым**) и **Хватит писать тесты, пора писать спецификации!** (воркшоп вёл **Алексей Нестеров**).
Во время просмотра конференции выбор пал на второй воркшоп. Алексей работает в **VMware** (ex-**Pivotal Labs**) в команде **Spring Cloud Commerical** и является очень известной личностью, в настоящий момент он — один из соведущих популярнейшего [подкаста Радио-Т](https://radio-t.com/about/) (т.н. «Алексей второй» и «Алексей добрый», в отличие от Алексея Абашева).
Воркшоп на конференциях *JUG Ru Group* обычно разбит на две части и суммарно занимает один конференционный день, к чему надо быть готовым. Для демонстрации написания тестов использовался проект в [репозитории](https://github.com/alek-sys/animal-rescue-tdd) (если используете *Windows*, то дополнительно придётся изменить две строчки в файле `frontend/package.json`). Высококвалифицированный приятный инструктор-докладчик, возможность спокойно покопаться в проекте на своём привычном рабочем месте, настоятельно рекомендую.
[](https://habrastorage.org/webt/ec/m7/nv/ecm7nv3w7pp2ipub1d8de_hrx0w.jpeg)
### Сайт
Сайт онлайн-платформы для стриминга конференций, как уже говорилось ранее, претерпел существенные изменения. Имеющаяся функциональность была значительно расширена. Кроме добавления удобства существующим возможностям (например, изменение скорости воспроизведения и возможность «догнать» текущее время доклада), появился совершенно новый «игровой» вид конференции. Участник конференции может выбрать персонажа и совершать виртуальную прогулку по разным локациям.
Слева представлен общий план возможных локаций, справа — локация «Холл».
[](https://habrastorage.org/webt/ez/5t/p4/ez5tp4jctoxhq1wyyisqjl6ukbk.jpeg)
Далее локация «Улица» — слева, «Партнёрская выставка» — справа. При приближении к персонажам других людей внизу появляется видео рядом расположенных субъектов с возможностью диалога. Наверное, следующим шагом могут стать VR-шлемы и трёхмерное пространство выставки с видом от первого лица.
[](https://habrastorage.org/webt/zf/fq/3d/zffq3dyjpprnuetmeg95k1lguoc.jpeg)
### Просмотр информации о конференциях и игра
В обзорах [предыдущих](https://habr.com/ru/company/jugru/blog/473550/) [конференций](https://habr.com/ru/company/jugru/blog/508594/) уже рассказывалось про приложение, доступное на сайте [jugspeakers.info](https://jugspeakers.info) (репозиторий с кодом [находится на GitHub](https://github.com/JugruGroup/guess-game)). Приложение состоит из двух частей:
1. Просмотр информации о конференциях *JUG Ru Group* и *JUG*-митапах (с поиском данных о конференциях, спикерах, докладах, просмотром видео докладов и презентаций).
2. Игра «Угадай спикера».
Первая часть приложения была дополнена возможностью просмотра статистики по компаниям, к которым относятся спикеры *на момент последнего доклада или в настоящий момент*. По количеству сделанных докладов (так сказать, в командном зачёте) уверенно побеждает компания *JetBrains*. То есть в настоящий момент в данной компании работают спикеры, сделавшие в сумме наибольшее количество докладов в конференциях *JUG Ru Group* (с учётом и без учёта Java-митапов).
[](https://habrastorage.org/webt/nf/eh/xn/nfehxnlbfqz45vdlikeq2tg6rki.jpeg)
Во второй части приложения (в игре «Угадай спикера») было добавлено 2 новых режима: угадывание компании по спикеру и спикера по компании. Можно проверить, так ли хорошо Вы знаете принадлежность спикеров к их компаниям. В режиме «угадать спикера по компании» правильным ответом может быть множественный выбор — спикеры, относящиеся к одной компании.
[](https://habrastorage.org/webt/it/ay/eq/itayeql2j5iy2rtguxmay6nubtu.jpeg)
Java-код программы на 100% покрыт тестами, для сбора информации о покрытии кода используется библиотека [JaCoCo](https://github.com/jacoco/jacoco), для контроля покрытия тестами и качества кода — сервисы [Codecov](https://codecov.io/gh/JugruGroup/guess-game) и [SonarCloud](https://sonarcloud.io/dashboard?id=JugruGroup_guess-game).
На конференции *Heisenbug* две недели назад [Евгений Мандриков](https://jugspeakers.info/information/speaker/47), ведущий разработчик проектов *JaCoCo* и *SonarQube*, проводил воркшоп [Покрытие кода в JVM](https://jugspeakers.info/information/talk/2617). Посмотреть видео воркшопа могут обладатели билета на конференцию [Heisenbug](https://heisenbug-moscow.ru/?utm_source=habr&utm_medium=529984) или [единого билета](https://fullpass.jugru.org/?utm_source=habr&utm_medium=529984).
### Закрытие
Открывавшие три дня назад Алексей Фёдоров и Глеб Смирнов и закрыли конференцию. Традиционный выход на сцену спикеров, участников программного комитета и организаторов вынужденно пока заменён демонстрацией слайдов с фото.
[](https://habrastorage.org/webt/6i/-1/11/6i-111v7-kglmzkgm5qkewjpjyu.jpeg)
В качестве итогов можно сказать, что конференция стала ещё интереснее и разнообразнее (по крайней мере, насколько ей это позволяют рамки онлайн-конференции). Любители социальности тоже получили в этом сезоне желаемое в виде возможности пообщаться, пусть виртуально.
Всем — до следующих Java-конференций!
> Осенне-зимний сезон онлайн-конференций *JUG Ru Group* продолжится конференциями [DotNext](https://dotnext-moscow.ru/?utm_source=habr&utm_medium=529984), [DevOops](https://devoops-piter.ru/?utm_source=habr&utm_medium=529984) (**2-5 декабря 2020 года**) и [SmartData](https://smartdataconf.ru?utm_source=habr&utm_medium=529984) (**9-12 декабря 2020 года**). Можно посетить любую из конференций отдельно или [купить единый билет](https://fullpass.jugru.org/?utm_source=habr&utm_medium=529984) на все восемь конференций сезона (пять уже прошедших и три оставшихся), видео докладов при этом доступны сразу же после завершения конференций. | https://habr.com/ru/post/529984/ | null | ru | null |
# Visual Studio Snippets
Одно время я очень фанател от CodeRush. Он позволял в два-три нажатия клавиши создать свойство у объекта или составить тело цикла. Набирать код институтских лабораторных было одно удовольствие.
Потом вышла 2008 студия с C# 3.0 и там были автоматические свойства. Мне все больше не нравилось, когда CodeRush делал не то, что я хотел. Короткие шоткаты этому способствуют. И в один прекрасный момент я отказался от его использования. У меня больше времени тратилось на борьбу с инструментом, чем если бы я набирал код собственоручно.
Потом я узнал о сниппетах студии. По сути это те же шаблоны кода из CodeRush, только более простые. Есть стандартные вроде for, foreach, prop и exception. Чтобы их раскрыть нужно написать имя шаблона и нажать TAB. Если пользоваться автокомплитом, то можно написать часть имени шаблона, а потом TAB, TAB.
Но самая прелесть в том, что можно писать свои шаблоны. Вручную, правда, этого лучше не делать. Шаблон хранится в XML и редактировать его вручную тяжко.
Однако есть дополнение к студии, позволяющее создавать и редактировать шаблоны —
<http://www.codeplex.com/SnippetDesigner>. Редактирование выглядит следующим образом:
Все подставляемые поля подсвечиваются, настройки вынесены в свойства документа, а также в таблицу параметров. Отсутствует подсветка синтаксиса, но это все равно на порядок лучше, чем редактировать XML.
Чтобы подсоединить новый сниппет к студии, нужно его создать. Делается это либо через контекстное меню (для выделенного кода), либо копированием существующего файла сниппета. Где лежат шаблоны можно посмотреть в Tools\Code Snippets Manager. Пользовательские шаблоны лежат по умолчанию в \Documents\Visual Studio 2008\Code Snippets\. Если создавать шаблон через копирование файла, то нужно у него поменять Shortcut свойство в XML. То ли студия, то ли SnippetDesigner кеширует сниппеты и при сохранении сниппета с тем же шоткатом можно потерять изменения.
Примеры пользовательских сниппетов, которые я написал работая с недавним WPF проектом я привел чуть ниже. Эти шаблоны сэкономили мне несколько часов рутинной наборной работы и отладки.
### Свойство с уведомлением:
`///
/// $comment$
///
///
/// Уведомление об изменении
///
private $type$ m\_$property$;
///
/// $comment$
///
public $type$ $property$
{
get
{
return m\_$property$;
}
set
{
m\_$property$ = value;
OnPropertyChanged( "$property$" );
}
}`
### Свойство с ленивой инициализацией:
`///
/// $comment$
///
///
/// Ленивая инициализация
///
private $type$ m\_$property$;
///
/// $comment$
///
public $type$ $property$
{
get
{
if( m\_$property$ == null )
{
m\_$property$ = null;
}
return m\_$property$;
}
}`
### MS Prism команда:
`#region Command - $name$
///
/// Команда $comment$
///
public DelegateCommand<$type$> $name$Command { get; private set; }
///
/// Обработчик команды $comment$
///
private void $name$( $type$ parameter )
{
// TODO: Инициализировать команду в конструкторе
// $name$Command = new DelegateCommand<$type$>( $name$, Can$name$ );
// TODO: Добавить по необходимости Shortcuts, ReturnKeyAssistants
}
///
/// Критерий выполнимости для команды $comment$
///
/// true если команде разрешено выполняться
private bool Can$name$( $type$ parameter )
{
// TODO: Добавить обработчики ошибок для входных данных
//return Errors.Count == 0;
return true;
}
#endregion` | https://habr.com/ru/post/78530/ | null | ru | null |
# Вышла бета консольной утилиты GitHub CLI
Разработчики GitHub выпустили бета-версию консольной утилиты [GitHub CLI](https://github.com/cli/cli). Она позволяет создавать пул-реквесты и тикеты на GitHub, не выходя из консоли, где вы уже работаете с git.
Пул-реквесты и issue — самые распространённые команды, поэтому их добавили в первую очередь.
Как и прошлая программа [Hub](https://github.com/github/hub), эта полностью написана на Go. Она тоже запускается в разных ОС, включая [Linux, MacOS и Windows](https://github.com/cli/cli#installation-and-upgrading), причём гораздо удобнее в использовании.
* `gh pr [status, list, view, checkout, create]`
* `gh issue [status, list, view, create]`
* `gh help`
Для получения справки по любой команде/подкоманде добавьте в конце строки `--help`. Например:
```
$ gh issue create --help
Create a new issue
Usage:
gh issue create [flags]
Flags:
-b, --body string Supply a body. Will prompt for one otherwise.
-t, --title string Supply a title. Will prompt for one otherwise.
-w, --web Open the browser to create an issue
Global Flags:
--help Show help for command
-R, --repo OWNER/REPO Select another repository using the OWNER/REPO format
```
**Глобальные флаги:**
```
--help Show help for command
-R, --repo OWNER/REPO Select another repository using the OWNER/REPO format
--version Show gh version
```
Примеры команд
--------------
#### Отображение списка тикетов с пометкой "help wanted"
```
~/Projects/my-project$ gh issue list --label "help wanted"
```
#### Создание пул-реквеста
```
~/Projects/my-project$ gh pr create
```
Здесь же под флагом `-B` указываем ветку, если это не мастер.
```
Flags:
-B, --base string The branch into which you want your code merged
-b, --body string Supply a body. Will prompt for one otherwise.
-d, --draft Mark pull request as a draft
-t, --title string Supply a title. Will prompt for one otherwise.
-w, --web Open the web browser to create a pull request
```
Если не ввести тему и содержание пул-реквеста в командной строке, то появится интерактивное поле для ввода *прямо в консоли*.
При отправке пул-реквеста GitHub CLI автоматически создаёт форк мастера, если он не был создан ранее.
#### Проверка изменений/статуса
```
~/Projects/my-project$ gh pr status
Current branch
#12 Remove the test feature [Rexogamer:patch-2]
- All checks failing - review required
Created by you
You have no open pull requests
Requesting a code review from you
#13 Fix tests [branch]
- 3/4 checks failing - review required
#15 New feature [branch]
- Checks passing - approved
```
#### Отмена изменений (check out)
```
~/Projects/my-project$ gh pr checkout 12
remote: Enumerating objects: 66, done.
remote: Counting objects: 100% (66/66), done.
remote: Total 83 (delta 66), reused 66 (delta 66), pack-reused 17
Unpacking objects: 100% (83/83), done.
From https://github.com/owner/repo
* [new ref] refs/pull/8896/head -> patch-2
M README.md
Switched to branch 'patch-2'
```
Нужно признать, что после покупки со стороны Microsoft разработка новых функций GitHub явно ускорилась. Есть [версия](https://news.ycombinator.com/item?id=22311560), что перед покупкой в проекте накопился очень большой технический долг (старые версии на Rails и прочее), но новый владелец бросил массу ресурсов на его устранение, благо у него есть такие возможности.
Теперь большая часть проблем позади, так что разработчики GitHub могут, наконец, сосредоточиться на развитии продукта. Они ждут отзывов по GitHub CLI в [анкете](https://docs.google.com/forms/d/e/1FAIpQLSfScxLCO5eyeIM4clYcEQEnT0bIP6PK3LZ7E4AHQdj5tItUvQ/viewform) и [репозитории](https://github.com/cli/cli). | https://habr.com/ru/post/488170/ | null | ru | null |
# 6 кнопок
Постановка задачи
=================
Сутки добрые, Хабраюзеры!
Пару недель назад представитель федерации по кикбоксингу нашего региона поставил мне задачу, сделать то, что позволит сократить время проведения соревнований на 30% методом автоматизации, кибернизации, механизации и прочей «ции». Человек он простой, прямой, и сильный так, что отказать у меня не было возможности. Задача была принята.
Изучив регламент проведения боев, и вспоминая прошлые соревнования было установлено, что 20-30% от соревнований отнимают следующие пункты:
1. сбор рефери судейских записок после трех раундов
2. передача записок главному судье
3. подсчет очков
4. подведение итогов боя
В среднем около 3-5 минут
Задача встала в следующем: необходимо оперативно передавать информацию об очках главному судье, то есть «запрограммировать 6 кнопок».
Выбор решения
=============
Для решения задачи были рассмотрены следующие аппаратные варианты:
1. Манипуляторы Мышь на каждом судейском столе и передача от них информации
2. Некий джойстик на каждом судейском столе и передача информации главному судье
Первый вариант решения технической части задачи был отметен сразу же так как я себе сложно представлял как поведет себя USB мышь на расстоянии 15-20 метров от компьютера главного судьи.
Второй вариант показался мне более реальным.
Центром сбора данных я возложил на контроллер ARDUINO.
Исполнение
==========
Этап 1 Общая схема
------------------
На столах боковых судей размещается судейские пульты, которые имеют 2 кнопки: красная и синяя. Информация об нажатиях этих кнопок собирается контроллером Arduino и передается программе установленной на ноутбуке.
Программа анализирует нажатия кнопок и выдает информацию по итогу боя и набранных баллах бойцом.
Главный судья на основании результатов боя объявляет победителя.
Этап 2 схема подключения
------------------------
Со схемой все просто, каждую отдельную кнопку ставлю на отдельный вход микроконтроллера. Резисторы использовал 2.4 кОм. Я не стал использовать сдвиговый регистр так как не умею с ним работать, а под текущую задачу PIN-ов хватает с лихвой.
Изготовление
============
Этап 3 Изготовление пультов
---------------------------
Состав пульта:
1. Коробочка
2. Кусок монтажной платы
3. Кнопки
4. Кусочки проводов
5. Красная и синяя изолента
6. Коннектор RJ45
Этап 4 Изготовление контроллера
-------------------------------
Состав контроллера:
1. Коробочка из под отверток
2. Arduino
3. монтажная плата
4. Кусочки проводов
5. Изолента
6. Пачкорды RJ-45
7. USB провод
Программирование
================
Этап 5 программа для контроллера
--------------------------------
В программе для контроллера все взято из примеров. Ждем нажатия кнопок, учитывая дребезжание контактов и шлем все COM-порт:
**Скетч контроллера**
```
#include
#define BUTTON7 7
#define BUTTON6 6
#define BUTTON5 5
#define BUTTON4 4
#define BUTTON3 3
#define BUTTON2 2
#define LED 13
int state7 = 0;
int prevstate7 = 0;
int state6 = 0;
int prevstate6 = 0;
int state5 = 0;
int prevstate5 = 0;
int state4 = 0;
int prevstate4 = 0;
int state3 = 0;
int prevstate3 = 0;
int state2 = 0;
int prevstate2 = 0;
Bounce bouncer7 = Bounce( BUTTON7,5 );
Bounce bouncer6 = Bounce( BUTTON6,5 );
Bounce bouncer5 = Bounce( BUTTON5,5 );
Bounce bouncer4 = Bounce( BUTTON4,5 );
Bounce bouncer3 = Bounce( BUTTON3,5 );
Bounce bouncer2 = Bounce( BUTTON2,5 );
void setup() {
Serial.begin(115200);
pinMode(BUTTON7,INPUT);
pinMode(BUTTON6,INPUT);
pinMode(LED,OUTPUT);
}
void loop() {
// 7 кнопка начало
bouncer7.update ( );
int value7 = bouncer7.read();
if ( value7 == HIGH) {
digitalWrite(LED, HIGH );
state7 = 1;
} else {
digitalWrite(LED, LOW );
state7 = 0;
}
if(state7 != prevstate7){
if(state7 == 1){
Serial.println("7");
}
}
prevstate7 = state7;
// 7 кнопка конец
// 6 кнопка начало
bouncer6.update ( );
int value6 = bouncer6.read();
if ( value6 == HIGH) {
digitalWrite(LED, HIGH );
state6 = 1;
} else {
digitalWrite(LED, LOW );
state6 = 0;
}
if(state6 != prevstate6){
if(state6 == 1){
Serial.println("6");
}
}
prevstate6 = state6;
// 6 кнопка конец
// 5 кнопка начало
bouncer5.update ( );
int value5 = bouncer5.read();
if ( value5 == HIGH) {
digitalWrite(LED, HIGH );
state5 = 1;
} else {
digitalWrite(LED, LOW );
state5 = 0;
}
if(state5 != prevstate5){
if(state5 == 1){
Serial.println("5");
}
}
prevstate5 = state5;
// 5 кнопка конец
// 4 кнопка начало
bouncer4.update ( );
int value4 = bouncer4.read();
if ( value4 == HIGH) {
digitalWrite(LED, HIGH );
state4 = 1;
} else {
digitalWrite(LED, LOW );
state4 = 0;
}
if(state4 != prevstate4){
if(state4 == 1){
Serial.println("4");
}
}
prevstate4 = state4;
// 4 кнопка конец
// 3 кнопка начало
bouncer3.update ( );
int value3 = bouncer3.read();
if ( value3 == HIGH) {
digitalWrite(LED, HIGH );
state3 = 1;
} else {
digitalWrite(LED, LOW );
state3 = 0;
}
if(state3 != prevstate3){
if(state3 == 1){
Serial.println("3");
}
}
prevstate3 = state3;
// 3 кнопка конец
// 2 кнопка начало
bouncer2.update ( );
int value2 = bouncer2.read();
if ( value2 == HIGH) {
digitalWrite(LED, HIGH );
state2 = 1;
} else {
digitalWrite(LED, LOW );
state2 = 0;
}
if(state2 != prevstate2){
if(state2 == 1){
Serial.println("2");
}
}
prevstate2 = state2;
// 2 кнопка конец
}
```
Этап 6 программа для контроля ведения боя
-----------------------------------------
Во первых сразу же делюсь кодом [Скачать исходный код](https://docs.google.com/file/d/0B6tCFxCR5IdOTlUxbGlRUUZfaTg/edit?usp=sharing).
Весь код написан делфи XE3 так как учил его в школе. И небольшая описательная часть:
1. Используя компоненту ComPort 4.11 подключаемся к com-порту и слушаем его
2. в зависимости от настроек боя слушаем порт и результаты выводим в labelX.caption
3. в конце боя выводим итог
Программа писалась за одну ночь, поэтому о красоте не может быть и речи.
Подготовка к соревнованиям
==========================
Прокладка кабелей от центрального блока до боковых судей
Работа судьи
О том как работает программа
============================
Итоги соревнований
==================
По итогу двух дневных соревнований был разыгран полный комплект наград проведено более 150 боев.
Благодаря сэкономленному времени спортсмены уехали по своим городам на 4 часа раньше планированного времени
Выводы
======
1. Оборудование отработало на ура, без единого сбоя
2. Длина проводов от центрального блока до кнопок составляла 20 метров, при этом тестировал кнопки на 100 метровом кабеле
3. В программе нужно переработать интерфейс, чем и занимаюсь к подготовке соревнований по боксу
4. Программе необходимы дополнения связанные с выводом на табло и звуковыми эффектами
5. Использование стандартного сетевого кабеля для подключения кнопок и разъемы значительно удешевило всю конструкцию в целом
Спасибо за внимание.
**UPD-1 :** По кнопкам.
специально выбрал такие кнопки по следующим причинам:
1. обратная связь тактильная. щелчек при нажатии
2. кнопки не имеют свободного хода
3. у кнопок со свободным ходом есть не приятность они срабатывают раньше чем чувствуется щелчок
4. пользователи системы люди с мышцами, а не любители няшных кнопок
5. обратная связь светодиодом бесполезна ибо взор судьи направлен на ринг, а не на руки
**UPD-2:** бюджет данной сборки вряд ли перевалил 3000 руб
**UPD-3** [По просьбам исходники на github](https://github.com/mtopsib/kikboxv10.git) | https://habr.com/ru/post/178633/ | null | ru | null |
# Есть мнение: технология DANE для браузеров провалилась
Говорим о том, что собой представляет технология DANE для аутентификации доменных имен по DNS и почему она не получила широкого распространения в браузерах.
[](https://habr.com/ru/company/1cloud/blog/454322/)
*/ Unsplash / [Paulius Dragunas](https://unsplash.com/photos/uw_NWjC1mBE)*
Что такое DANE
--------------
Сертификационные центры (CA) — это организации, которые [занимаются](https://1cloud.ru/blog/sozdat-ili-kupit-ssl?utm_source=habrahabr&utm_medium=cpm&utm_campaign=dane&utm_content=site) удостоверением криптографических [SSL-сертификатов](https://1cloud.ru/services/ssl?utm_source=habrahabr&utm_medium=cpm&utm_campaign=dane&utm_content=site). Они ставят на них свою электронную подпись, подтверждая подлинность. Однако порой возникают ситуации, когда удостоверения выдаются с нарушениями. Например, в прошлом году Google инициировали «процедуру прекращения доверия» к сертификатам Symantec из-за их компрометации (подробно эту историю мы освещали в нашем блоге — [раз](https://habr.com/ru/company/1cloud/blog/349382/) и [два](https://habr.com/ru/company/1cloud/blog/350768/)).
Чтобы избежать таких ситуаций, несколько лет назад в IETF [начали разрабатывать](https://www.ietfjournal.org/dane-taking-tls-authentication-to-the-next-level-using-dnssec/) технологию DANE (но она не получила широкого распространения в браузерах — почему так получилось, поговорим далее).
DANE (DNS-based Authentication of Named Entities) — это набор спецификаций, который позволяет использовать DNSSEC (Name System Security Extensions) для контроля достоверности SSL-сертификатов. DNSSEC представляет собой расширение для системы доменных имен, которое минимизирует атаки, связанные с подменой адресов. Используя две эти технологии, веб-мастер или клиент могут обратиться к одному из операторов зон DNS и подтвердить валидность используемого сертификата.
По сути, DANE выступает в качестве самоподписанного сертификата (гарантом его надежности является DNSSEC) и дополняет функции CA.
Как это работает
----------------
Спецификация DANE описана в [RFC6698](https://tools.ietf.org/html/rfc6698). Согласно документу, в [ресурсные записи DNS](https://ru.wikipedia.org/wiki/%D0%A2%D0%B8%D0%BF%D1%8B_%D1%80%D0%B5%D1%81%D1%83%D1%80%D1%81%D0%BD%D1%8B%D1%85_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D0%B5%D0%B9_DNS) был добавлен новый тип — TLSA. Он содержит информацию о передаваемом сертификате, размерность и тип передаваемых данных, а также сами данные. Веб-мастер создает цифровой отпечаток сертификата, подписывает его с помощью DNSSEC и размещает в TLSA.
> Клиент подключается к сайту в интернете и сравнивает его сертификат с «копией», полученной от DNS-оператора. Если они совпадают, то ресурс считается доверенным.
На wiki-странице DANE приведен следующий пример DNS-запроса к серверу example.org по TCP-порту 443:
```
IN TLSA _443._tcp.example.org
```
Ответ на него выглядит так:
```
_443._tcp.example.com. IN TLSA (
3 0 0 30820307308201efa003020102020... )
```
DANE имеет несколько расширений, которые работают с другими записями DNS помимо TLSA. Первое — DNS-запись SSHFP для проверки ключей при SSH-соединениях. Оно описано в [RFC4255](https://tools.ietf.org/html/rfc4255), [RFC6594](https://tools.ietf.org/html/rfc6594) и [RFC7479](https://tools.ietf.org/html/rfc7479). Второе — запись OPENPGPKEY для обмена ключами с помощью PGP ([RFC7929](https://tools.ietf.org/html/rfc7929)). Наконец, третье — запись SMIMEA (в RFC стандарт не оформлен, есть [только его черновик](https://tools.ietf.org/html/draft-ietf-dane-smime-16)) для криптографического обмена ключами по S/MIME.
В чем проблема с DANE
---------------------
В середине мая прошла конференция DNS-OARC (это некоммерческая организация, которая занимается вопросами безопасности, стабильности и развития системы доменных имён). На одной из панелей эксперты [пришли к выводу](https://blog.apnic.net/2019/05/27/dns-oarc-30-bad-news-for-dane/), что технология DANE в браузерах провалилась (по крайней мере, в текущем варианте реализации). Присутствующий на конференции Джефф Хастон (Geoff Huston), ведущий научный сотрудник [APNIC](https://ru.wikipedia.org/wiki/Asia-Pacific_Network_Information_Centre), одного из пяти региональных интернет-регистраторов, [отозвался](https://afaae.com/germany/dnssec-dane-chain-for-browsers-is-practically-dead/) о DANE как о «мертвой технологии».
> Популярные браузеры не поддерживают аутентификацию сертификатов с помощью DANE. На рынке [встречаются специальные плагины](https://superuser.com/questions/1273058/browser-plugin-enabling-dane-protocol-with-firefox-chrome-or-other-browser), которые раскрывают функциональность TLSA-записей, однако и их поддержку [постепенно прекращают](https://www.dnssec-validator.cz/2018-10-16-end-of-support.html).
Проблемы с распространением DANE в браузерах связывают с длительностью процесса валидации по DNSSEC. Система вынуждена производить криптографические расчеты для подтверждения подлинности SSL-сертификата и проходить по всей цепочке DNS-серверов (от корневой зоны до домена хоста) при первом подключении к ресурсу.
*/ Unsplash / [Kaley Dykstra](https://unsplash.com/photos/gtVrejEGdmM)*
Этот недостаток пытались устранить в Mozilla с помощью механизма [DNSSEC Chain Extension](https://tools.ietf.org/html/draft-ietf-tls-dnssec-chain-extension-07) для TLS. Он должен был сократить количество DNS-записей, которые приходилось просматривать клиенту во время аутентификации. Однако внутри группы разработчиков возникли разногласия, которые разрешить не удалось. В итоге проект забросили, хотя он был одобрен IETF в марте 2018 года.
Еще одной причиной низкой популярности DANE считается слабая распространенность DNSSEC в мире — [с ним работает всего 19% ресурсов](https://stats.labs.apnic.net/dnssec). Эксперты посчитали, что этого недостаточно для активного продвижения DANE.
Скорее всего, индустрия будет развиваться в другом направлении. Вместо того чтобы использовать DNS для верификации сертификатов SSL/TLS, игроки рынка, наоборот, будут продвигать протоколы DNS-over-TLS (DoT) и DNS-over-HTTPS (DoH). Последний мы упоминали в одном из наших [предыдущих материалов](https://habr.com/ru/company/1cloud/blog/439426/) на Хабре. Они шифруют и проверяют запросы пользователей к DNS-серверу, не давая злоумышленникам возможности подменить данные. В начале года DoT уже [внедрили](https://security.googleblog.com/2019/01/google-public-dns-now-supports-dns-over.html) в Google для своего Public DNS. Что касается DANE — получится ли у технологии «вернуться в седло» и все же стать массовой, предстоит увидеть в будущем.
> **Что еще у нас есть для дополнительного чтения:**
>
>
>
>  [Как автоматизировать управление ИТ-инфраструктурой — обсуждаем три тренда](https://habr.com/ru/company/1cloud/blog/453326/)
>
>  [JMAP — открытый протокол заменит IMAP при обмене электронными письмами](https://habr.com/ru/company/1cloud/blog/452958/)
>
>
>
>  [Как сэкономить с помощью прикладного программного интерфейса](https://1cloud.ru/blog/ekonomiya-na-api?utm_source=habrahabr&utm_medium=cpm&utm_campaign=jmap&utm_content=blog)
>
>  [DevOps в облачном сервисе на примере 1cloud.ru](https://1cloud.ru/blog/devops-v-razrabotke-oblaka-1cloud?utm_source=habrahabr&utm_medium=cpm&utm_campaign=jmap&utm_content=blog)
>
>  [Эволюция архитектуры облака 1cloud](https://1cloud.ru/blog/our-system-architecture-evolution?utm_source=habrahabr&utm_medium=cpm&utm_campaign=jmap&utm_content=blog)
>
>
>
>  [Как работает техподдержка 1cloud](https://www.facebook.com/1cloudru/posts/2334655376856969)
>
>  [Мифы об облачных технологиях](https://www.facebook.com/1cloudru/posts/2329624197360087) | https://habr.com/ru/post/454322/ | null | ru | null |
# Отправляем магические ссылки с помощью Node.js
***Перевод статьи подготовлен в преддверии старта курса [«Разработчик Node.js»](https://otus.pw/qEXb/).***
---
Самый популярный метод входа в приложение – это предоставление логина и пароля, но пользователи могут найти в этом определенные недостатки. Несмотря на то, что существует множество менеджеров паролей, их использование требует времени. Не сильно много, но все же. Некоторые приложения продвигают сложную и тем самым разочаровывающую политику паролей, поэтому придумать новый пароль бывает совсем непросто. Беспарольная система может стать хорошей альтернативой обычной аутентификации по логину и паролю. Она используется в Slack и FramerX, и выглядит это, как отправка магической ссылки пользователю для включения такой аутентификации в приложении. Беспарольная система работает следующим образом:
1. Пользователь посещает приложение, где есть форма для ввода адреса электронной почты;
2. Пользователь вводит адрес электронной почты и нажимает кнопку подтверждения;
3. Магическая ссылка для входа в систему отправляется на электронную почту пользователя;
4. Пользователь нажимает на ссылку и его перенаправляют в приложение, где он уже вошел в систему.
После этого магическая ссылка более недействительна.
Ниже мы рассмотрим некоторые основные моменты реализации беспарольной авторизации на Node.js.
**Создадим [express](https://expressjs.com/) — приложение**
Для начала нам нужно создать простое express-приложение и добавить несколько конечных точек. Код ниже отвечает за настройку express-сервера с помощниками для [парсинга входящих запросов](https://github.com/expressjs/body-parser), [логином](https://github.com/sirrodgepodge/morgan-body) и добавлением [cors](https://github.com/expressjs/cors). Нам нужно будет создать две директории, к которым мы позже добавим обработчики. Это будут `/login` и `/account`. Первый обработчик будет отвечать за отправку магических ссылок пользователям, а второй – за их аутентификацию.
*server.ts*
### Настройка nodemailer
Мы будем использовать *nodemailer* для отправки электронных писем, но для начала его нужно настроить. Нам понадобится несколько составляющих: адрес электронной почты, пароль от электронной почты, хост SMTP-сервера и порт SMTP-сервера. Также нам понадобится шаблон письма, которое мы будем отправлять пользователям с магической ссылкой. Шаблон может быть просто строкой или HTML-страницей.
### Генерация токенов
Для этого мы будем использовать пакет *[jsonwebtoken](https://github.com/auth0/node-jsonwebtoken#readme)*, который в целом сделает все за нас. Наш токен будет состоять из двух свойств: адреса электронной почты и времени истечения срока действия.
*token.ts*
### Отправка электронного письма
Теперь нужно добавить обработчик входа в систему, где мы сначала будем проверять, что запрос содержит адрес электронной почты пользователя, затем сгенерируем новый токен для этого конкретного пользователя и, наконец, используем механизм, описанный в коде выше, для отправки электронного письма.
### Аутентификация пользователя
При входе пользователя в системы, нам нужно авторизовать его запросы к нашему серверу. Для этого нужно сделать следующее:
1. Проверить, есть ли заголовок авторизации в запросе;
2. Проверить, что заголовок авторизации – это `bearer token`;
3. Попробовать декодировать этот токен;
4. Проверить, что в токене есть все нужные поля. В нашем случае: `email` и `expiration`.
5. Сравнить дату и время из expiration с текущими, чтобы проверить, что токен не истек.
6. Наконец, проверить, что пользователь с электронной почтой, извлечённой из токена, существует.
### Заключение
Здесь представлена базовая настройка для беспарольного входа в систему поверх обычного потока авторизации. Самое большое преимущество, которое я вижу в таком подходе, заключается в том, что, если пользователи смогут быстрее и проще входить в систему какого-либо продукта, их опыт от пользования продуктом улучшится.
С другой стороны, даже если войти в систему может быть проще, чем с обычным логином/паролем, то вернуться в нее может быть сложнее. Каждый раз, когда пользователь будет входить в систему, ему нужно будет дождаться письма на электронную почту, проверить почтовый ящик и нажать на ссылку. Этот процесс также может оказаться неприятным, поэтому если в сессии короткие периоды timeout-а или ожидается, что пользователи будут часто входить в систему, то беспарольная авторизация может оказаться не лучшим выбором.
---
[Узнать подробнее о курсе.](https://otus.pw/qEXb/)
--- | https://habr.com/ru/post/507148/ | null | ru | null |
# Скачиваем Google Docs без браузера
Скриптик выглядит как-то так:
`#!/bin/bash
token=$(curl -s www.google.com/accounts/ClientLogin -d Email=user.name@gmail.com -d Passwd=qwerty -d accountType=GOOGLE -d service=writely -d Gdata-version=3.0 |cut -d "=" -f 2)
set $token
curl --silent --header "Gdata-Version: 3.0" --header "Authorization: GoogleLogin auth=$3" "http://docs.google.com/feeds/user.name@gmail.com/private/full" | tidy -xml -indent -utf8 -quiet > /tmp/gdocs.xml
file=(doc1 doc2 doc3 doc4)
**resourceId**=(document:0ASpnxqo7zPlfZGQ3Z2Zwc183NWZteDNiM2Y ...) # и ещё 3 resourceId
i=0
while (( i < 4 )) # match num_files
do
wget --header "Gdata-Version: 3.0" --header "Authorization: GoogleLogin auth=$3" "https://docs.google.com/feeds/download/documents/Export?docID=${resourceId[$i]}&exportFormat=txt" -O /tmp/${file[$i]}.txt
sleep 2
i=$i+1
done`
А теперь, как принято, разоблачение.
* Первой строкой получаем жетон аутентификации. Далее его предъявляем для скачивания RSS потока, который сохраняем в файл. Далее из него берём **resourceId** и скачиваем доки. Тут следует сделать оговорку, что **resourceId** берётся «вручную» из сохраненного RSS файла. Можно, конечно, и это автоматизировать, но если документов не много то и раздувать скрипт не обязательно.
* Ссылка для скачивания доков:
`GET /feeds/download/documents/Export?docID=resource_id&exportFormat=format`
* service=writely. Список наименований кодов Гугло-сервисов [берется отсюда](http://code.google.com/intl/ru/apis/gdata/faq.html#clientlogin).
* **resourceId** ключевое элемент. Это идентификатор дока. Его берём из RSS потока скачанного в файл */tmp/gdocs.xml*. Релевантные тэги выглядят так и находятся в той же записи где название доки.
`document:0ASpnxqo7zPlfZGQ3Z2Zwc183Zzc3NnZkY2g`
* exportFormat=txt. Можно выбрать и другие форматы для скачивания. Список [тут](http://code.google.com/intl/ru/apis/documents/docs/3.0/developers_guide_protocol.html#DownloadingDocs).
Написано на скорую руку, поэтому любые замечания и критика приветствуются. | https://habr.com/ru/post/85298/ | null | ru | null |
# Супер кнопка для Манчкина
Многие знают или, по крайней мере, слышали про настольную игру [Манчкин](http://ru.wikipedia.org/wiki/Манчкин_(игра))
В этой игре есть такое правило:
*«Когда вы убиваете или иначе одолеваете монстра, дайте соперникам приемлемое время (около 2,6 секунды), чтобы они могли высказаться.»*
Иногда очень хочется эти самые 2,6 секунды замерить, особенно когда кто-нибудь долго думает, читает карты, не может решить что делать. В таких случаях мы просто считали вслух до трех, на цифре «три» бой заканчивался.
Хотелось сделать какую-нибудь кнопку и таймер, чтобы не считать вслух.
Делая заказ на сайте [www.sparkfun.com](http://www.sparkfun.com) наткнулся на такую [кнопку](http://www.sparkfun.com/products/9181):
Можно сказать, что кнопка в масштабе 1:1, она диаметром почти 10 см.
Таймер и пищалку решил делать на attiny85 (собственно ничего другого и не было).
Для подсветки кнопки разобрал [«фонарик»](http://www.dealextreme.com/p/10mm-focused-led-flashlight-keychain-white-3491) (пришедший бонусом к другому заказу с DX)
Я в схемотехнике не очень силен, поэтому буду особо рад комментариям по поводу схемы:
Транзисторы выдраны с мертвой матплаты: на них написано 1AM, это [MBT3904LT1](http://www.smd.ru/katalog/tranzistory/index.khtml)
Программатор использовал [этот](http://www.sparkfun.com/products/9825):
В качестве пищалки подключен мелкий спикер от компа:
При включении питания или нажатии на кнопку (а это reset), зажигается светодиод, каждую секунду делается короткий «бип», по истечении времени (2,6 секунды) светодиод гаснет и дается продолжительный финальный «бииип». Затем процессор переводится в спячку.
Программа получилась просто минималистичная.
```
#include
#include
#include
#include
int main(void)
{
DDRB |= 0x1a;
PORTB = 0x18;
SoundOn();
\_delay\_ms(50);
SoundOff();
\_delay\_ms(950);
SoundOn();
\_delay\_ms(50);
SoundOff();
\_delay\_ms(950);
SoundOn();
\_delay\_ms(50);
SoundOff();
\_delay\_ms(550);
SoundOn();
PORTB = 0x00;
\_delay\_ms(700);
SoundOff();
PORTB = 0;
DDRB = 0;
sleep\_cpu();
}
void SoundOn()
{
TCCR0A = (1 << COM0B0) | (1 << WGM01);
TCCR0B = (1 << CS01) ;
OCR0A=0x60;
TCNT0=0x00;
OCR0B=0x00;
}
void SoundOff()
{
TCCR0A = 0;
TCCR0B = 0;
}
```
Плату травить не стал, все сделал навесным монтажом, выглядит это ужасно, но в непрозрачном корпусе незаметно.
В качестве источника питания 1 литиевый аккумулятор, у меня валялся 18500. Он, к сожалению, не protected, поэтому придется за ним иногда поглядывать. Лучше конечно взять что-то типа [18650 protected](http://www.dealextreme.com/p/trustfire-protected-18650-lithium-battery-2400mah-2-pack-gray-5776)
Логика работы простая: включили светодиод, пропищали, перевели проц в спячку. В спячке проц почти ничего не потребляет, поэтому выключатель питания не нужен. Т.е. аккум можно не трогать несколько месяцев.
В качестве корпуса использован шпиндель на 25 болванок.
В начале прозрачный колпак покрасил краской и наклеил бумажку:
[](http://habrastorage.org/storage/0339c6da/ce2e36f1/9becde76/f7a41c36.jpg)
На следующий день наклейка слезла вместе с краской. Поэтому колпак был перекрашен, наклейку повторно не лепили.
Итоговый результат выглядит так:
С кнопкой играется примерно так:
тот кто в бою говорит что-то типа: «я его побеждаю 18 против 10». Если начинаются споры, то нажимает кнопку, после финального «бип» карты не принимаются.
[](http://habrastorage.org/storage/db529373/2339a53e/5ba78053/183e72f6.jpg)
UPD: [Лист персонажа](http://www.worldofmunchkin.com/img/MgrRussian.pdf) | https://habr.com/ru/post/116550/ | null | ru | null |
# Computed Columns и nvarchar(max)
Недавно столкнулся с проблемным запросом, который делал отбор по столбцу с типом nvarchar(max). Про производительность отборов по nvarcar(max) я [уже писал](https://habr.com/ru/post/489182/), а сейчас решил сделать пост о том, как можно решить проблему, если фильтр по nvarchar(max) нужен.
В первой части я покажу что можно сделать, если на самом деле nvarchar(max) не был нужен, а хватило бы "нормальной" длины, с которой столбец можно проиндексировать. А во второй - что делать, если строка на самом деле такая длинная, что проиндексировать столбец с ней не представляется возможным.
Я не могу показать проблемный запрос в том виде, как он был, но, упрощённо, его самая проблемная часть сводилась вот к такому:
```
SELECT id
FROM smth
WHERE
field1 = @v1
OR field2 = @v2
OR field3 = @v3
```
Колонка field1 была проиндексирована, а field2 и field3 мало того, что не были, так ещё и имели тип nvarchar(max). Причём, не смотря на кажущееся очень неприятным условие, эта часть всегда возвращает очень небольшое количество записей - от нуля до нескольких десятков.
Для начала, создам таблицу, с помощью которой можно воспроизвести проблему:
```
CREATE TABLE smth (
id int IDENTITY PRIMARY KEY,
field1 nvarchar(200),
field2 nvarchar(max),
field3 nvarchar(max),
/* добавляю столбцы, чтобы сканировать кластерный индекс не всегда было выгодно */
field4 nvarchar(max),
field5 nvarchar(max),
field6 nvarchar(max),
field7 nvarchar(max),
field8 nvarchar(max),
field9 nvarchar(max),
field0 nvarchar(max),
/* а там ещё 40 столбцов с разными типами */
);
GO
```
Реальная таблица достаточно широкая и содержит под сотню миллионов записей, мы сделаем поменьше:
```
--заполним случайными данными
;WITH
n AS (
SELECT 0 n UNION ALL SELECT 0
), n1 AS (
SELECT 0 n
FROM n, n n1, n n2
), n2 AS (
SELECT 0 n
FROM n1 n, n1 n1, n1 n2
), nums AS (
SELECT 0 n /* 262144 строк */
FROM n2 n, n2 n1
)
INSERT INTO smth (field1, field2, field3, field4, field5, field6, field7, field8, field9, field0)
SELECT
CASE WHEN RAND(CHECKSUM(NEWID())) > 0.5 THEN CAST(NEWID() AS nvarchar(200)) ELSE NULL END AS field1,
CASE WHEN RAND(CHECKSUM(NEWID())) > 0.5 THEN CAST(NEWID() AS nvarchar(200)) ELSE NULL END AS field2,
CASE WHEN RAND(CHECKSUM(NEWID())) > 0.5 THEN CAST(NEWID() AS nvarchar(200)) ELSE NULL END AS field3,
CASE WHEN RAND(CHECKSUM(NEWID())) > 0.5 THEN CAST(NEWID() AS nvarchar(200)) ELSE NULL END AS field4,
CASE WHEN RAND(CHECKSUM(NEWID())) > 0.5 THEN CAST(NEWID() AS nvarchar(200)) ELSE NULL END AS field5,
CASE WHEN RAND(CHECKSUM(NEWID())) > 0.5 THEN CAST(NEWID() AS nvarchar(200)) ELSE NULL END AS field6,
CASE WHEN RAND(CHECKSUM(NEWID())) > 0.5 THEN CAST(NEWID() AS nvarchar(200)) ELSE NULL END AS field7,
CASE WHEN RAND(CHECKSUM(NEWID())) > 0.5 THEN CAST(NEWID() AS nvarchar(200)) ELSE NULL END AS field8,
CASE WHEN RAND(CHECKSUM(NEWID())) > 0.5 THEN CAST(NEWID() AS nvarchar(200)) ELSE NULL END AS field9,
CASE WHEN RAND(CHECKSUM(NEWID())) > 0.5 THEN CAST(NEWID() AS nvarchar(200)) ELSE NULL END AS field0
FROM nums;
GO
--добавляем дубли
INSERT INTO smth (field1, field2, field3)
SELECT field1, field2, field3
FROM smth;
GO 4 -- 4194304 строк
```
В результате получилась таблица с 4194304 записями.
Как я уже говорил, столбец field1 проиндексирован, поэтому тоже создаю индекс, выбираю произвольные значения и выполняю запрос:
```
CREATE INDEX ix_ST ON smth (field1);
GO
SET STATISTICS TIME, IO, XML ON;
SELECT id
FROM smth
WHERE
field1 = N'0FCD0182-AF6E-47E9-94F9-456F2047992C'
OR field2 = N'67D1B1C6-8E11-4E7F-BDAD-EF33D8D3AF87'
OR field3 = N'D75B375A-E977-4EDD-A836-7AF4967B8BFD'
SET STATISTICS TIME, IO, XML OFF;
```
В результате, получаю 16 строк за примерно 4 секунды процессорного времени:
> (16 rows affected) Table 'smth'. Scan count 9, logical reads 84083, physical reads 0, read-ahead reads 83155, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
>
> SQL Server Execution Times: CPU time = 3937 ms ...
>
>
В плане запроса, как можно увидеть, просто сканирование кластерного индекса - это логично, т.к. поля field2 и field3 не входят в индекс по field1.
Первое, что приходит в голову - создать индексы по field2 и field3, но как я уже говорил, эти поля имеют типы nvarchar(max), поэтому индекс по ним создать нельзя. Но, можно включить их в существующий индекс, как include-поля. Давайте попробуем:
```
CREATE INDEX ix_ST ON smth (field1) INCLUDE (field2, field3) WITH (DROP_EXISTING = ON);
```
Теперь у нас есть покрывающий индекс, в котором есть все поля, необходимые запросу. Но сильно ли он помогает? Выполнив тот же запрос, получаю:
> (16 rows affected) Table 'smth'. Scan count 9, logical reads 65855, physical reads 0, read-ahead reads 64878, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
>
> SQL Server Execution Times: CPU time = 2874 ms ...
>
>
Как видно, индекс используется, но, как и ожидалось, не очень эффективно - сначала проходит его полное сканирование и затем уже применяется заданный фильтр по трём полям. Запрос, в принципе, уже выполняется быстрее, но можно ли сделать его ещё лучше?
Поскольку мы говорим о не самом удачном дизайне таблицы, то да, можно В полях field2 и field3 фактическая максимальная длина (в реальном запросе) не превышает 200 символов, поэтому было бы здорово изменить у них тип данных на более подходящий. К сожалению, я не могу менять типы данных у существующих столбцов.
Попробуем добавить вычисляемые столбцы и проиндексировать их.
```
ALTER TABLE smth
ADD field2_calculated AS CAST(LEFT(field2, 400) AS nvarchar(400));
ALTER TABLE smth
ADD field3_calculated AS CAST(LEFT(field3, 400) AS nvarchar(400));
CREATE INDEX ix_ON ON smth (field2_calculated);
CREATE INDEX ix_ED ON smth (field3_calculated);
```
Теперь выполним запрос в модифицированном виде:
```
SET STATISTICS TIME, IO, XML ON;
SELECT id
FROM smth
WHERE
field1 = N'0FCD0182-AF6E-47E9-94F9-456F2047992C'
OR CAST(LEFT(field2, 400) AS nvarchar(400)) = N'67D1B1C6-8E11-4E7F-BDAD-EF33D8D3AF87'
OR CAST(LEFT(field3, 400) AS nvarchar(400)) = N'D75B375A-E977-4EDD-A836-7AF4967B8BFD'
```
Ура!
> (16 rows affected) Table 'smth'. Scan count 3, logical reads 14, physical reads 0, read-ahead reads 2, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
>
> SQL Server Execution Times: CPU time = 0 ms ...
>
>
ПримечаниеПоскольку в field2 и field3 допустимы NULL'ы, а мы ищем по точному совпадению, имеет смысл делать фильтрованные индексы, с условием field2 IS NOT NULL и field3 IS NOT NULL (не забывая добавить их в запрос). Это вряд ли уменьшит количество чтений, но может очень сильно уменьшить размер индекса, если NULL-значений много.
**А что делать, если nvarchar(max) реально нужен?**
Для примера возьму таблицу dbo.Users из БД [StackOverflow2013](https://www.brentozar.com/archive/2015/10/how-to-download-the-stack-overflow-database-via-bittorrent/) (я использую Medium-вариант, содержащий данные с 2008 по 2013 год). В ней есть столбец AboutMe, по которому я и хочу искать.
SARGabilityНапомню, что поиск всегда будет эффективным либо по полному равенству, либо по LIKE 'smth%', если использовать CHARINDEX или LIKE '%smth%', индексы вам сильно не помогут. Для эффективного использования индекса условия должны быть [SARGable](https://dba.stackexchange.com/questions/162263/what-does-the-word-sargable-really-mean).
Итак, для примера посмотрим сколько будет выполняться такой запрос (я выбрал самое длинное значение поля AboutMe):
```
DECLARE @var AS nvarchar(max);
SELECT TOP 1 @var = AboutMe
FROM dbo.Users
WHERE LEN(AboutMe) = (SELECT MAX(LEN(AboutMe)) FROM dbo.Users);
SET STATISTICS TIME, IO, XML ON;
SELECT *
FROM dbo.Users
WHERE AboutMe = @var
OPTION (RECOMPILE);
SET STATISTICS TIME, IO, XML OFF;
```
OPTION (RECOMPILE) я использую для того, чтобы оптимизатор лучше мог оценивать ожидаемое количество строк. Про то, как локальные переменные могут влиять на это можно прочитать [здесь](https://www.sqlshack.com/impact-of-sql-variables-on-performance/). А переменную использую, потому что ищу значение длиной больше 5000 символов.
> Table 'Users'. Scan count 1, logical reads 44530, physical reads 0, read-ahead reads 25515, lob logical reads 106, lob physical reads 0, lob read-ahead reads 0.
>
> SQL Server Execution Times: CPU time = 828 ms
>
>
Чем в этом случае могут помочь вычисляемые столбцы? Одним из наиболее популярных решений является вычисление хэша, индексирование и сравнение хэшей:
```
ALTER TABLE dbo.Users
ADD AboutMeHash AS CHECKSUM(AboutMe);
CREATE INDEX ix_hash ON dbo.Users (AboutMeHash);
```
Все мы знаем про возможные коллизии, поэтому дополнительно требуется проверка на полное совпадение:
```
DECLARE @var AS nvarchar(max);
SELECT TOP 1 @var = AboutMe
FROM dbo.Users
WHERE LEN(AboutMe) = (SELECT MAX(LEN(AboutMe)) FROM dbo.Users);
SET STATISTICS TIME, IO, XML ON;
SELECT *
FROM dbo.Users
WHERE CHECKSUM(AboutMe) = CHECKSUM(@var) AND AboutMe = @var
OPTION (RECOMPILE);
SET STATISTICS TIME, IO, XML OFF;
```
> Table 'Users'. Scan count 1, logical reads 6, physical reads 3, read-ahead reads 0, lob logical reads 8, lob physical reads 0, lob read-ahead reads 0.
>
> SQL Server Execution Times: CPU time = 0 ms
>
>
Находим полные совпадения по хэшу, дополняем полными значениями и фильтруем по ним. Успех? Успех!
Дополнительно, если мы всё-таки хотим иметь возможность поиска с помощью LIKE smth%, мы можем использовать такой способ (который может не всегда подойти, в зависимости от содержимого столбца):
```
ALTER TABLE dbo.Users
ADD AboutMeLeft AS CAST(LEFT(AboutMe, 800) AS nvarchar(800));
CREATE INDEX ix_lef ON dbo.Users (AboutMeLeft);
```
Теперь первые 800 символов (у меня SQL Server 2017, где максимальная длина ключа некластерного индекса составляет 1600 байт, если у вас SQL Server старше 2016, вы ограничены 900 байтами) можно использовать как нам угодно. Либо так же, как в предыдущем случае, либо с помощью LIKE:
```
DECLARE @var AS nvarchar(max);
SELECT TOP 1 @var = AboutMe
FROM dbo.Users
WHERE LEN(AboutMe) = (SELECT MAX(LEN(AboutMe)) FROM dbo.Users);
SET STATISTICS TIME, IO, XML ON;
SELECT *
FROM dbo.Users
WHERE CAST(LEFT(AboutMe, 800) AS nvarchar(800)) = CAST(LEFT(@var, 800) AS nvarchar(800)) AND AboutMe = @var
OPTION (RECOMPILE);
SET STATISTICS TIME, IO, XML OFF;
```
> Table 'Users'. Scan count 1, logical reads 9, physical reads 0, read-ahead reads 0, lob logical reads 12, lob physical reads 0, lob read-ahead reads 0.
>
> SQL Server Execution Times: CPU time = 0 ms
>
>
```
DECLARE @var AS nvarchar(max);
SELECT TOP 1 @var = LEFT(AboutMe, 10)
FROM dbo.Users
WHERE Id = 9; --случайный Id
SET STATISTICS TIME, IO, XML ON;
SELECT *
FROM dbo.Users
WHERE CAST(LEFT(AboutMe, 800) AS nvarchar(800)) LIKE @var + N'%'
OPTION (RECOMPILE);
SET STATISTICS TIME, IO, XML OFF;
```
> (317 rows affected)
>
> Table 'Users'. Scan count 1, logical reads 1000, physical reads 1, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
>
> Table 'Worktable'. Scan count 0, logical reads 0, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
>
> SQL Server Execution Times: CPU time = 0 ms
>
>
Если сама таблица достаточно "широкая" и Key Lookup'ы дороги, а доставать нужно, например, только идентификатор, то само значение может иметь смысл включать в индекс по вычисляемому полю в качестве INCLUDE-поля.
Про вычисляемые столбцы не очень часто вспоминают как о "технике оптимизации" ([здесь](https://habr.com/ru/company/otus/blog/519848/), например, о них говорят скорее как о потенциальной "угрозе" производительности), однако, иногда они могут сильно помочь. | https://habr.com/ru/post/577612/ | null | ru | null |
# Модульное тестирование для приложений на платформе IBM Notes/Domino
Коснусь темы, которая в мире Notes/Domino практически не известна — модульного (unit) тестирования, и представлю вашему вниманию инструмент на написания unit-тестов для Notes/Domino под язык LotusScript. Статья в большей степени рассчитана на тех, кто работает с платформой IBM Notes/Domino (Lotus Notes), ведет разработку с использованием языка LotusScript.
Немного терминологии, которая будет использоваться в статье:
* Приложение — база данных IBM Notes/Domino или совокупность баз данных, если они представляют собой единую логическую единицу.
* Клиент — толстый клиент, ПО IBM (Lotus) Notes.
* Сервер — серверное ПО IBM Domino.
Начну с описания того, как выглядит разработка, чтобы каждый мог взглянуть на себя. Речь, в первую очередь, идет о написании приложений под толстый клиент с использованием @-формул и языка LotusScript. Оба языка скриптовые, а код можно писать практически везде: в событиях и действиях UI-объектов (таких, как формы и представления), в библиотеках (только для языка LotusScript), агентах и других элементах дизайна базы. К тому же, для каждого события и действия можно независимо выбрать язык, на котором писать. В итоге, если не иметь какой-то подход к организации кода, получается ужасная лапшеобразная каша из кода, разбросанного по всем мыслимым и немыслимым местам. А теперь добавим к этому большой зоопарк приложений, и, обычно, небольшой штат специалистов.
Мне был привит (за что очень благодарен) определенный подход к написанию кода, который я в дальнейшем развивал. В итоге получилась целая система, которая говорит не только о том, где писать, но и как писать. Если в кратце:
* вся бизнес-логика пишется на языке LotusScript, использование @-формул минимально;
* весь код находится в библиотеках, причем разделен на:
+ код, который может использоваться как на сервере, так и на клиенте;
+ код, который может использоваться исключительно на клиенте;
* в визуальных элементах (формы, представления) используются только вызовы библиотечного кода, причем, в подавляющем большинстве — однострочные;
* максимальное использование объектных и минимальное использование процедурных возможностей языка LotusScript.
Так при чем тут модульное тестирование? Чем более сложная, многозвенная система получается, тем сложнее удержать в голове все ее составляющие. Неизбежно правки в одном месте приводят к поломкам в другом. Зачастую, большое количество вариантов происходящего, количество параметров и зависимостей при ограниченных ресурсах, делают практически невозможным ручное тестирование всех вариаций. Нельзя отметать страх изменений, потому как не всегда можно помнить, а уж тем более знать особенности кода, который лежит в основе. Наличие тестов может как очертить границы взаимодействий, так и гарантировать проверку работоспособности. Да, это дополнительные усилия на покрытие тестами, их составление, но, как мне представляется, они того стоят.
Товарищ google, ассистировавший при поиске средств именно модульного (unit) тестирования для IBM Notes/Domino под язык LotusScript, привел только к одному очень старому варианту проекта на [OpenNTF.org](https://openntf.org/main.nsf/project.xsp?r=project/Domino%20Unit%20Framework). В целом, идея, которая крутилась у меня голове, была похожей, но реализация обещала несколько больше. Поэтому было принято решение писать свой, не побоюсь этого слова, framework для unit-тестирования ~~с блэкджеком и куртизанками~~ достаточно гибкий и расширяемый.
За основу построения логики тестов взял обычную для любого (наверно) фреймворка для unit-тестирования: класс с методами-тестами. Эти тесты надо собрать в кучу и прогнать. Итак, в голове составился некоторый список того, что нужно для минимального набора:
1. тесты будут писаться в виде методов класса;
2. тесты будет запускать агент;
3. при написании тестов понадобится набор проверок (ассертов, assert);
4. в рамках запуска тестов должна вестись статистика успешности теста и выводиться строка в тесте, где произошла ошибка.
Некоторые аспекты и допущения, которые были сделаны при проектировании реализации:
* LotusScript не имеет в своем арсенале ни рефлексии, ни аннотаций, а значит необходимо будет явно указывать какие методы являются тестовыми. Варианты, например, с парсингом библиотеки с классами-тестами отмел, как минимум для первого этапа.
* Минимальный набор проверок:
+ сравнение выражения с истиной;
+ ложью;
+ сравнение на равенство. Т.к. вопрос равенства — вещь контекстно-зависимая, в метод сравнения на равенство, будет передаваться объект. Класс этого объекта должен быть унаследован от класса-интерфейса (в языке LotusScript нет чистых интерфейсов) с одним публичными методом, возвращающим логическое значение;
+ проверка на ошибку, а именно, на код ошибки.
При реализации встал вопрос: как фиксировать статистику? Опять же, средств рефлексии и аннотаций нет, значит:
* либо оборачивать каждый тестовый метод в агенте, который их запускает, кодом со статистикой;
* либо внести это в сам тестовый метод.
Принял решение пойти по второму пути. В итоге родился класс AbstractTest с двумя публичными методами: BeginTest(ИМЯ\_ТЕСТА), EndTest(ИМЯ\_ТЕСТА). Почему публичными? Это было сделано для удобства, из-за особенностей встроенной IDE на основе Eclipse: приватные методы суперкласса видны потомкам и доступны для переопределения, но в подсказки самой IDE не попадают. Шаблон каждого тестового метода для успешного сценария выглядит вот так:
```
Public Sub TestMethod()
On Error GoTo ErrorHandler
Const FuncName = "TestClassName.TestSubName ()"
Call Me.BeginTest(funcName)
'Код тестового метода располагается здесь
Call Me.EndTest(funcName)
GoTo endh
ErrorHandler:
Error Err, "(" & DESIGN & ") " & FuncName & ", line " & Erl & Chr(10) & Error$
endh:
End Sub
```
Для тестовых методов с ожидаемой ошибкой он немного отличается и выглядит так:
```
Public Sub TestError()
On Error GoTo ErrorHandler
Const FuncName = "DemoTest.TestAssertErrorExample ()"
Call Me.BeginTest(funcName)
'Код может быть как здесь
On Error ERROR_CODE_TO_TEST GoTo AssertErrorHandler
'Код, который завершается с ошибкой, обозначенной выше располагается здесь
GoTo endh
AssertErrorHandler:
Call Me.EndTest(funcName)
Resume endh
ErrorHandler:
Error Err, "(" & DESIGN & ") " & FuncName & ", line " & Erl & Chr(10) & Error$
endh:
End Sub
```
Из этих размышлений родился тестовый контекст, хранящий информацию времени выполнения тестов:
* данные о статусах прохождения тестов;
* возможность добавления тестов и изменения статусов;
* ведение логирования.
Шаблонизированию подвергся и класс, ответственный за запуск тестов. Если свести к минимуму код, то он состоит из основного метода Run() и метода, который следует переопределить в агенте, запускающем тесты DoRunTests(). Метод DoRunTests как раз должен содержать создание классов-тестов и вызов соответствуютщих тестовых методов:
```
Class AbstractTestRunner
Public Function Run()
On Error GoTo ErrorHandler
Const FuncName = "AbstractTestRunner.Run ()"
[...]
Call Me.DoRunTests()
[...]
GoTo endh
ErrorHandler:
Error Err, "(" & DESIGN & ") " & FuncName & ", line " & Erl & Chr(10) & Error$
endh:
End Function
Private Sub DoRunTests()
On Error GoTo ErrorHandler
Const FuncName = "AbstractTestRunner.RunTests ()"
'Override
GoTo endh
ErrorHandler:
Call Me.TestFailed(Error$)
Resume Next
endh:
End Sub
End Class
```
С проверками все просто. Небольшого отдельного внимания может заслуживать только метод сравнения на равенство:
```
Public Sub Equals(matcher As IMatcher)
On Error GoTo ErrorHandler
Const FuncName = "Assert.Equals ()"
If Not Matcher.Matches() Then Call Me.Throwerror(funcName)
GoTo endh
ErrorHandler:
Error Err, "(" & DESIGN & ") " & FuncName & ", line " & Erl & Chr(10) & Error$
endh:
End Sub
```
Как говорилось выше, он принимает объект, чей класс унаследован от класса-интерфейса (IMatcher), имеющего только один публичный метод Matches() as boolean.
```
Class IMatcher
Public Function Matches() As Boolean
End Function
End Class
```
Также было реализовано несколько простых матчеров, которые были вынесены в отдельную библиотеку:
* SimpleValueMatcher — простое сравнение 2ух значений. Значения принимаются с типом Variant.
* DocumentItemsMatcher — сравнение заданных полей в двух заданных документах. Сравнение происходит на наличие поля, на тип и значение.
* DatabaseMatcher — сравнение двух баз: id реплики, пути и названия. Суть — мы имеем дело с одной и той же базой. Целесообразно сюда еще сравнение на сервер добавить.
* DocumentMatcher — сравнение 2х документов на идентичность: лежат в одной базе, имеют один и тот же UniversalId, совпадают по всем полям.
Проект размещен в открытом доступе на [GitHub](https://github.com/MrArtemAA/DUnit), распространяется по лицензии Apache 2.0 и снабжен подробной документацией по установке и использованию. Также проект был размещен на самой популярной для domino-водов площадке — [Openntf.org](https://openntf.org/main.nsf/project.xsp?r=project/DUnit).
В качестве развития вижу:
1. упростить написание тестов, чтобы можно было избавится от ряда условностей при их создании;
2. избавиться от необходимости вручную создавать тестовые классы и вызывать тестовые методы;
3. создать централизованное приложение для запуска и сбора результатов тестирования.
Так получилось, что та система, которая показала всю необходимость создания unit-тестирования для Domino и сподвигла меня на написание представленного инструмента, на текущий момент так и не покрыта тестами. Однако готовлю еще один проект, который изначально должен стать публичными. Первая версия уже готова и на 100% покрыта тестами, созданными на описанном фреймворке. Статистику прохождения тестов собираюсь прикладывать к каждому релизу.
Конструктивные идеи, предложения и замечания всегда приветствуются! | https://habr.com/ru/post/346708/ | null | ru | null |
# Padding Oracle Attack или почему криптография пугает
Все мы знаем, что не следует самостоятельно реализовывать криптографические примитивы. Мы также в курсе, что даже если мы хитрым образом развернем порядок букв во всех словах сообщения, сдвинем каждую букву по алфавиту на 5 позиций и разбавим текст случайными фразами, чтобы сбить атакующих с пути, наш замечательный шифр скорее всего вскроет любой мало-мальски знакомый с криптографией человек (а в данном случае с задачей справится и в меру умный 12-летний подросток).
Однако, и внедрение известных и стойких алгоритмов не является панацеей. Даже если вы возьмете готовую реализацию данного алгоритма, сгенерируете секретные ключи согласно всем требованиям и тому подобное, все-равно вы останетесь потенциально подвержены некоторым весьма эффективным атакам. Опытному злоумышленнику достаточно крошечной, казалось бы, совершенно несвязанной с криптосистемой толики информации, чтобы обойти шифрование.
Мой посыл не в том, что убедить вас отказаться от самостоятельного использования криптографических средств или пойти и нанять консультанта с зарплатой от $1000 в час всякий раз когда вы задумываетесь о шифровании.
Частично я веду к тому, что вам никогда не следует расслабляться, всегда нужно быть начеку, изыскивая пути, которые злоумышленник может использовать для получения дополнительной информации о вашей системе, а частично к тому, что Padding Oracle Attack является крутой демонстрацией всего этого. Итак, начнем.
Режим CBC
=========
CBC, или режим сцепления блоков шифротекста, это один из режимов симметричного блочного шифрования с использованием механизма обратной связи. Это означает, что при шифровании очередной блок открытого текста проходит через блочный алгортим шифрования, а также дополнительно изменяется с использованием результата шифрования предыдущего блока.
Так что, если мы шифруем предложение:
> This is a sentence of a carefully chosen length.
мы получим результат шифрования для каждого блока из 16 байт, причем последний блок открытого текста будет специальным образом дополнен (но об этом далее).
В CBC каждый блок открытого текста складывается побитово по модулю два (xor) с предыдущим блоком шифротекста перед тем как поступить на вход алгоритму шифрования. Данная взаимозависимость блоков означает, что каждый блок шифротекста зависит от каждого блока открытого текста, который был обработан к данному моменту. Причем изменение любого байта открытого текста приведет к изменению всех последующих байт шифротекста (лавинный эффект, ага). Согласно Википедии — CBC является «одним из двух режимов симметричного блочного шифрования, рекомендованных Нилом Фергюсоном и Брюсом Шнайером».
Как работает дополнение блоков (важно!)
=======================================
Предпочтительным методом дополнения блоков шифротекста, является PKCS7. В нем значение каждого дополняемого байта устанавливается равным количеству дополняемых байт. Так если мы имеем блок из 12 символов, он будет дополнен четырьмя байтами **[04, 04, 04, 04]** до стандартного размера блока в 16 байт. Если блок имеет размер в 15 байт, он будет дополнен одним байтом [01]. Если блок имеет размер ровно в 16 байт, мы добавляем новый блок состоящий из **[16]\*16**. (подробнее — <https://en.wikipedia.org/wiki/Padding_(cryptography)#PKCS7>)
Солгасно данному методу, последний блок расшифрованного открытого текста не может заканчиваться, например, на **[..., 13, 06, 05]**. А значит, что и оригинальный шифротекст является неверным, потому как не существует допустимых открытых текстов, которые могли бы быть преобразованы в такой шифротекст.
The Padding Oracle Attack
=========================
Оказывается, что знания факта, получается ли при расшифровке шифротекста открытый текст с корректным дополнением, достаточно атакующему для проведения успешной атаки на шифрование в режиме CBC. Если мы можем подавать какому-то сервису шифротексты, а он будет возвращать нам информацию, корректно ли дополнение — мы сможем вскрыть ЛЮБОЙ шифротекст.
Так что ошибкой, которой достаточно, чтобы обрушить ваше шифрование, может являться некоторый API, который будет возвращать код **200**, если поданный нами шифротекст расшифровывается во что-то с корректным дополнением, и код **500**, если нет.
Это не маловероятная ситуация. Например, Ruby OpenSSL подвержен данной проблеме. Достаточно использовать пример кода из официальной документации (<http://www.ruby-doc.org/stdlib-1.9.3/libdoc/openssl/rdoc/OpenSSL/Cipher.html#documentation>):
```
decipher = OpenSSL::Cipher::AES.new(128, :CBC)
decipher.decrypt
decipher.key = "the most secret!"
decipher.iv = "also very secret"
plain = decipher.update("thewrongpadding!") + decipher.final
```
Данный код выдает **OpenSSL::Cipher::CipherError: bad decrypt**, который, если его не перехватить, вернет ответ с ошибкой **500**.
Положим, что мы украли шифротекст. Если мы можем посылать шифротексты и определять расшифровываются ли они в сообщения с корректным дополнением, как же нам использовать это для того, чтобы полностью расшифровать украденный шифротекст?
Промежуточное состояние (The intermediate state)
================================================
Повторим еще раз — в CBC режиме каждый блок открытого текста побитово складывается по модулю два (XOR) с предыдущим блоком шифротекста перед тем как пойти на вход шифру. При расшифровании каждый шифротекст проходит через дешифратор и затем XOR'ится с предыдущим блоком шифротекста, чтобы произвести открытый текст.
Атака работает через вычисление «промежуточного состояния» процедуры расшифрования (смотри схему) для каждого блока шифротекста. Это состояние блока шифротекста после расшифрования блочным алгоритмом, но ДО процедуры XOR с предыдущим блоком шифротекста. Мы будем находить это состояние, поднимаясь снизу от открытого текста, вместо того, чтобы спускаться вниз через блочный шифр. Также мы вообще не будем волноваться на счет ключа шифрования или алгоритма блочного шифрования.
Почему же данное промежуточное состояние так важно? Заметим:
```
I2 = C1 ^ P2
и
P2 = C1 ^ I2
```
Мы уже знаем C1 т.к. это часть шифротекста, который мы имеем. Так что если мы найдем I2, мы можем легко найти P2 и расшифровать сообщение.
Манипулирование шифротекстами
=============================
Вспомним, что мы можем подавать на вход системе любой шифротекст, и сервер ответит нам корректное ли дополнение получается после расшифрования. Мы используем данный факт, подавая на вход **C1' + C2**, где **C1'** — специальным образом сформированный нами блок шифротекста, а **C2** — это блок, который мы хотим расшифровать. Под обозначением **C1' + C2** мы понимаем простую конкатенацию (то-есть, «склеивание» блоков). Обозначим результат расшифрования как **P'2**.
Начнем с того, что мы заполним **C1'[1..15]** случайными байтами, а **C1'[16]** заполним нулем (**0x00**). Теперь подадим **C1' + C2** серверу. Если сервер ответит, что дополнение получилось корректное, то мы можем быть уверены (с большой вероятностью), что **P2'[16]** равно **0x01** (т.к. дополнение корректно). Если сервер отвечает ошибкой — посылаем сообщение с **C1'[16]**, установленным в **0x01**, затем в **0x02** и.т.д. пока не получим нужный нам ответ.
> (примечание переводчика. Конечно же возможна ситуация, когда мы получим два верных ответа:
>
> 1) для дополнения 01
>
> 2) для дополнения 02,02 или 03,03,03…
>
>
>
> Если произошла такая ситуация — просто меняем предпоследний байт C1' и повторяем операцию заново.
>
> В самом крайнем случае, нам понадобится три попытки, но это маловероятно.
>
> )
Теперь положим, что сервер вернул ответ **200** при **C1'[16] = 94**.
```
I2 = C1' ^ P2'
I2[16] = C1'[16] ^ P2'[16]
= 94 ^ 01
= 95
```
Ура! Мы получили финальный байт промежуточного состояния. Т.к. **C2** взят из реального шифротекста, то **I2** тоже идентичен реальному. Поэтому, мы можем расшифровать последний байт настоящего открытого текста:
```
P2[16] = C1[16] ^ I2[16]
= C1[16] ^ 95
```
Мы подаем на вход **C1'[16] = C1[16]** и получаем последний байт реального открытого текста. На этом этапе, мы нашли всего-лишь заполнитель, так что придется проделать еще несколько итераций данного процесса, пока мы не обнаружим что-нибудь интересное.
Продолжаем
==========
Мы нашли последний байт прокручиванием **C1'** до получения корректного дополнения. При этом мы можем сделать заключение, что последний байт **P'2** равен **0x01**. Затем используя **P2'[16]** и **C1'[16]**, находим **I2[16]**. Продолжая этот процесс, находим оставшиеся байты **I2** и расшифровываем весь блок шифротекста.
Заполняем **C1'[1..14]** случайными байтами, **C1'[15]** устанавливаем в **0x00**, а **C1'[16]** таким, чтобы получить **P2'[16] == 0x02**:
```
C'1[16] = P'2[16] ^ I2[16]
= 02 ^ 95
= 93
```
Теперь мы можем быть уверены, что **P2'** будет заканчиваться на 0x02, и поэтому единственный вариант, при котором **P2'** будет иметь корректное дополнение — если **P2[16] == 0x02**. Мы будем прокручивать **C1'[15]**, пока сервер не выдаст нам код **200**. Предположим, что это случилось при **C1'[15] == 106**. Проделываем опять то, что мы уже умеем:
```
I2 = C1' ^ P2'
I2[15] = C1'[15] ^ P2'[15]
= 106 ^ 02
= 104
```
И вуаля! Мы знаем предпоследний байт **I2**. Поэтому можем найти предпоследний байт **P2**, как мы это уже проделывали ранее:
```
P2[15] = C1[15] ^ I2[15]
= C1[15] ^ 104
```
И так далее для всех 16 байтов **C2**.
Остальные блоки
===============
Форма блоков шифротекста зависит только от них самих и предшествующих блоков. Так что мы можем применить вышеприведенный алгоритм к каждому блоку шифротекста (отдельно от первого). Первый блок будет зашифрован с использованием вектора инициализации (**IV**), а сам **IV** выбран случайно при процедуре зашифрования. До тех пор, пока мы не узнаем **IV**, мы не сможем расшифровать первый блок, и нет ничего, что тут можно придумать, кроме глупого перебора очевидных значений **[0,0,0,...]** для **IV** и просмотра, получается ли какой-нибудь разумный открытый текст. И делать так в надежде, что первые 16 байт будут чем-нибудь вроде "*Дорогой Евгений!*".
Это все и есть *Padding Oracle Attack*.
Вот почему все, что связано с криптографией пугает.
Мы знаем, что не следует самостоятельно реализовывать криптографические примитивы, и что мы строим систему на чем-то уже изобретенном. Легко почувствовать себя расслабленно, когда мы прячемся за стойким шифром, разработанным специалистами. И пока мы держим наши ключи в секрете и не храним нигде открытые тексты, мы чувствуем себя неуязвимыми.
Но, как вы только что видели, достаточно малейшего стороннего канала, капельки информации, чтобы система стала полностью уязвимой. Наш воображаемый разработчик использовал стойкий алгоритм из существующей библиотеки, сгенерировал ключи требуемой длины и не сделал никаких глупостей, вроде повторного использования временных значений (*nonce*). Его единственной ошибкой было не перехватить неочевидное исключение, что привело нас к возможности понять расшифровывается ли наш шифротекст во что-то корректное.
Конечно, конкретно данная атака может быть предотвращена путем перехвата исключений, ограничения числа запросов с одного IP адреса и мониторингом подозрительных запросов, но не в этом суть. Злоумышленники всегда изощренные и будут использовать даже малейшее несовершенство реализации. Будьте осторожны со своей криптографией, даже если она взята из надежного источника.
Спасибо.
The Matasano Crypto Challenges (<http://matasano.com/articles/crypto-challenges/>), благодаря которым я заинтересовался криптографией. Очень рекомендую!
\_\_\_\_\_
Перевод сделан с разрешения автора статьи Robert Heaton.
Источник: <http://robertheaton.com/2013/07/29/padding-oracle-attack/>
Еще интересные ссылки по теме:
<https://class.coursera.org/crypto-preview/lecture/38> | https://habr.com/ru/post/247527/ | null | ru | null |
# Внутренние и вложенные классы java. Часть 1
**Внутренние и вложенные классы java. Часть 1**
02.03.2017 — 2019 год
**Часть 1. Начало**
**Цель статьи:** Рассказать о внутренних, вложенных, локальных, анонимных классах. Показать примеры их использования. Написать и протестировать классы в коде на java. Рассказать о свойствах этих классов. Материал предназначен для лучшего понимания безымянных классов, лямбда выражений, адаптеров и многопоточности. То есть перед их изучением.
Небольшое вступление. Предлагаю вашему вниманию цикл из трех статей.
В них я рассказываю о внутренних, вложенных, локальных, анонимных классах. Речь идет о терминологии и применении. Для этих статей я написал довольно много кода.
Это учебный код, а не руководство к действию. То есть сам код я написал для лучшего понимания. Также я постарался объяснить работу учебного кода. На написание данной публикации, ушло довольно много времени. Публикация состоит из трех частей. Прошу отнестись с пониманием.
Для лучшего изучения материала у вас должна быть некоторая подготовка.
То есть вам нужно знать: синтаксис языка java, область видимости переменных, классы, статические и нестатические члены класса, создание экземпляров класса, наследование, модификаторы доступа.
Начнем с того, что же такое внутренние и вложенные классы. Посмотрим терминологию, встречающуюся в документации и литературе:
> В Java существуют 4 типа вложенных (nested) классов:
>
>
>
> 1. Статические вложенные классы
> 2. Внутренние классы
> 3. Локальные классы
> 4. Анонимные (безымянные) классы
>
>
>
>
Джошуа Блох:
>
>
> Существуют четыре категории вложенных классов:
>
>
>
> * статический класс-член (static member class),
> * не статический класс-член (nonstatic member class),
> * анонимный класс (anonymous class)
> * и локальный класс (local class).
>
>
>
>
Попытаемся разобраться, что же это такое.
Начнем немного отдаленно, так как всё это имеет непосредственное отношение к нашим вопросам. Вспомним объектно-ориентированное программирование. Отношения композиции и наследования.
В своей книге «Java 2 Руководство разработчика» Майкл Морган очень хорошо и подробно описывает взаимосвязи классов и объектов. Мы рассмотрим некоторые из них. Взаимосвязь «это — есть — то» выражается наследованием, а взаимосвязь «имеет часть» описывается композицией.
В наших примерах мы в основном рассматриваем композицию. Так как вложенные классы — это и есть часть чего-то. То есть у нас есть класс оболочка и вложенный класс определенный внутри класса оболочки. Пример композиции: машина имеет двигатель, двери, 4 колеса, корпус. И мы можем описать машину с помощью внутренних (Inner) классов.
Пример такого использования вы можете найти в книге Брюса Эккеля «Философия Java»
```
/* Пример №1 */
//: c06:Car.java
// композиция с использованием открытых объектов
// двигатель
class Engine{
public void start(){}
public void rev(){}
public void stop(){}
}
class Wheel{
public void inflare(int psi){}// накачать
}
// окно
class Window{
public void rollup(){}// приоткрыть
public void rolldown(){}// опустить
}
// дверь
class Door{
public Window window=new Window();
public void open(){}//открыть
public void close(){}// закрыть
}
// машина
public class Car{
public Engine engine = new Engine();
public Wheel[] wheel = new Wheel[4];
public Door left = new Door(),
right = new Door();//две двери
public Car(){
for(int i = 0; i<4; i++)
wheel[i]= new Wheel();
}
public static void main(String[] args){
Car car= new Car();
car.left.window.rollup();
car.wheel[0].inflare(72);
}
}
```
Есть некоторое предупреждение автора по использованию кода в таком виде:
> Так как композиция объекта является частью проведенного анализа задачи (а не
>
> просто частью реализации класса), объявление членов класса открытыми, помогает программисту-клиенту понять, как использовать класс, и упрощает создателю написание кода. Однако нужно помнить, что описанный случай является особым, и в основном поля класса нужно объявлять как private.
Выше я не случайно упомянул наследование и композицию. Это напрямую относится к дальнейшему материалу.
**Статические вложенные классы**
*Определение вложенных классов:*
> Класс называется вложенным (nested), если он определен внутри другого класса.
То есть класс просто определен внутри другого, даже не важно статически определен или не статически. Вложенный класс создается для того, чтобы обслуживать окружающий его класс. Если вложенный класс оказывается полезен в каком-либо ином контексте, он должен стать классом верхнего уровня.
*Применение*
Вложенные классы применяются в тех случаях, когда нужно написать небольшой вспомогательный код для другого класса. Вложенный класс создают также, чтобы скрыть его переменные и методы от внешнего мира. Таким образом, вложенный класс еще один элегантный способ ограничения области видимости. Внутренние классы также есть смысл использовать, если предполагается, что они будут использовать элементы родителя, чтобы не передавать лишнего в конструкторах.
Пример вложенного класса вы можете увидеть в документации Оракле:
```
/* Пример №2 */
//
class OuterClass {
...
class NestedClass {
...
}
}
```
У нас нет, пока что, никакого контекста использования данной конструкции. С таким же успехом вложенный класс мы можем назвать вместо: «Вложенный класс» (NestedClass) — «Внутренний класс» InnerClass. Далее будем разбираться, в чем же отличия, и в каких контекстах используются классы. Брюс Эккель пишет в книге «Философия Java» так:
> «Класс называется вложенным (nested), если он определен внутри другого класса»
Документацию Oracle вы можете посмотреть по этой ссылке: [>>>](https://docs.oracle.com/javase/tutorial/java/javaOO/nested.html)
**Терминология:**
Существует четыре категории вложенных классов:
1. Статические вложенные классы и не статические вложенные классы. Вложенные классы, объявленные статически, называются вложенными статическими классами.
2. Внутренние классы — когда объект внутреннего класса связан с объектом обрамляющего класса. Не статические вложенные классы называются внутренними классами, если они связанны с внешним классом.
3. Локальные классы — объявленные внутри блока кода и не являющиеся членом обрамляющего класса. В этом случае можно рассматривать класс как локальную переменную типа класс.
4. Анонимные классы – наследуемые, от какого либо класса, классы в которых при объявлении не задано имя класса.
**Причины использования вложенных классов (Nesred Classes)
Зачем использовать вложенные классы?**
Причины использования вложенных классов такие. Если класс полезен только для одного другого класса, то вполне логично встроить его в этот класс и хранить их вместе. Использование вложенных классов увеличивает инкапсуляцию. Рассмотрим два класса верхнего уровня, A и B, где B нужен доступ к членам, которые иначе были бы объявлены закрытыми.
```
/* Пример №3 */
//
class A{
...
class B {
...
}
}
```
Скрывая класс «B» в пределах класса «А», члены класса «А» могут быть объявлены закрытыми, и «B» может получить доступ к ним. Кроме того, сам «B» может быть скрыт от внешнего мира.
Продемонстрируем это в коде:
```
/* Учебный пример №4 */
package innernested;
/**
*
* @author Ar20L80
*/
public class A {
private static int iPrivVar;
class B {
void setPrivateOfA(int var)
{
A.iPrivVar = var;
}
}
}
```
Использование вложенных классов приводит к более читабельному и поддерживаемому коду: Размещение класса ближе к тому месту, где он будет использован, делает код более читабельным.
**Статические Вложенные Классы
Static Nested Classes**
Причины использования статических вложенных классов такие.
Для случая, когда связь между объектом вложенного класса и объектом внешнего класса не нужна, можно сделать вложенный класс статическим(static).
Так как внутренний класс связан с экземпляром, он не может определить в себе любые статические члены.
Статические вложенные классы не имеют ограничений по объявлению своих данных и полей как static.
Из вложенного статического класса мы не имеем доступа к внешней не статической переменной внешнего класса.
Приведенный ниже код демонстрирует это:
```
/*
Учебный пример №5
Статические вложенные классы
Попытка доступа к не статической переменной
внешнего класса Outer2 через обращение из вложенного статического класса Nested2
*/
package nested;
/**
*
* @author Ar20L80
* 20.03.2016
*/
public class Outer2 {
public int pubOutVar; // переменная не статическая и мы не имеем к ней доступа
// из внутреннего статического класса
private int prOutVar;
public Outer2(){}// конструктор внешнего класса
static class Nested2{
public static int pub_innVar; // тут все в порядке
public Nested2() {} // конструктор вложенного класса
int getOuterPublicVariable()
{
return Outer2.this.pubOutVar; // ошибка
return Outer2.pubOutVar; // ошибка
}
int getOuterPrivateVariable()
{
return Outer2.this.prOutVar; // ошибка
return Outer2.prOutVar; // ошибка
}
}
}
/*
вывод программы:
программа не компилируется
*/
```
*Вывод:* Мы не имеем доступа к не статическому полю внешнего класса, через статический контекст вложенного класса. Это подобно тому, как мы не имеем доступа из статического метода к нестатическим переменным класса. Точно также из статического вложенного класса мы не имеем доступа к нестатическим переменным внешнего класса.
Но мы имеем доступ к приватным статическим полям внешнего класса из вложенного статичного класса.
Приведенный ниже фрагмент кода демонстрирует это:
```
/*
Учебный пример №6
Статические вложенные классы
Демонстрация доступа к «приватной» статической переменной
внешнего класса из внутреннего статического класса
20.03.2016
*/
package nested;
/**
*
* @author Ar20L80
*/
public class Outer3 {
private static int prStOuterVar;
public Outer3(){}
static class Nested3 // Nested
{
int getStaticOuterVar()
{
return Outer3.prStOuterVar; // ok
}
void setStaticOuterVariable(int var)
{
Outer3.prStOuterVar = var; // ok
}
}
public static void main(String[] args) {
Outer3.Nested3 nestedObj = new Outer3.Nested3(); // экземпляр класса внутренний
Outer3.prStOuterVar = 19;
System.out.println("nestedObj.getStaticOuterVar() = "+nestedObj.getStaticOuterVar());//статическая переменная внешнего класса из экземпляра внутреннего
// устанавливаем через экземпляр внутреннего класса
nestedObj.setStaticOuterVariable(77);
System.out.println("Outer3.prStOuterVar = "+ Outer3.prStOuterVar);
}
}
/*
Вывод программы:
nestedObj.getStaticOuterVar() = 19
Outer3.prStOuterVar = 77
*/
```
В этом примере кода мы создали экземпляр внутреннего класса с именем «nestedObj».
То есть мы получаем доступ к приватной статической переменной внешнего класса, через экземпляр внутреннего класса. В контексте экземпляра связанного с внешним классом, у нас получился внутренний класс.
**Литература**
Майкл Морган. «Java 2. Руководство разработчика» ISBN 5-8459-0046-8
Брюс Эккель. «Философия Java.» ISBN 5-272-00250-4
Герберт Шилдт «Java. Полное руководство. 8-е издание.» ISBN: 978-5-8459-1759-1
**Ссылки:**
[ru.wikipedia.org](https://ru.wikipedia.org/)
[src-code.net/lokalnye-vnutrennie-klassy-java](http://src-code.net/lokalnye-vnutrennie-klassy-java/)
[Документация Oracle](https://docs.oracle.com/javase/tutorial/java/javaOO/nested.html)
Все вопросы, комментарии, дополнения, критика приветствуются.
Продолжение следует…
Часть 2 [>>>](https://habr.com/ru/post/439666/)
*Если у вас есть возможность, вам пригодилось, и вы можете помочь, то нажмите кнопку поддержать автора материально.* | https://habr.com/ru/post/439648/ | null | ru | null |
# Поддельное BLE-устройство на nRF24l01
Данная статья на 90% основывается на заметке [«Bit-Banging» Bluetooth Low Energy](http://dmitry.gr/index.php?r=05.Projects&proj=11.%20Bluetooth%20LE%20fakery). Все началось с того, что потребовалось запустить распространенные сейчас трансиверы на чипе Nordic nRF24l01. В процессе поиска примеров работы с ними я и наткнулся на вышеупомянутую статью. Являясь обладателем телефона с поддержкой Bluetooth 4.0 (который и включает в себя Bluetooth Low Energy), подумал: а почему бы не попытаться повторить эксперимент?
### Описание
Как выглядит устройство и какая у него схема описывать не буду. В интернете, включая русскоязычный, полно информации по описываемым радиомодулям. Скажу только, что в моем случае для управления был использован микроконтроллер NXP LPC1343 (для него и представлена прошивка внизу).
Как обычно, чудес не бывает: пример не захотел работать в виде «как есть». Во-первых на странице присутствует явное повреждение форматирования, во-вторых сразу видно что есть проблема с байтом длины. Какие еще опечатки и неточности присутствуют в описании, мне оставалось только гадать. Однако, после непродолжительных правок все заработало.
BLE-устройство сильно отличается от всех прочих «синих зубчиков», достаточно упомянуть, что стандартный поиск устройства в Android не ищет BLE: для их обзора требуются отдельные приложения. BLE устройства — отдельное ответвление в Bluetooth-технологии, фактически это еще один стандарт. Видимо, он разрабатывался с оглядкой на возможности малопотребляющих трансиверов на 2.4ГГц. Отсюда и итоговое сходство.
А сходства следующие:
* Одинаковые рабочие частоты 2.4GHz с поддержкой скорости 1Mbps и пересекающаяся сетка каналов.
* Одинаковые байты стартовые байты 10101010 или 01010101 (преамбула).
* Одинаковая модуляция сигнала: [GFSK](https://en.wikipedia.org/wiki/GFSK).
* Возможность задать в nRF24l01 адресацию 4 байтами.
Но вот и отличия:
* Разные алгоритмы CRC. Благо в nRF24l01 его можно отключить и заниматься расчетом программно в микроконтроллере.
* nRF24l01 после каждой передачи отключает [PLL](https://en.wikipedia.org/wiki/Phase-locked_loop). Это подкладывает свинью в реализации протокола, т.к. повторный запуск PLL требует приличное время.
* BLE поддерживает пакеты данных с длиной до 39 байт. У nRF24l01 это значение ограничено 32 байтами.
Именно из-за последнего пункта полноценного протокола BLE поднять не получится. Однако, мы можем составить корректный Broadcast-пакет, который участвует в процессе поиска устройства.
Код составления пакета:
```
buf[L++] = 0x42; //PDU type, given address is random
buf[L++] = 0x11; //17 bytes of payload
buf[L++] = MY_MAC_0;//0xEF
buf[L++] = MY_MAC_1;//0xFF
buf[L++] = MY_MAC_2;//0xC0
buf[L++] = MY_MAC_3;//0xAA
buf[L++] = MY_MAC_4;//0x18
buf[L++] = MY_MAC_5;//0x00
buf[L++] = 2; //flags (LE-only, limited discovery mode)
buf[L++] = 0x01;
buf[L++] = 0x05;
buf[L++] = 7; //name
buf[L++] = 0x08;
buf[L++] = 'n';
buf[L++] = 'R';
buf[L++] = 'F';
buf[L++] = ' ';
buf[L++] = 'L';
buf[L++] = 'E';
buf[L++] = 0x55; //CRC start value: 0x555555
buf[L++] = 0x55;
buf[L++] = 0x55;
//...
btLePacketEncode(buf, L, chLe[ch]); // crc calculate
```
Программа делает только одно: инициализирует радиомодуль специальным образом, составляет пакет и отправляет его. Этого достаточно, чтобы телефон показал устройство в поиске.
### Как использовать
После того, как мой телефон увидел приложение, сразу встал вопрос: а можно ли каким-то образом использовать эту «подделку»?
Ограничения в чипе nRF24l01 не дают возможности поднять полноценный BLE-протокол и заканчиваются на том, что телефон «видит» нечто, но никаким образом с ним работать не может. Соответственно, передача данных в устройство отметается сразу, а вот что с передачей данных в телефон? Имя и мак-адрес телефон определяет, а это уже какая-никакая информация, а что еще?
А еще можно передавать и наши данные. Для этого необходимо в буфер добавить дополнительные поля. Лучше всего для этого подходит тег MANUFACTURER\_DATA=0xFF. Данных за раз можно передавать не более 32 байт (ограничение модуля nRF24l01), при этом часть их тратится на передачу служебных структур BLE. В чистом остатке остается около 32-6-3-3 = 20 байт. Из них 2 байта уйдут на заголовок, таким образом «наших» данных может быть 18 байт. Но стоит учесть, что данный расчет я привел для безымянного устройства.
### Применения
Теоретически данный хак можно использовать и в реальных устройствах. Стоимость nRF24l01 кардинально ниже true-BLE-модулей. В смартфон можно передавать данные с каких-либо датчиков, причем как и в случае с BLE, датчики могут иметь батарейное питание.
Если взять связку из примитивнейшего ATtiny13 и nRF24l01, получится устройство копеечной стоимости. Разместив десяток или сотню таких в большом помещении (к примеру, ТЦ) можно развернуть локальную систему позиционирования, которая в приложении точно покажет где же находится владелец телефона.
*К сожалению, для меня открыт вопрос: каким будет потребление самого смартфона. Все-таки связь с устройством не устанавливается, приходится постоянно проводить сканирование. Может кто знаком с темой и сможет прокомментировать.*
### ANT+
В довесок, исследовал возможность реализации взаимодействия nRF24l01 с ANT+ устройствами. Здесь, к сожалению, все потеряно. Если байт синхронизации в BLE и nRF24l01 совпадает, то в случае с ANT-протоколом работать ничего не будет: последний имеет отличный от них вектор.
### Ссылки
* Оринальная статья: [«Bit-Banging» Bluetooth Low Energy](http://dmitry.gr/index.php?r=05.Projects&proj=11.%20Bluetooth%20LE%20fakery)
* Модифицированная версия утилиты [BluetoothLeGatt](http://igorkov.org/zip/BluetoothLeGatt_v2.zip). Добавлен вывод тела пакета при поиске. В данном теле видны передаваемые приложением данные. Экран работы утилиты представлен выше.
* [Исходный код](http://igorkov.org/zip/blehack_v1.zip) работы с модулем.
* [Бинарник](http://igorkov.org/zip/ble-spibridge.bin) с прошивкой микроконтроллера LPC1343 (мост USB-SPI). | https://habr.com/ru/post/245671/ | null | ru | null |
# Отслеживание лиц в реальном времени в браузере с использованием TensorFlow.js. Часть 5
Носить виртуальные аксессуары – это весело, но до их ношения в реальной жизни всего один шаг. Мы могли бы легко создать приложение, которое позволяет виртуально примерять шляпы – именно такое приложение вы могли бы захотеть создать для веб-сайта электронной коммерции. Но, если мы собираемся это сделать, почему бы при этом не получить немного больше удовольствия? Программное обеспечение замечательно тем, что мы можем воплотить в жизнь своё воображение.
В этой статье мы собираемся соединить все предыдущие части, чтобы создать волшебную шляпу для обнаружения эмоций, которая распознаёт и реагирует на выражения лиц, когда мы носим её виртуально.
---
Вы можете загрузить демоверсию этого проекта. Для обеспечения необходимой производительности может потребоваться включить в веб-браузере поддержку интерфейса WebGL. Вы также можете загрузить [код и файлы](https://disk.yandex.ru/d/kvcWY8Ttpkh7jQ) для этой серии. Предполагается, что вы знакомы с JavaScript и HTML и имеете хотя бы базовое представление о нейронных сетях.
Создание волшебной шляпы
------------------------
Помните, как мы ранее в этой серии статей создавали функцию обнаружения эмоций на лице в реальном времени? Теперь давайте добавим немного графики в этот проект – придадим ему, так сказать, «лицо».
Чтобы создать нашу виртуальную шляпу, мы собираемся добавить графические ресурсы на веб-страницу как скрытые элементы `img`:
```
```
Ключевое свойство этого проекта заключается в том, что шляпа должна отображаться всё время, в правильном положении и с правильным размером, поэтому мы сохраним «состояния» шляпы в глобальной переменной:
```
let currentEmotion = "neutral";
let hat = { scale: { x: 0, y: 0 }, position: { x: 0, y: 0 } };
```
Рисовать шляпу этого размера и в этом положении мы будем с помощью 2D-преобразования полотна в каждом кадре.
```
async function trackFace() {
...
output.drawImage(
video,
0, 0, video.width, video.height,
0, 0, video.width, video.height
);
let hatImage = document.getElementById( `hat-${currentEmotion}` );
output.save();
output.translate( -hatImage.width / 2, -hatImage.height / 2 );
output.translate( hat.position.x, hat.position.y );
output.drawImage(
hatImage,
0, 0, hatImage.width, hatImage.height,
0, 0, hatImage.width * hat.scale, hatImage.height * hat.scale
);
output.restore();
...
}
```
По ключевым точкам лица, предоставляемым TensorFlow, мы можем рассчитать размер и положение шляпы относительно лица, чтобы задать указанные выше значения.
Размер головы можно оценить по расстоянию между глазами. Вектор «вверх» аппроксимируем по точке `midwayBetweenEyes` и точке `noseBottom`, которые можно использовать для перемещения шляпы вверх ближе к верхней части лица ([в отличие от виртуальных очков из предыдущей статьи](https://habr.com/ru/company/skillfactory/blog/545334/)).
```
const eyeDist = Math.sqrt(
( face.annotations.leftEyeUpper1[ 3 ][ 0 ] - face.annotations.rightEyeUpper1[ 3 ][ 0 ] ) ** 2 +
( face.annotations.leftEyeUpper1[ 3 ][ 1 ] - face.annotations.rightEyeUpper1[ 3 ][ 1 ] ) ** 2 +
( face.annotations.leftEyeUpper1[ 3 ][ 2 ] - face.annotations.rightEyeUpper1[ 3 ][ 2 ] ) ** 2
);
const faceScale = eyeDist / 80;
let upX = face.annotations.midwayBetweenEyes[ 0 ][ 0 ] - face.annotations.noseBottom[ 0 ][ 0 ];
let upY = face.annotations.midwayBetweenEyes[ 0 ][ 1 ] - face.annotations.noseBottom[ 0 ][ 1 ];
const length = Math.sqrt( upX ** 2 + upY ** 2 );
upX /= length;
upY /= length;
hat = {
scale: faceScale,
position: {
x: face.annotations.midwayBetweenEyes[ 0 ][ 0 ] + upX * 100 * faceScale,
y: face.annotations.midwayBetweenEyes[ 0 ][ 1 ] + upY * 100 * faceScale,
}
};
```
После сохранения названия спрогнозированной эмоции в `currentEmotion` отображается соответствующее изображение шляпы, и мы готовы её примерить!
```
if( points ) {
let emotion = await predictEmotion( points );
setText( `Detected: ${emotion}` );
currentEmotion = emotion;
}
else {
setText( "No Face" );
}
```
Вот полный код этого проекта
```
Building a Magical Emotion Detection Hat
Loading...
==========
function setText( text ) {
document.getElementById( "status" ).innerText = text;
}
function drawLine( ctx, x1, y1, x2, y2 ) {
ctx.beginPath();
ctx.moveTo( x1, y1 );
ctx.lineTo( x2, y2 );
ctx.stroke();
}
async function setupWebcam() {
return new Promise( ( resolve, reject ) => {
const webcamElement = document.getElementById( "webcam" );
const navigatorAny = navigator;
navigator.getUserMedia = navigator.getUserMedia ||
navigatorAny.webkitGetUserMedia || navigatorAny.mozGetUserMedia ||
navigatorAny.msGetUserMedia;
if( navigator.getUserMedia ) {
navigator.getUserMedia( { video: true },
stream => {
webcamElement.srcObject = stream;
webcamElement.addEventListener( "loadeddata", resolve, false );
},
error => reject());
}
else {
reject();
}
});
}
const emotions = [ "angry", "disgust", "fear", "happy", "neutral", "sad", "surprise" ];
let emotionModel = null;
let output = null;
let model = null;
let currentEmotion = "neutral";
let hat = { scale: { x: 0, y: 0 }, position: { x: 0, y: 0 } };
async function predictEmotion( points ) {
let result = tf.tidy( () => {
const xs = tf.stack( [ tf.tensor1d( points ) ] );
return emotionModel.predict( xs );
});
let prediction = await result.data();
result.dispose();
// Get the index of the maximum value
let id = prediction.indexOf( Math.max( ...prediction ) );
return emotions[ id ];
}
async function trackFace() {
const video = document.querySelector( "video" );
const faces = await model.estimateFaces( {
input: video,
returnTensors: false,
flipHorizontal: false,
});
output.drawImage(
video,
0, 0, video.width, video.height,
0, 0, video.width, video.height
);
let hatImage = document.getElementById( `hat-${currentEmotion}` );
output.save();
output.translate( -hatImage.width / 2, -hatImage.height / 2 );
output.translate( hat.position.x, hat.position.y );
output.drawImage(
hatImage,
0, 0, hatImage.width, hatImage.height,
0, 0, hatImage.width \* hat.scale, hatImage.height \* hat.scale
);
output.restore();
let points = null;
faces.forEach( face => {
const x1 = face.boundingBox.topLeft[ 0 ];
const y1 = face.boundingBox.topLeft[ 1 ];
const x2 = face.boundingBox.bottomRight[ 0 ];
const y2 = face.boundingBox.bottomRight[ 1 ];
const bWidth = x2 - x1;
const bHeight = y2 - y1;
// Add just the nose, cheeks, eyes, eyebrows & mouth
const features = [
"noseTip",
"leftCheek",
"rightCheek",
"leftEyeLower1", "leftEyeUpper1",
"rightEyeLower1", "rightEyeUpper1",
"leftEyebrowLower", //"leftEyebrowUpper",
"rightEyebrowLower", //"rightEyebrowUpper",
"lipsLowerInner", //"lipsLowerOuter",
"lipsUpperInner", //"lipsUpperOuter",
];
points = [];
features.forEach( feature => {
face.annotations[ feature ].forEach( x => {
points.push( ( x[ 0 ] - x1 ) / bWidth );
points.push( ( x[ 1 ] - y1 ) / bHeight );
});
});
const eyeDist = Math.sqrt(
( face.annotations.leftEyeUpper1[ 3 ][ 0 ] - face.annotations.rightEyeUpper1[ 3 ][ 0 ] ) \*\* 2 +
( face.annotations.leftEyeUpper1[ 3 ][ 1 ] - face.annotations.rightEyeUpper1[ 3 ][ 1 ] ) \*\* 2 +
( face.annotations.leftEyeUpper1[ 3 ][ 2 ] - face.annotations.rightEyeUpper1[ 3 ][ 2 ] ) \*\* 2
);
const faceScale = eyeDist / 80;
let upX = face.annotations.midwayBetweenEyes[ 0 ][ 0 ] - face.annotations.noseBottom[ 0 ][ 0 ];
let upY = face.annotations.midwayBetweenEyes[ 0 ][ 1 ] - face.annotations.noseBottom[ 0 ][ 1 ];
const length = Math.sqrt( upX \*\* 2 + upY \*\* 2 );
upX /= length;
upY /= length;
hat = {
scale: faceScale,
position: {
x: face.annotations.midwayBetweenEyes[ 0 ][ 0 ] + upX \* 100 \* faceScale,
y: face.annotations.midwayBetweenEyes[ 0 ][ 1 ] + upY \* 100 \* faceScale,
}
};
});
if( points ) {
let emotion = await predictEmotion( points );
setText( `Detected: ${emotion}` );
currentEmotion = emotion;
}
else {
setText( "No Face" );
}
requestAnimationFrame( trackFace );
}
(async () => {
await setupWebcam();
const video = document.getElementById( "webcam" );
video.play();
let videoWidth = video.videoWidth;
let videoHeight = video.videoHeight;
video.width = videoWidth;
video.height = videoHeight;
let canvas = document.getElementById( "output" );
canvas.width = video.width;
canvas.height = video.height;
output = canvas.getContext( "2d" );
output.translate( canvas.width, 0 );
output.scale( -1, 1 ); // Mirror cam
output.fillStyle = "#fdffb6";
output.strokeStyle = "#fdffb6";
output.lineWidth = 2;
// Load Face Landmarks Detection
model = await faceLandmarksDetection.load(
faceLandmarksDetection.SupportedPackages.mediapipeFacemesh
);
// Load Emotion Detection
emotionModel = await tf.loadLayersModel( 'web/model/facemo.json' );
setText( "Loaded!" );
trackFace();
})();
```
### Что дальше? Возможен ли контроль по состоянию глаз и рта?
В этом проекте собраны воедино все куски, созданные ранее в этой серии статей в целях развлечения с визуальными образами. А что, если бы можно было реализовать в нём взаимодействие с лицом?
В следующей, заключительной статье этой серии мы реализуем обнаружение моргания глаз и открывания рта, чтобы получить интерактивную сцену. Оставайтесь с нами и до встречи завтра, в это же время.
* [Отслеживание лиц в реальном времени в браузере. Часть 1](https://habr.com/ru/company/skillfactory/blog/544846/)
* [Отслеживание лиц в реальном времени в браузере. Часть 2](https://habr.com/ru/company/skillfactory/blog/544850/)
* [Отслеживание лиц в реальном времени в браузере. Часть 3](https://habr.com/ru/company/skillfactory/blog/545332/)
* [Отслеживание лиц в реальном времени в браузере. Часть 4](https://habr.com/ru/company/skillfactory/blog/545334/)
* [Отслеживание лиц в реальном времени в браузере. Часть 6](https://habr.com/ru/company/skillfactory/blog/545336/)
[Узнайте подробности](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=060321), как получить Level Up по навыкам и зарплате или востребованную профессию с нуля, пройдя онлайн-курсы SkillFactory со скидкой 40% и промокодом **HABR**, который даст еще +10% скидки на обучение.
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=060321)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=060321)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=060321)
Другие профессии и курсы**ПРОФЕССИИ**
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=060321)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=060321)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=060321)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=060321)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=060321)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=060321)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=060321)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=060321)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=060321)
**КУРСЫ**
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=060321)
* [Курс "Математика и Machine Learning для Data Science"](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MATML&utm_term=regular&utm_content=060321)
* [Курс "Machine Learning и Deep Learning"](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=060321)
* [Курс "Python для веб-разработки"](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=060321)
* [Курс "Алгоритмы и структуры данных"](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=060321)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=060321)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=060321) | https://habr.com/ru/post/545336/ | null | ru | null |
# Делаем сайт для виртуальной реальности. Встраиваем монитор в монитор и размышляем о будущем
Несмотря на то, что понятие «виртуальная реальность» уже не первый год мелькает перед глазами, оно до сих пор остается загадкой для большинства людей, а цены на аксессуары, связанные с этим развлечением, могут уходить в бесконечность. Но существует бюджетный вариант. Среднестатистический человек, интересующийся новыми технологиями, может позволить себе смартфон с гироскопом, встроенный в Google Cardboard или любой аналог этого нехитрого устройства и простой джойстик с парой кнопок. В наше время такой вариант знакомства с этой технологией наиболее распространенный. Но, как и многие другие технологичные новинки, вроде квадрокоптеров, интересная игрушка быстро превращается в пылящуюся на полке. Практическое применение сильно ограничено. Взрослые люди, купившие очки виртуальной реальности, первые дни играются в игрушки, смотрят различные видео ~~с прекрасными барышнями~~, радуются, как дети. Это здорово. Новые впечатления всегда полезны. Но быстро приходит понимание, что графика в игрушках находится на уровне конца 90-х, видео наскучивает, а другого практического применения очкам для этих людей нет. Для отдельных разработчиков, дизайнеров и экспериментаторов очки становятся инструментом в работе, но обычный потребитель кладет их на полку и забрасывает. Было бы интересно применить эту технологию в интернете на обычных сайтах. В этой статье мы попробуем с помощью Javascript адаптировать привычную нам верстку под новые условия отображения. Информации по теме пока не много, статья носит характер эксперимента, так что всем заинтересованным людям, а также тем, кто имел подобный практический опыт, заранее предлагается присоединиться к обсуждению и поделиться своими мыслями и опытом в комментариях.
Введение
--------
С течением времени в нашем мире появляются новые устройства ввода-вывода. Монитор, механическая клавиатура и мышка с шариком дополнились тачпадами, у мышки появилось колесико, у людей стали появляться устройства с плоскими экранами, в которые все тыкали старыми шариковыми ручками вместо стилуса, затем телефоны с touch-экранами стали чем-то повседневным и совершенно не примечательным. Мы перестали говорить «не тыкай пальцем в монитор» и стали задумываться об адаптации интерфейсов под новые реалии. Кнопки становятся больше, чтобы пальцем не промахиваться, интерактивные элементы поддерживают свайпы и другие движения разным количеством пальцев. С появлением очков виртуальной реальности (телефон с парой линз тоже будем считать таковым) нам стоит задуматься о том, как адаптировать то, что мы имеем в интернете на данный момент, к такому повороту событий. Да, пройдет еще несколько лет (а может несколько десятков лет) пока такие очки будут в каждом доме, но если мы не начнем что-то думать сейчас — мы просто еще сильнее отложим приход этого момента.
Что-то получаем, но и что-то теряем
-----------------------------------
VR очки дают нам возможность располагать информацию в трех измерениях (ну или по крайней мере создается такой эффект), в отличии от обычного монитора. У нас появляется возможность управлять происходящим с помощью поворота головы, что довольно интересно. Некоторые джойстики, если их можно так назвать, позволяют управлять тем, что мы видим, с помощью движения рук в пространстве. Но при этом мы теряем возможность использовать клавиатуру — только если вы действительно умеете печатать вслепую, вы сможете ее использовать. Причем для тех, кто много печатает, отсутствие привычного тактильного ощущения от нее и отсутствее стука клавиш может быть серьезным испытанием. Подобный эффект, хотя и не в такой степени, происходит при переходе со старой клавиатуры из начала 2000-х на новую, с малым ходом клавиш и почти бесшумную. Теряем и обычную мышку — крайне проблематично представить себе использование двухмерного контроллера в трехмерном пространстве.
Получается, что мы имеем совершенно новый набор устройств ввода-вывода с новым для нас поведением. У нас не просто эволюционирует одно из них, а заменяется весь стек. В такой ситуации неизбежны вопросы о том, насколько приспособлены все эти устройства для решения уже существующих задач.
Потребление контента. Все-таки плоскости?
-----------------------------------------
Поскольку мы начали говорить о применении технологии с точки зрения потребителя, а не разработчика, продолжим смотреть с этой же стороны. Потребление информации последние десятилетия не претерпевало значительных изменений. Контент может быть представлен в виде текста, в виде звука, графического изображения или видео. Механические кнопки заменяются виртуальными, перелистывание страниц заменяется кликанием по ссылкам, но сам контент сильно не меняется. Запахи и тактильные ощущения из фильмов или игр широкому кругу потребителей пока не доступны.
С аудио все более-менее понятно. Наушники или несколько колонок могут дать определенное ощущение объема, хотя два наушника не позволяют «перемещать» источник звука вперед или назад. Слушать музыку мы можем также, как и раньше, а большинство интерфейсов работают беззвучно, так что вопрос звука будет волновать нас в последнюю очередь. Плееры для видео в 3d уже есть в разных вариантах. Можно считат, что вопрос потребления видео «на весь экран» более-менее решен.
А вот с текстом все интереснее. Первым делом, оказавшись в виртуальном пространстве, возникает мысль об отходе от идеи плоского монитора и расположении текста на кривой поверхности. Шарик? А пользователь в центре. Почему бы и нет. Но лучше все же сохранить вертикальные оси на повержности, а то и вырвать может от такого интерфейса. Раньше мы не задумывались о таком? А теперь придется. На некоторых игрушках делают предупреждения для эпилептиков, а теперь видимо будут для людей с проблемами с вестибулярным аппаратом. Цилиндрическая поверхность кажется хорошим выбором. Одинаковое «расстояние» до текста во всех точках должно снизить нагрузку на глаза (по сравнению с огромным монитором), эффективное использование пространства…
Но реальность бьет очень больно. Из-за искажений читать такой текст очень сложно, причем это усугубляется плохим качеством дисплеев у большинства смартфонов — буквы по краям области видимости превращаются в мыльно-пиксельное нечто. А постоянно крутить головой на каждой строчке текста — не вариант. Похоже, что в ближайшем будущем мы будем ограничены плоскостями в 3d. Придется склониться к призме — три вертикальных монитора мы можем встроить в наше пространство и при этом более-менее сохраним читаемость текста. Причем желательно разместить их так, чтобы при повороте головы к «монитору» взгляд попадал ровно в его центр и линия взгляда была перпендикулярна плоскости монитора. Таким образом искажения будут минимальными. Если вы пробовали сидеть под углом к монитору, то поймете о чем я. Почему три? Можно было бы сделать еще пару мониторов за спиной, но если предполагать длительную работу, то нужно будет иметь здоровье космонавта, чтобы вращаться на стуле целый день. Некоторых людей и без очков от пары оборотов хватит весьма неприятный приступ головокружения и помутнение в глазах. Так что имеет смысл ограничить угол обзора. Возможно стоит произвести эксперименты с частью додекаэдра, а не с призмой, но мне пока сложно представить интерфейс, построенный на пятиугольниках.
А что со вводом?
----------------
Трехмерный контроллер — вещь интересная. Но… Вы когда-нибудь видели обычного художника, который рисует на мольберте? Формально он не занимается физическим трудом — кисточка весит несколько граммов (ну может пару десятков), но после полного дня рисования рука у него просто отваливается. Да и спина устает, что бы там не говорили. Вот у трехмерных контроллеров та же проблема. Ослабленные от многих лет лежания на столе и печатания на клавиатуре руки не могут весь день находиться в подвешенном состоянии. Так что для игр — здорово, для отдельных этапов 3d-моделирования — может быть, но для постоянной работы такой вид контроллера плохо приспособлен. Остается вариант, когда рука лежит и нажимает несколько кнопок. Но и это уже хорошо. На контроллерах кнопок обычно больше, чем на стандартной мышке (для пользователей топовых моделей от Razer напомню, что их там две + колесико).
С клавиатурой — беда. Можно сделать подобие экранной клавиатуры, но скорость печати на таком чуде будет ниже плинтуса. Возможно, со временем, у нас будут распространены полупрозрачные очки, чтобы на уровне глаз у нас было изображение, а снизу мы могли видеть реальную клавиатуру, но пока о бюджетном варианте речи не идет. Плюс — у тех устройств, которые есть на рынке, имеется проблема с утомляемостью глах — читать полупрозрачный текст в течении длительного времени можно только если на фоне что-то более-менее однотонное и неподвижное. Уведомление посмотреть можно, но читать на постоянной основе — нет. Голосовой ввод пока тоже далек от совершенства. Похоже, что в ближайшее время в виртуальной реальности вводить большие объемы текста не получится.
На данный момент вариант со смартфоном не позволит нам совместить очки и штуки вроде [WebGazer](https://webgazer.cs.brown.edu/) для того, чтобы использовать направление взгляда как заменитель мышки. Если будет интересно, я разберу отдельно идею построения интерфейса для веб приложения, которым можно будет управлять с помощью одного лишь взгляда (вполне вероятно, что у этого может быть практическое применение в медицине). Но в случае с очками у нас есть только поворот головы. Наиболее эффективным вариантом его использования в нашей ситуации кажется следующий: взять центр поля зрения, построить луч от пользователя и использовать его пересечение с плоскостями-мониторами для того, чтобы создавать подобие мышки на этих плоскостях.
Попробуем что-нибудь сделать.
-----------------------------
Раз уж мы делаем несколько плоскостей-мониторов, создадим какую-нибудь разметку для них
(ссылка на GitHub с полными исходниками будет в конце статьи). Это обычная разметка, я в полных исходниках использовал кнопочки и аккордеон из одного из своих проектов.
```
....
....
....
```
Вариантов использовать обычную разметку HTML + CSS в трехмерном пространстве не так уж и много. Но существуют пара рендереров для Three.js, которые сразу привлекают к себе внимание. Один из них, который называется CSS3DRenderer, позволяет взять нашу разметку и отрендерить ее на плоскости. Это вполне подходит под нашу задачу. Второй, CSS3DStereoRenderer, который мы и будем использовать, делает то же самое, но делит экран на две части, создает как бы два изображения, по одному для каждого глаза.
Инициализация Three.js уже не раз упоминалась в различных статьях, так что не будем сильно зацикливаться на ней.
```
var scene = null,
camera = null,
renderer = null,
controls = null;
init();
render();
animate();
function init() {
initScene();
initRenderer();
initCamera();
initControls();
initAreas();
initCursor();
initEvents();
}
function initScene() {
scene = new THREE.Scene();
}
function initRenderer() {
renderer = new THREE.CSS3DStereoRenderer();
renderer.setSize(window.innerWidth, window.innerHeight);
renderer.domElement.style.position = 'absolute';
renderer.domElement.style.top = 0;
renderer.domElement.style.background = '#343335';
document.body.appendChild(renderer.domElement);
}
function initCamera() {
camera = new THREE.PerspectiveCamera(45,
window.innerWidth/window.innerHeight, 1, 1000);
camera.position.z = 1000;
scene.add(camera);
}
```
Второй компонент, который мы сразу добавим, — это DeviceOrientationController, который позволит использовать поворот устройства для ориентации в 3d-пространстве. Технология определения положения устройства является экспериментальной, и, мягко говоря, на сегодняшний день работает так себе. Все три устройства, на которых она проверялась, вели себя по-разному. Это еще усугубляется тем, что помимо гироскопа (а, возможно, и вместо него) браузером используется компас, который в окружении различного железа и проводов ведет себя сильно неадекватно. Мы будем использовать именно этот контроллер еще и для того, чтобы сохранить возможность использования обычной мышки при оценке результатов эксперимента.
```
function initControls() {
controls = new DeviceOrientationController(camera, renderer.domElement);
controls.connect();
controls.addEventListener('userinteractionstart', function () {
renderer.domElement.style.cursor = 'move';
});
controls.addEventListener('userinteractionend', function () {
renderer.domElement.style.cursor = 'default';
});
}
```
CSS3DRenderer, как мы уже сказали, дает возможность использовать обычную разметку в нашем 3d примере. Создание CSS объектов при этом похоже на создание обычных плоскостей.
```
function initAreas() {
var width = window.innerWidth / 2;
initArea('.vr-area.-left', [-width/2 -width/5.64,0,width/5.64], [0,Math.PI/4,0]);
initArea('.vr-area.-center', [0,0,0], [0,0,0]);
initArea('.vr-area.-right', [width/2 + width/5.64,0,width/5.64], [0,-Math.PI/4,0]);
}
function initArea(contentSelector, position, rotation) {
var element = document.querySelector(contentSelector),
area = new THREE.CSS3DObject(element);
area.position.x = position[0];
area.position.y = position[1];
area.position.z = position[2];
area.rotation.x = rotation[0];
area.rotation.y = rotation[1];
area.rotation.z = rotation[2];
scene.add(area);
}
```
Далее опять идут стандартные для почти всех демок Three.js функции для анимации и изменения окна браузера.
```
function initEvents() {
window.addEventListener('resize', onWindowResize);
}
function onWindowResize() {
camera.aspect = window.innerWidth / window.innerHeight;
camera.updateProjectionMatrix();
renderer.setSize( window.innerWidth, window.innerHeight );
render();
}
function animate() {
controls.update();
render();
requestAnimationFrame(animate);
}
function render() {
renderer.render(scene, camera);
}
```
А вот дальше начинается интересное. CSS3DStereoRenderer по своей сути создает два идентичных дерева элементов, которые с помощью CSS-трансформаций выстраиваются в нужном месте. Иными словами, магии в этом рендерере нет. А то, что есть, создает проблему. Как можно взаимодействовать с интерактивными элементами, если они все продублировались? Мы не можем сфокусироваться на двух элементах одновременно, не можем сделать двойной :hover, вообщем маленькая засада. Вторая проблема — id элементов, которые могут быть только в единственном экземпляре на странице. Но если id можно и не использовать, то над взаимодействиями нужно плотно подумать.
Единственным способом, который позволит управлять внешним видом двух элементов одновременно — это добавление и удаление к ним каких-то CSS классов. Также мы можем имитировать click(). Кликать на несколько элементов мы можем, это не ведет к странному поведению браузера. Таким образом, мы можем сделать второй курсор в центре поля зрения (не всего экрана, а именно в центрах его половин, предназначенных для разных глаз). Для того, чтобы узнавать элемент, находящийся под курсором, мы можем использовать функцию document.elementFromPoint(x, y). В этот момент кажется очень полезным тот факт, что рендерер использует трансформации, но сами элементы остаются стандартными DOM-элементами. Нам не нужно придумывать геометрию с пересечением луча с плоскостью, на которой рендерится контент, поиском координат пересечения и определением элементов на плоскости по этим координатам. Все гораздо проще. Стандартная функция вполне справляется с этой задачей.
Правда возникает вопрос о том, к какому именно элементу добавлять и удалять классы. Я решил временно остановиться на простом переходе к родительским элементам до тех пор, пока не появится фокусируемый элемент. Вероятно есть более красивое решение, да и можно это вынести в отдельную функцию, но уж очень хотелось поскорее посмотреть, что же там получится.
```
function initCursor() {
var x1 = window.innerWidth * 0.25,
x2 = window.innerWidth * 0.75,
y = window.innerHeight * 0.50,
element1 = document.body,
element2 = document.body,
cursor = document.querySelector('.fake-cursor');
setInterval(function() {
if (element1 && element1.classList) {
element1.classList.remove('-focused');
}
if (element2 && element2.classList) {
element2.classList.remove('-focused');
}
element1 = document.elementFromPoint(x1, y);
element2 = document.elementFromPoint(x2, y);
if (element1 && element2) {
while (element1.tabIndex < 0 && element1.parentNode) {
element1 = element1.parentNode;
}
while (element2.tabIndex < 0 && element2.parentNode) {
element2 = element2.parentNode;
}
if (element1.tabIndex >= 0) {
element1.classList.add('-focused');
}
if (element2.tabIndex >= 0) {
element2.classList.add('-focused');
}
}
}, 100);
}
```
Также добавим на скорую руку простую имитацию клика по обоим элементам под нашим фейковым курсором. В случае с очками, тут должна быть обработка кнопки на контроллере, но не имея такового, остановимся на обычном enter на клавиатуре.
```
document.addEventListener('keydown', function(event) {
if (event.keyCode === 13) {
if (element1 && element2) {
element1.click();
element2.click();
cursor.classList.add('-active');
setTimeout(function() {
cursor.classList.remove('-active');
}, 100);
}
}
});
```
Что же там получилось?
----------------------
Поскольку значительная часть того, что использовалось в статье, является экспериментальным, пока сложно утверждать о кроссбраузерности. В Chrome под линуксом с обычной мышкой все работает, в Chrome под андроидом — на одном устройстве все немного поворачивается в зависимости от положения в помещении (полагаю из-за компаса, на который влияют окружающие наводки), на другом — все разлетается в щи. По этой причине записал небольшое видео с экрана, на котором виден результат с десктопного браузера:
Мысли вместо заключения.
------------------------
Эксперимент интересный. Да, до реального применения еще очень далеко. Браузеры пока еще очень плохо поддерживают определение положения устройства в пространстве, возможности для калибрации компаса можно сказать отсутствуют (формально есть событие compassneedscalibration, но на практике толку от него не очень много). Но в целом идея создания интерфейса в трехмерном пространстве вполне реализуема. По крайней мере на десктопе мы уже точно можем такое применять. Если заменить стерео-рендерер на обычный, а камеру поворачивать просто по движению мыши, то получим что-то похожее на обычную трехмерную игрушку, только с возможностью использовать ~~bootstrap~~ все любимые инструменты верстальщика.
Полные исходники примера доступны [на GitHub](https://github.com/sfi0zy/habraexample-ui-in-vr/blob/master/index.html) | https://habr.com/ru/post/333400/ | null | ru | null |
# Как обойтись без WDS сервера, при установке Windows из WIM-образов по сети
Введение
========
Образы в [WIM](https://msdn.microsoft.com/en-us/library/windows/desktop/dd861280.aspx) формате, подготовленные в системе [MDT](https://msdn.microsoft.com/en-us/library/dn781292.aspx), компания Microsoft предлагает развертывать по сети с помощью [WDS-сервера](https://msdn.microsoft.com/en-us/library/aa967394.aspx), либо [интегрировать в SCCM](https://technet.microsoft.com/en-us/library/dn744295.aspx).
SCCM стоит довольно дорого, а вот WDS-сервер бесплатен в случае, если вы являетесь счастливым обладателем лицензии на Windows Server 2008/2012. Но не всех устраивают возможности WDS-сервера.
Предлагаемый мной способ будет полезен тем:
* у кого нет лицензии на Windows Server, или все ресурсы на имеющихся серверах уже задействованы и нет возможности приобрести еще одну лицензию;
* кого не устраивает скорость загрузки Windows PE по протоколу [TFTP](https://tools.ietf.org/html/rfc1350), используемому WDS-сервером;
* кому необходимо совместить развертывание ОС Windows и Linux по сети на одном сервере.
Хочу предложить читателям решение на базе ОС Ubuntu Linux, с использованием syslinux и iPXE.
В дальнейшем будет подразумеваться использование ОС Ubuntu 14.04 LTS.
Упомянутые ниже службы не обязательно должны работать на одном и том же сервере.
Установка и настройка tftp-сервера
==================================
Для организации передачи данных по TFTP-протоколу будет использован сервер [tftpd-hpa](http://manpages.ubuntu.com/manpages/natty/man8/tftpd.8.html). Он обладает необходимыми возможностями, а также поддерживает remapping.
Установим соответсвующий пакет:
```
aptitude install tftpd-hpa
```
Настройки находятся в конфигурационном файле **/etc/default/tftpd-hpa**
```
RUN_DAEMON="yes"
TFTP_USERNAME="tftp"
TFTP_DIRECTORY="/var/lib/tftpboot"
TFTP_ADDRESS="0.0.0.0:69"
TFTP_OPTIONS="--secure --listen --verbose --verbosity 10 --map-file /etc/tftpd.remap --refuse blksize"
```
Также нам потребуется файл с правилами для remapping **/etc/tftpd.remap**
```
rg \\ /
ri (.*)ÿ$ \1
ri (.*)M-\^\?$ \1
ri (pxelinux\.0).*$ \1
```
Первая строка переопределяет слэши для ОС Windows, последующие предупреждают возможные проблемы с загрузкой на некоторых сетевых адаптерах, когда клиент пытается запросить у tftp-сервера файл «pxelinux.0M-^» или «pxelinux.0ÿ» вместо «pxelinux.0».
Настройка http-сервера
======================
Для чего вообще нам нужен http-сервер, ведь для загрузки WIM-образов по сети достаточно tftp-сервера?
Так получилось, что Trivial FTP хоть и обеспечивает базовые функции для передачи файлов по сети, но не может обеспечить высокую надежность и скорость передачи данных.
Как показывает практика, образы с Windows PE размером около 250МБ, скачиваются по сети 1Гбит с использованием http-протокола в несколько раз быстрее (5-10 секунд, против 30-60 секунд соответственно).
Также по протоколу http можно загружать preseed-файлы для установщика debian-installer.
В качестве http-сервера можно использовать apache, nginx или любой другой сервер который вам нравится. Каких-либо особенных настроек не требуется. Главное, чтоб перечисленные ниже файлы \*.ipxe, \*.wim и другие файлы, размещенные на http-сервере, были доступны для чтения.
Настройка dhcp-сервера
======================
Согласно [RFC1232](http://www.faqs.org/rfcs/rfc2132.html) необходимо настроить опцию 66 TFTP server name, где указать IP-адрес вашего tftp-сервера, например 192.168.1.1; и опцию 67 Bootfile name, где указать имя файла для загрузки «pxelinux.0»;
Если вы используете, например isc-dhcp-server под управлением Ubuntu, то нужно будет добавить примерно такие настройки в файл **/etc/dhcp/dhcpd.conf**
```
shared-network PXE-Netwotk {
subnet 192.168.1.0 netmask 255.255.255.0 {
# Общие настройки для подсети
range 192.168.1.2 192.168.1.254;
option routers 192.168.1.1;
option subnet-mask 255.255.255.0;
option domain-name-servers 192.168.1.1;
# Настройки опций для сетевой загрузки в подсети
filename "pxelinux.0";
next-server 192.168.1.1;
option root-path "192.168.1.1:/var/lib/tftpboot/"; # необязательный параметр
}
}
```
Установка и настройка загрузчика syslinux
=========================================
Установка загрузчика
--------------------
Нам потребуется [syslinux](http://www.syslinux.org/wiki/index.php/SYSLINUX) версии 5.03 или выше.**Я бы рекомендовал собрать загрузчик из исходных кодов, ничего страшного и сложного в этом нет**Для сборки из исходников нужно установить make, gcc, nasm, uuid-dev, и выполнить команды:
```
# Скачаем архив с исходными кодами
wget https://www.kernel.org/pub/linux/utils/boot/syslinux/syslinux-6.03.zip
# распакуем его
unzip syslinux-6.03.zip -d syslinux-6.03
# Собственно сама сборка с помощью make
cd syslinux-6.03
make
# Скопируем полученные файлы в каталог tftp-сервера:
cd ..
cp syslinux-6.03/bios/memdisk/memdisk /var/lib/tftpboot/
find ./syslinux-6.03/bios/ -name "pxelinux.0"|xargs -I {} cp '{}' /var/lib/tftpboot/
find ./syslinux-6.03/bios/ -name "*.c32"|xargs -I {} cp '{}' /var/lib/tftpboot/
```
Настройка меню загрузчика
-------------------------
Создадим каталог для файлов меню syslinux:
```
mkdir -p /var/lib/tftpboot/pxelinux.cfg/
```
И создадим файл с меню по умолчанию**/var/lib/tftpboot/pxelinux.cfg/default**
```
ui vesamenu.c32
PROMPT 0
menu background background.jpg
menu title PXE boot menu
# По умолчанию загружаемся с первого жесткого диска
LABEL bootlocal
menu label Boot from first HDD
kernel chain.c32
append hd0 0
# Таймаут для автоматической загрузки 12 секунд
timeout 120
TEXT HELP
The system will boot after the time is up
ENDTEXT
# Подменю для центрального офиса
LABEL Central Office ->
KERNEL vesamenu.c32
APPEND pxelinux.cfg/CentralOffice
# Подменю для региональных офисов
LABEL Regional Offices ->
# menu PASSWD $1$15opgKTx$dP/IaLNiCbfECiC2KPkDC0 # раскомментировать если требуется вход в подменю по паролю, пароль Qwerty, алгоритм MD5
KERNEL vesamenu.c32
APPEND pxelinux.cfg/RegionalOffices
```
А теперь создадим подменю непосредственно для загрузки ОС:
**/var/lib/tftpboot/pxelinux.cfg/CentralOffice**
```
PROMPT 0
UI vesamenu.c32
MENU BACKGROUND background.jpg
MENU TITLE Central Office
# Возврат в главное меню
LABEL <- Main Menu
KERNEL vesamenu.c32
APPEND pxelinux.cfg/default
# Загрузка через http
LABEL PE via http
KERNEL ipxe.lkrn
APPEND dhcp && chain http://192.168.2.1/winpe.ipxe
# Для сравнения загрузка через tftp
LABEL PE via tftp
KERNEL ipxe.lkrn
APPEND dhcp && chain tftp://192.168.2.1/winpe.ipxe
# Можно также загрузить debian-installer
LABEL Ubuntu
KERNEL ubuntu-installer/i386/linux
APPEND initrd=ubuntu-installer/i386/initrd.gz preseed/url=http://192.168.1.1/preseed/custom.seed debconf/priority=high auto-install/enable=true debian-installer/language=ru debian-installer/locale=ru_RU.UTF-8 debian-installer/country=RU ipv6.disable=1 netcfg/hostname=testname DEBCONF_DEBUG=5 --
```
, где winpe.ipxe — конфигурационный файл с настройками для ipxe, который мы разберем ниже, в соответствующем разделе.
Не стоит забывать, что tftp-сервер не умеет работать с символическими ссылками, поэтому нужно будет сделать отдельную копию файла winpe.ipxe в каталоге tftp-сервера, если захочется сравнить скорость загрузки по http и tftp.
Некоторые сетевые карты не успевают поднять link с первого раза, поэтому можно сделать вторую попытку загрузки в случае неудачи, с использованием оператора "||". Если после второй попытки нас снова постигнет неудача, то можно вывести статистику интерфейса и открыть командную строку для диагностики проблемы:
```
APPEND dhcp && chain http://192.168.2.1/winpe.ipxe || dhcp && chain http://192.168.2.1/winpe.ipxe || ifstat && shell
```
iPXE
====
Установка iPXE
--------------
[iPXE](http://ipxe.org/) я тоже предлагаю собирать из исходных кодов, к тому же это тоже очень просто:
```
git clone git://git.ipxe.org/ipxe.git
cd ipxe/src
make
cp bin/ipxe.lkrn /var/lib/tftpboot
```
Если какая-либо сетевая карта отказывается поднимать link с любой попытки, то скорее всего проблема в драйвере iPXE.
Особенно эта проблема касается новых сетевых карт от Intel. У меня возникли проблемы с картами i218lm и с i218v-2, при принудительно выставленной скорости 1Гбит на свиче.
Перед сборкой нужно поправить ipxe/src/drivers/net/intel.c: для i218lm и i218v-2 выставить флаг INTEL\_NO\_PHY\_RST:
```
PCI_ROM ( 0x8086, 0x155a, "i218lm", "I218-LM", INTEL_NO_PHY_RST),
PCI_ROM ( 0x8086, 0x15a1, "i218v-2", "I218-V", INTEL_NO_PHY_RST ),
```
Установка wimboot
-----------------
Для загрузки WIM-образов через iPXE потребуется утилита [wimboot](http://ipxe.org/wimboot).
Установка этой утилиты также очень проста:
```
wget http://git.ipxe.org/releases/wimboot/wimboot-latest.zip
unzip wimboot-latest.zip
cp wimboot-2.5.1-signed/wimboot /var/lib/tftpboot/
```
Создание конфигурационных файлов .ipxe
--------------------------------------
Конфигурационные файлы .ipxe (расширение может быть любым, но так удобнее) содержат инструкции для ядра ipxe: что именно загружать дальше.
Мы будем загружать утилиту wimboot, и передадим ей в параметрах пути к файлу данных конфигурации загрузки BCD, файлу конфигурации RAM-диска boot.sdi и к образу boot.wim. Структуру каталогов сохранять не обязательно, wimboot сама позаботиться об этом. Все файлы можно сложить в один каталог.
**winpe.ipxe**
```
#!ipxe
kernel http://192.168.1.1/boot/wimboot
initrd http://192.168.1.1/boot/DeploymentShare/Boot/x86/Boot/bcd BCD
initrd http://192.168.1.1/boot/DeploymentShare/Boot/x86/Boot/boot.sdi boot.sdi
initrd http://192.168.1.1/boot/DeploymentShare/Boot/LiteTouchPE_x86.wim boot.wim
boot
```
В данном примере на http-сервере сделана символическая ссылка для 192.168.1.1/boot/DeploymentShare прямо на корень MDT DeploymentShare. Этот способ не подходит в качестве основного рабочего варианта. Т.к. если Вы вдруг соберете «кривой» wim-образ, то сразу же испортите загрузку по сети для тех, кто с этим работает. Но этот способ хорошо подходит для тестирования новых wim-образов.
Желающие могут заменить в .ipxe файле протокол http на tftp — тоже будет работать, но медленно.
Все. Теперь можно загружаться и ставить ОС.
**Источники информации*** [msdn.microsoft.com/en-us/library/dn781292.aspx](https://msdn.microsoft.com/en-us/library/dn781292.aspx)
* [msdn.microsoft.com/en-us/library/windows/desktop/dd861280.aspx](https://msdn.microsoft.com/en-us/library/windows/desktop/dd861280.aspx)
* [msdn.microsoft.com/en-us/library/aa967394.aspx](https://msdn.microsoft.com/en-us/library/aa967394.aspx)
* [technet.microsoft.com/en-us/library/dn744295.aspx](https://technet.microsoft.com/en-us/library/dn744295.aspx)
* [tools.ietf.org/html/rfc1350](https://tools.ietf.org/html/rfc1350)
* [manpages.ubuntu.com/manpages/natty/man8/tftpd.8.html](http://manpages.ubuntu.com/manpages/natty/man8/tftpd.8.html)
* [www.faqs.org/rfcs/rfc2132.html](http://www.faqs.org/rfcs/rfc2132.html)
* [www.syslinux.org/wiki/index.php/SYSLINUX](http://www.syslinux.org/wiki/index.php/SYSLINUX)
* [ipxe.org](http://ipxe.org/) | https://habr.com/ru/post/268827/ | null | ru | null |
# ControlValueAccessor и contenteditable в Angular
Вы когда-нибудь задумывались, как работает связка форм Angular и HTML элементов, через которые пользователь заносит данные?
С самого начала для этого использовали `ControlValueAccessor` — специальный интерфейс, состоящий всего из 4 методов:
```
interface ControlValueAccessor {
writeValue(value: any): void
registerOnChange(fn: (value: any) => void): void
registerOnTouched(fn: () => void): void
setDisabledState(isDisabled: boolean)?: void
}
```
Из коробки, Angular имеет несколько таких аксессоров: для чекбоксов и радиокнопок, для инпутов и селектов. Однако, если вы разрабатываете чат, в котором вам нужно дать возможность писать курсивом, делать текст жирным или, допустим, вставлять смайлики — вы, скорее всего, воспользуетесь атрибутом `contenteditable` для создания содержимого с форматированием.
В Angular нет поддержки использования форм вместе с `contenteditable`, поэтому написать её придётся самим.
ControlValueAccessor
====================
Директива, которую мы напишем, будет работать аналогично встроенным аксессорам — она будет реагировать на атрибут `contenteditable`. Чтобы шаблонные и реактивные формы получили её через внедрение зависимостей, достаточно предоставить встроенный `InjectionToken`:
```
@Directive({
selector:
'[contenteditable][formControlName],' +
'[contenteditable][formControl],' +
'[contenteditable][ngModel]',
providers: [
{
provide: NG_VALUE_ACCESSOR,
useExisting: forwardRef(() => ContenteditableValueAccessor),
multi: true,
},
],
})
export class ContenteditableValueAccessor implements ControlValueAccessor {
// ...
}
```
Интерфейс `ControlValueAccessor` требует реализовать 3 метода и имеет 1 опциональный метод:
* `registerOnChange` — в этот метод при инициализации придёт функция. Её вызывают с новым значением, когда пользователь что-то ввёл в наш компонент, для того, чтобы новые данные были занесены в контрол.
* `registerOnTouched` — в этот метод при инициализации придёт функция. Её надо вызвать, когда пользователь покинул наш компонент для того, чтобы контрол приобрёл статус `touched`. Это используется для валидации.
* `writeValue` — этот метод будет вызываться контролом для передачи значения в наш компонент. Его используют если значение поменяется через код снаружи (`setValue` или изменение переменной, на которую завязан `ngModel`), а так же для задания начального значения.
> Тут стоит отметить, что, в отличие от реактивных форм, `ngModel` ведёт себя кривовато — в частности, начальное значение в ней инициализируется с задержкой, а метод `writeValue` «дёргается» дважды, первый раз с `null`:
>
> <https://github.com/angular/angular/issues/14988>
>
>
* `setDisabledState` *(опционально)* — этот метод будет вызываться контролом при изменении состояния `disabled`. Хоть метод и опциональный, на это лучше реагировать в вашем компоненте.
Реализация интерфейса
=====================
Для работы с DOM элементом нам потребуется `Renderer2` и, собственно, сам элемент, поэтому добавим их в конструктор:
```
constructor(
@Inject(ElementRef) private readonly elementRef: ElementRef,
@Inject(Renderer2) private readonly renderer: Renderer2,
) {}
```
Сохраним методы, которые нам передаст контрол в приватные поля класса:
```
private onTouched = () => {};
private onChange: (value: string) => void = () => {};
registerOnChange(onChange: (value: string) => void) {
this.onChange = onChange;
}
registerOnTouched(onTouched: () => void) {
this.onTouched = onTouched;
}
```
`disabled` состояние для `contenteditable` компонента равносильно отключению режима редактирования — `contenteditable="false"`. Задание значения снаружи эквивалентно подмене `innerHTML` DOM элемента, а обновление значения пользователем и уход из компонента можно отслеживать, подписавшись на соответствующие события:
```
@HostListener('input')
onInput() {
this.onChange(this.elementRef.nativeElement.innerHTML);
}
@HostListener('blur')
onBlur() {
this.onTouched();
}
setDisabledState(disabled: boolean) {
this.renderer.setAttribute(
this.elementRef.nativeElement,
'contenteditable',
String(!disabled),
);
}
writeValue(value: string) {
this.renderer.setProperty(
this.elementRef.nativeElement,
'innerHTML',
value,
);
}
```
Вот, собственно, и всё. Этого достаточно для базовой реализации работы форм Angular и `contenteditable` элементов.
Internet Explorer
=================
Однако, есть пара но.
Во-первых, пустое начальное значение формы — `null`, и после выполнения `writeValue` в IE11 мы так и увидим в шаблоне `null`. Чтобы правильно реализовать работу, нам нужно нормализовать значение:
```
writeValue(value: string | null) {
this.renderer.setProperty(
this.elementRef.nativeElement,
'innerHTML',
ContenteditableValueAccessor.processValue(value),
);
}
private static processValue(value: string | null): string {
const processed = value || '';
return processed.trim() === '
' ? '' : processed;
}
``` | https://habr.com/ru/post/443714/ | null | ru | null |
# Dummy Origin: тестируем работу CDN
Перед тем как принять решение о работе с той или иной CDN хотелось бы убедиться, что она будет делать именно то, что мы от нее ожидаем. Конечно, вы прочитали документацию, и все подробно обсудили с консультантами, но ведь этого мало? И если вы подходите к делу так же въедливо, как и мы, этого недостаточно. Вы бы хотели протестировать CDN, получить объективные характеристики ее работы, сравнить их со своими требованиями и т. п.
Dummy Origin – это тот инструмент, который позволяет сделать все это наилучшим образом, а главное – легко.
Dummy Origin – специализированный сервер, написанный на языке Go. Он был разработан специально для тестирования CDN, работающих в режиме pull. Он легкий, быстрый, его легко установить, и самое главное – он с открытым кодом, т. е. бесплатный!
Зачем же использовать Dummy Origin, а не протестировать CDN прямо с использованием вашего рабочего сервера? Потому что так проще проверить различные режимы работы прокси.
* Вам не надо ничего менять в конфигурации, настройках сервера и сайтов.
* Можно свободно менять заголовки в ответах и анализировать, как CDN на это реагирует.
* Очень легко протестировать разные критические сценарии типа «мой сервер выдает 502 ошибку, поддерживает ли CDN раздачу устаревших копий страниц во время оффлайна основного сайта?
Возможности Dummy Origin
------------------------
Основное: Dummy Origin осуществляет инъекцию произвольных заголовков в запрос. Делается это при помощи строки параметров URL, которая потом вставляются как заголовок запроса. Например, посылаете в URL `?ETag="41a0544696e19971383984fdaaeb5aed"`, Dummy Origin выдаст `ETag:"41a0544696e19971383984fdaaeb5aed"` в заголовке запроса.
Этот механизм позволяет тестировать поведение CDN без изменения конфигурации сервера и его перезагрузки, что потребовалось бы для изменения заголовков.
Другие возможности Dummy Origin:
| Возможность | Описание | Преимущества |
| --- | --- | --- |
| Gzip | Сжимает ответ с помощью стандартной Gzip компрессии. Основывается на расширениях файлов, а не на Content-Type. В настоящее время поддерживает .html, .css .js и .json расширения, но остальные можно легко добавить | Тестирует работу CDN со сжатыми файлами |
| Условные запросы | Обычно сервер выдает `Last-Modified` заголовок вместе с ответом 200 и выдает 304 или 200 если получает `If-Modified-Since` запрос | Позволяет проверить, отправляет ли CDN запросы с условием после истечения срока годности файла в кэше |
| Запросы диапазонов | Отправляет запрошенный диапазон байтов в 206 частичном ответе и соответствующий заголовок `Content-Length` | Важно для пересылки больших объемов данных через CDN, например, видеофайлов |
| 404 и 301 | Отдает ошибку 404, если ресурс не существует, делает 301-редирект, если запрошен /index.html | Кэширует ли CDN 404 ответы? Передает ли CDN 301 дальше или же она обрабатывает редирект сама? |
| Специальный генератор ошибок | Когда сервер получает запрос в виде GET /err/`, он возвращает http статус `. Величина `должна быть в диапазоне от 400 до 599``` | Позволяет тестировать поведение CDN в случае выдачи сервером различных ошибок. В частности, можно проверить, кэширует ли CDN ответ 404. |
| X-Tb-Time | Сервер всегда выдает текущее время в заголовке X-Tb-Time | Помогает определить, обслуживает ли CDN запрос данными из кэша или от сервера и как долго содержимое находится уже в кэше |
| Поддержка Loggly | Детали запроса и ответа обрабатываются через Loggly, если определена переменная окружения LOGGLY\_TOKEN | Loggly — облачный сервис обработки логов, очень удобный для разбора логов запросов CDN к серверу |
В Dummy Origin на сегодняшний день нет:
* HTTPS
* Brotli (алгоритм сжатия, применяемый в частности в браузере Chrome)
* Не может выдавать различное содержимое/заголовки на основе запросов с заголовками User-Agent или Accept-Language.
Установка и конфигурирование
----------------------------
[Установка сервера описана в README.md на GitHub](https://github.com/turbobytes/dummyorigin/blob/master/README.md)
Разместите несколько файлов на сервере. Они должны быть аналогичны тем файлам, которые будут представлять ваш реальный контент. Несколько изображений разного размера, текстовые файлы – скрипты или просто текст. Какое-то видео.
> Не размещайте на сервере index.html, чтобы видеть, какие файлы в нем находятся просматривая исходный домен в браузере.
Сконфигурируйте CDN. Установите на CDN опцию различать адреса с различными строками запроса как уникальные (т. е. различать `file.jpg?123` и `file.jpg?456`, в Айри.рф это опция «Кэшировать со строкой запроса»). Обычно этот режим установлен на CDN по умолчанию, но все-таки проверьте. Также убедитесь, что CDN пересылает все заголовки от исходного сервера клиенту, включая заголовок X-Tb-Time.
Сконфигурируйте DNS. Установите также низкое значение TTL на сервере порядка 300 секунд, это пригодится позже при тестировании реакции CDN на отсутствие ответа от сервера.
Тестирование поведения CDN: примеры
-----------------------------------
Здесь адрес dummy.mydomain.com используется как адрес CDN и dummy.origin.com – адрес исходного сервера. Протестируем, используя cURL. Запустим cURL со следующими опциями: curl -vo /dev/null и будем отправлять запрос GET, и в ответ видеть только заголовки, отправляя основное тело страницы на /dev/null.
Не используйте –I флаг для отправки запроса HEAD. CDN может обрабатывать запросы HEAD совершенно иначе, чем GET. Кроме того, ваши пользователи вряд ли будут слать на сервер HEAD, их запросы будут преимущественно GET.
Не кэшировать и получать все данные из исходного сервера
--------------------------------------------------------
Это не самый типичный пример использования CDN, но если вам надо какую-то часть контента оставить не кэшированной, то необходимо убедиться, что здесь все работает как нужно. Вопрос тут в том, какую директиву Cache-Control правильнее будет использовать. Основываясь на RFC 7234 кажется логичным использовать Cache-Control:no-store. RFC пишет:
> Директива no-store указывает, что данные не должны сохраняться в кэше как для запроса, так и для ответа. Касается как публичного кэша, так и локального.
Давайте попробуем:
```
curl -vo /dev/null 'http://dummy.mydomain.com/15kb.jpg?Cache-Control=no-store'
```
Ниже вы видите заголовки ответа для наших тестов CDN Fastly. Удивительно, но Fastly не уважает no-store и кэширует данные после того, как не обнаруживает их во время первого запроса в своем кэше.
```
HTTP/1.1 200 OK
Access-Control-Allow-Origin: *
Cache-Control: no-store
Content-Type: image/jpeg
Last-Modified: Tue, 21 Mar 2017 10:13:25 GMT
X-Tb-Time: 2017-03-30 14:39:11.358951299 +0000 UTC
Content-Length: 15887
Accept-Ranges: bytes
Date: Thu, 30 Mar 2017 14:39:23 GMT
Via: 1.1 varnish
Age: 12
X-Served-By: cache-ams4136-AMS
X-Cache: HIT
X-Cache-Hits: 1
X-Timer: S1490884763.605627,VS0,VE0
Vary: Accept-Encoding
```
Может быть, сработает no-cache или max-age=0? Нам надо, чтобы CDN не кэшировала ответы и не слала условные запросы исходному серверу.
Тестирование показало, что no-cache так же не работает – CDN продолжает кэшировать ответы, а вот max-age=0 сработало.
Кэшировать на 300 секунд, затем сверить с оригиналом
----------------------------------------------------
Дать CDN задание кэшировать файл на 300 секунд довольно просто: Cache-Control=max-age=300. Вопрос тут вот в чем: когда время жизни файла в кэше истечет, какой тип запроса будет посылать CDN серверу – условный или безусловный? Кто-то может сказать, что условный запрос тут будет оптимальным, поскольку если файл не устарел, сервер скажет 304 – «нет, файл не устарел, можно брать его из кэша», и CDN быстренько выдаст клиенту имеющуюся у нее копию. Это быстрее, чем если бы сервер начал пересылку всего файла сам.
RFC 7234 не утверждает, что CDN должна слать условный запрос для проверки актуальности кэша. Потому не будет ничего удивительного, если CDN пошлет в этой ситуации безусловный запрос (что не очень хорошо для производительности).
```
curl -vo /dev/null 'http://dummy.mydomain.com/15kb.jpg?Cache-Control=max-age=300'
```
Fastly и CDNetworks шлют условные запросы. Айри.рф и StackPath шлет серверу безусловные запросы, обновляя кэш новой версией файла. Это видно из логов исходного сервера и из значения X-Tb-Time поля в заголовке ответа CDN клиенту. Тестировалось также Cache-Control=max-age=300,must-revalidate, но безуспешно.
```
HTTP/1.1 200 OK
Date: Fri, 31 Mar 2017 11:20:16 GMT
Content-Type: image/jpeg
Content-Length: 33956
Access-Control-Allow-Origin: *
Cache-Control: max-age=20,must-revalidate
Last-Modified: Fri, 31 Mar 2017 09:49:42 GMT
X-Tb-Time: 2017-03-31 11:20:16.091275242 +0000 UTC
Server: NetDNA-cache/2.2
Accept-Ranges: bytes
X-Cache: EXPIRED
Connection: keep-alive
```
Кэшировать на 5 минут, разрешить выдавать просроченную версию еще 15 минут
--------------------------------------------------------------------------
```
curl -vo /dev/null 'http://dummy.mydomain.com/15kb.jpg?Cache-Control=max-age=300&stale-while-revalidate=900&stale-if-error=900'
```
Здесь важно протестировать три ситуации:
### 1. Исходный сервер не найден DNS (NXDOMAIN)
Еще долгое время после того, как DNS TTL истек в кэше для нашего сервера, CDN все еще выдавала сохраненный у нее контент. Это хорошо.
Что более интересно, CDN при этом продолжала обращаться к исходному серверу за свежими версиями контента. Такое ощущение, что вместе с контентом она хранит и IP-адреса, с которых он получен, и таким образом была «прикрыта» ошибка DNS, которая привела к невозможности вычисления IP. Или может быть Fastly поддерживает долгоживущий коннект с сервером? Тут надо смотреть глубже.
### 2. Исходный сервер выдает ответ 400
Что-то на сервере пошло не так, и он начал выдавать ошибку 400 Bad request. Ожидалось, что CDN будет обрабатывать в таком случае stale-if-error, но она просто транслировала ответ 400 клиенту. Как выяснилось, ожидания оказались неверными, так как в RFC 5861 «HTTP Cache-Control расширения для устаревшего контента» указано:
> Ошибка, это ситуация, в которой возвращен 500, 502, 503 или 504 HTTP ответ.
А 400 не является ошибкой, по умолчанию.
### 3. Сервер сбрасывает весь входящий трафик
В третьем сценарии была заменена DNS-записи сервера, привязав домен к адресу 72.66.115.13. Этот адрес связан с blackhole.webpagetest.org. Это специальный адрес для тестирования ситуаций, когда сервер не отвечает ни на какой запрос.
Стал ли CDN выдавать хранящийся у нее контент? Нет, она стала выдавать ответ 503 после примерно 1 секунды ожидания, и этот 503 ответ содержал заголовок Retry-After: 0. Айри.рф в описываемой ситуации отвечает с заголовков Retry-After: 500 и имеет настраиваемые времена ожидания соединения и ответа от хостинга сайта.
Это то, что заложено в настройках по умолчанию для прокси. В документации написано: «Если Varnish не может связаться с исходным сервером по любой причине – в любом случае генерируется ответ 503». Это свойство унаследовано от Varnish-кода, на основе которого создано большинство CDN прокси.
StackPath в подобной ситуации может выдавать архивный контент, но эта ситуация должна быть сконфигурирована пользователем для ошибок 404, 502, 503 и т. д. Тем не менее, StackPath не обрабатывает ситуацию NXDOMAIN или blackhole.
Итак, пользуйтесь Dummy Origin, чтобы убедиться, что ваш CDN-провайдер работает правильно. Это бесплатный инструмент с открытым исходным кодом. | https://habr.com/ru/post/328772/ | null | ru | null |
# Node.JS — формируем результирующий документ, используя другие HTTP-источники
Часто сервера на [Node.JS](http://nodejs.org/) используются как сервисы-агрегаторы, получающие динамические данные с других HTTP-источников и формирующие на основе этих данных агрегированный ответ.
Для обработки полученных данных удобно использовать внешние процессы, обрабатывающие исходный набор файлов (например, утилиты ImageMagick или ffmpeg).
Рассмотрим это на примере HTTP-сервера, выполняющего роль backend для сервера nginx, и формирующего CSS-спрайты для набора изображений.
#### Асинхронные чтение/запись
##### Пул клиентских соединений
Объекты «HTTP-клиент» в Node.JS работают каждый с одним TCP-соединением, выполняя запросы по очереди, поэтому нам нужно организовать пул клиентов (компромисс между созданием соединений на каждый чих и использованием одного соединения), если мы хотим работать действительно быстро (параллельно).
Самый примитивный пул мы сделаем из предположения, что все исходные запросы мы посылаем на адрес [example.com](http://example.com):80.
> `var ClientPool = function()
>
> {
>
> this.poolSize = 0;
>
> this.freeClients = [];
>
> };
>
>
>
> ClientPool.prototype.needClient = function()
>
> {
>
> this.freeClients.push(this.newClient());
>
> this.poolSize++;
>
> };
>
>
>
> ClientPool.prototype.newClient = function()
>
> {
>
> return http.createClient(80, 'example.com');
>
> };
>
>
>
> ClientPool.prototype.request = function(method, url, headers)
>
> {
>
> if (this.freeClients.length == 0)
>
> {
>
> this.needClient();
>
> }
>
> var client = this.freeClients.pop();
>
> var req = client.request(method, url, headers);
>
> return req;
>
> };
>
>
>
> ClientPool.prototype.returnToPool = function(client)
>
> {
>
> this.freeClients.push(client);
>
> };
>
>
>
> var clientPool = new ClientPool();
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
При желании можно изменить архитектуру пула, разрешив соединения к нескольким хостам, а также ограничив сверху размер пула (при этом раскидывая запросы по наименее загруженным соединениям). Оставлю это в качестве домашнего задания.
##### Получение и сохранение файла
Нам нужна асинхронная функция для выполнения HTTP-запросов и сохранения содержимого в файл. Особенность её в том, что выполняется сразу два потока асинхронных операций — чтение исходного HTTP-потока, и запись в файл. Причём успешно закрыть файл и вызвать функцию обратного вызова мы можем только по завершению всех операций записи, которые могут выполняться не обязательно последовательно.
Вот пример реализации:
> `var getFile = function(url, path, callback)
>
> {
>
> fs.open(path, 'w', 0600, function(err, fd)
>
> {
>
> if (err)
>
> {
>
> callback(err);
>
> return;
>
> }
>
> var request = clientPool.request('GET', url, { 'Host': 'example.com' });
>
> request.on('response', function(sourceResponse)
>
> {
>
> var statusCode = parseInt(sourceResponse.statusCode);
>
> if (statusCode < 200 || statusCode > 299)
>
> {
>
> sourceResponse.on('end', function()
>
> {
>
> clientPool.returnToPool(sourceResponse.client);
>
> });
>
> callback('Bad status code');
>
> return;
>
> }
>
>
>
> var writeErr = null;
>
> var writesPending = 0;
>
> var sourceEnded = false;
>
>
>
> var checkPendingCallback = function()
>
> {
>
> if (!sourceEnded || writesPending > 0)
>
> {
>
> return;
>
> }
>
> fs.close(fd, function(err)
>
> {
>
> err = err ? err : writeErr;
>
> if (err)
>
> {
>
> removeFile(path);
>
> callback(err);
>
> return;
>
> }
>
> // No errors and all written
>
> callback(null);
>
> });
>
> };
>
>
>
> var position = 0;
>
> sourceResponse.on('data', function(chunk)
>
> {
>
> writesPending++;
>
> fs.write(fd, chunk, 0, chunk.length, position, function(err, written)
>
> {
>
> writesPending--;
>
> if (err)
>
> {
>
> writeErr = err;
>
> }
>
> checkPendingCallback();
>
> });
>
> position += chunk.length;
>
> });
>
>
>
> sourceResponse.on('end', function()
>
> {
>
> sourceEnded = true;
>
> checkPendingCallback();
>
> clientPool.returnToPool(sourceResponse.client);
>
> });
>
> });
>
> request.end();
>
> });
>
> };
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### Механизм взаимодействия nginx и нашего сервера
Для того, чтобы не генерировать спрайты на каждый запрос, мы будем сохранять выходные спрайты, удаляя самые старые из их, например, по крону. В случае, если файл уже существует, nginx отдаст его по правилу try\_files. В противном случае запрос будет перенаправлен на наш backend, который создаст нужный файл, и с помощью X-Accel-Redirect попросит nginx отдать файл с внутренней локации, которая ведёт на то же физическое пространство.
При этом конфигурация nginx будет выглядеть где-то так:
> ````
>
> upstream sprite_gen {
> server 127.0.0.1:14239;
> }
>
> location /out_folder/ {
> alias /var/sprite-gen/out_folder/;
> internal;
> }
>
> location / {
> alias /var/sprite-gen/out_folder/;
> try_files $uri @transcoder;
> }
>
> location @transcoder {
> proxy_pass http://sprite_gen;
> }
>
> ````
Данный пример не претендует на совершенство, с его помощью хорошо отдавать большие файлы, в том числе и по частям, с кэшированием.
Если же файлы маленькие, и нам желательно лучше контролировать перегенерацию спрайтов с отсутствующими картинками, то правильнее кэшировать на стороне nginx с правилом вида proxy\_no\_cache $http\_pragma.
#### Получаем несколько файлов
Здесь фрагмент HTTP-сервера, отвечающего за получение набора файлов, формирование спрайта и отдачу результата для nginx.
> `var outPath = ''; // Куда кладём результирующий спрайт
>
> var imageUrls = []; // Здесь список путей для исходных изображений.
>
> var images = []; // Здесь список путей для исходных изображений.
>
>
>
> var waitCounter = images.length;
>
> var needCache = true; // если хоть одно изображение отсутствует, и заменено плейсхолдером, то выключаем кэширование
>
> var handlePart = function(url, pth)
>
> {
>
> getFile(url, pth, function(err)
>
> {
>
> waitCounter--;
>
> if (err)
>
> {
>
> removeFile(pth);
>
> var pth = placeholder\_path;
>
> needCache = false;
>
> }
>
> if (waitCounter == 0)
>
> {
>
> makeSprite(images, outPath, function(err)
>
> {
>
> if (err)
>
> {
>
> response.writeHead(500, {
>
> 'Content-Type': 'text/plain',
>
> });
>
> response.end('Trouble');
>
> return;
>
> }
>
> var headers = {
>
> 'Content-Type': 'image/png',
>
> 'X-Accel-Redirect': outUrl
>
> };
>
> if (needCache)
>
> {
>
> headers['Cache-Control'] = 'max-age:315360000, public';
>
> headers['Expires'] = 'Thu, 31 Dec 2037 23:55:55 GMT';
>
> }
>
> else
>
> {
>
> headers['Cache-Control'] = 'no-cache, no-store';
>
> headers['Pragma'] = 'no-cache';
>
> }
>
> response.writeHead(200, headers);
>
> response.end();
>
> });
>
> }
>
> });
>
> };
>
>
>
> for (var i = 0; i < imageUrls.length)
>
> {
>
> handlePart(imageUrls[i], images[i]);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### Формируем выходной файл посредством внешнего процесса
Контролировать внешние процессы с помощью Node.JS легко и удобно. Для удобства отладки будем копировать вывод, генерируемый внешним процессом, в нашу консоль. Для формирования спрайта выберем пакет GraphicsMagick (форк ImageMagick, обладающий стабильным API и хорошей производительностью).
> `var spriteScript = '/usr/bin/gm';
>
> var placeholder = path.join(\_\_dirname, 'placeholder.jpg');
>
>
>
> var getParams = function(count)
>
> {
>
> return ('montage +frame +shadow +label -background #000000 -tile ' + count + 'x1 -geometry +0+0').split(' ');
>
> };
>
>
>
> var removeFile = function(path)
>
> {
>
> fs.unlink(path, function(err)
>
> {
>
> if (err)
>
> {
>
> console.log('Cannot remove ' + path);
>
> }
>
> });
>
> };
>
>
>
> var cleanup = function(inPaths, placeholder)
>
> {
>
> for (var i = 0; i < inPaths.length; i++)
>
> {
>
> if (inPaths[i] == placeholder)
>
> {
>
> continue;
>
> }
>
> removeFile(inPaths[i]);
>
> }
>
> };
>
>
>
> var makeSprite = function(inPaths, outPath, placeholder, callback)
>
> {
>
> var para = getParams(inPaths.length).concat(inPaths, outPath);
>
> console.log(['run', spriteScript, para.join(' ')].join(' '));
>
> var spriter = child\_process.spawn(spriteScript, para);
>
>
>
> spriter.stderr.addListener('data', function(data)
>
> {
>
> console.log(data);
>
> });
>
> spriter.stdout.addListener('data', function(data)
>
> {
>
> console.log(data);
>
> });
>
> spriter.addListener('exit', function(code, signal)
>
> {
>
> if (signal != null)
>
> {
>
> callback('Internal Server Error - Interrupted by signal' + signal.toString());
>
> return;
>
> }
>
> if (code != 0)
>
> {
>
> callback('Internal Server Error - Code is ' + code.toString());
>
> return;
>
> }
>
> cleanup(inPaths, placeholder);
>
> callback(null);
>
> });
>
> };
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### Небольшие нюансы
##### Формируем имя для временного файла
Для формирования имени файла лучше использовать Process.pid и счётчик запросов (например, как path.join('/tmp', ['source-file', Process.pid, requestCounter].join('-')). При этом функция обработки запросов должна получать счётчик запросов как аргумент, так как обработка следующего запроса может начаться раньше, чем выполнятся все шаги выполнения текущего запроса.
##### Чистим временные данные от прошлых процессов
Пусть все наши временные файлы имеют имя source-pid… или sprite-pid-…:
> `var fileExpr = /^(?:source|sprite)\-(\d+)\b/;
>
> var storagePath = '/tmp/';
>
>
>
> var cleanupOldFiles = function()
>
> {
>
> fs.readdir(storagePath, function(err, files)
>
> {
>
> if (err)
>
> {
>
> console.log('Cannot read ' + storagePath + ' directory.';
>
> return;
>
> }
>
> for (var i = 0; i < files.length; i++)
>
> {
>
> var fn = files[i];
>
> m = fileExpr.exec(fn);
>
> if (!m)
>
> {
>
> continue;
>
> }
>
> var pid = parseInt(m[1]);
>
> if (pid == process.pid)
>
> {
>
> continue;
>
> }
>
> removeFile(path.join(storagePath, fn));
>
> }
>
> });
>
> };
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
##### Скелет обработки запроса
Пусть мы хотим получить спрайт по фотоальбому с какого-то момента времени (timespec).
> `#!/usr/bin/env node
>
>
>
> var child\_process = require('child\_process');
>
> var http = require('http');
>
> var path = require('path');
>
> var fs = require('fs');
>
>
>
> var routeExpr = /^\/?(\w)\/([^\/]+)\/(\d+)\/(\d+)x(\d+)\.png$/;
>
> var fileCounter = 0;
>
>
>
> http.createServer(function(request, response)
>
> {
>
> if (request.method != 'GET')
>
> {
>
> response.writeHead(405, {'Content-Type': 'text/plain'});
>
> response.end('Method Not Allowed');
>
> return;
>
> }
>
> var m = routeExpr.exec(request.url);
>
> if (!m)
>
> {
>
> response.writeHead(400, {'Content-Type': 'text/plain'});
>
> response.end('Bad Request');
>
> return;
>
> }
>
>
>
> var mode = m[1];
>
> var chapter = m[2];
>
> var timespec = parseInt(m[3]);
>
> var width = parseInt(m[4]);
>
> var height = parseInt(m[5]);
>
>
>
> fileCounter++;
>
> var moments = [timespec];
>
> addWantedMoments(moments, mode)
>
>
>
> var runner = function(moments, fileCounter, width, height)
>
> {
>
> var waitCounter = moments.length;
>
> var outPath = path.join(storagePath, ['sprite', process.pid, fileCounter].join('-') + '.png');
>
> var needCache = true;
>
>
>
> for (var i = 0; i < moments.length; i++)
>
> {
>
> handlePart(i, placeholder);
>
> }
>
> };
>
> request.connection.setTimeout(0);
>
> runner([].concat(moments), fileCounter, width, height);
>
>
>
> }).listen(8080, '127.0.0.1');
>
>
>
> console.log('Server running at 127.0.0.1:8080');
>
>
>
> cleanupOldFiles();
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Собственно, теперь у нас есть готовое приложение, формирующее спрайт, как агрегированный результат по набору запросов к другим сайтам.
Осталось добавить конкретики (алгоритмы получения ссылок на исходные изображения, формирования плэйсхолдеров, если размеры постоянно меняются), и этим можно пользоваться.
Собственно, одно из моих мини-приложений и выполняет роль динамического генератора спрайтов.
* **Node.JS — формируем результирующий документ, используя другие HTTP-источники**
* [Node.JS — Основы асинхронного программирования, часть 1](http://habrahabr.ru/blogs/javas%63cript/102717/) | https://habr.com/ru/post/102722/ | null | ru | null |
# Стал доступен эмулятор часов Pebble
В стане разработчиков приложений и циферблатов для Pebble случилась долгожданная радость: в облаке для разработки PebbleCloud стал доступен эмулятор часов, что позволяет теперь отлаживать написанное без постоянной загрузки в часы!
Что особенно приятно, никаких особенных теледвижений для доступа к нему делать не нужно: достаточно зайти в [CloudPebble](https://cloudpebble.net/), и запустить свой проект. По умолчанию проект будет запущен именно в эмуляторе, и для запуска его, по старинке, на часах нужно будет зайти во вкладку «Compilation» и выбрать вариант «Phone» (поскольку именно через телефон происходит загрузка приложения в часы).
Эмулятор позволяет запускать приложения как нативные, так и созданные с использование JS-фреймворков (и PebbleKit JS, и Pebble.js). Сам эмулятор работает, кстати, в среде QEMU, так что можно говорить именно о полноценной эмуляции, а не об изображении похожего на правду поведения часов при запуске некого понятного кода — код действительно будет исполняться в прошивке и на виртуальном «железе» часов.
Взаимодействие с эмулятором возможно либо при помощи мыши, либо можно щелкнуть на экране, а затем нажимать курсорные клавиши на клавиатуре для эмуляуции нажатия кнопок часов. Кроме того, при активной клавиатуре можно нажимать X, Y, или Z для виртуального «перемещения» часов в положительном направлении по указанной оси, либо shift-X, shift-Y, или shift-Z для «перемещения» в отрицательном направлении.
Можно также задавать состояние часов при помощи всплывающего диалога настроек:
Как видно, здесь можно не только менять «текущее состояние» часов для проверки реакции на него своего кода (можно, как видим, менять уровень заряда батареи часов, задавать, подключены ли они к зарядке, указать, активна ли связь по bluetooth), но и вызывать диалог настройки своего приложения (если таковой предусмотрен), а также полностью выключать эмулятор.
Для правильно отработки показа панели настроек, однако, в код проекта нужно внести изменения: при вызове панели ей будет передан параметр запроса `return_to` — если он передан, следует использовать именно заданное в нем значение вместо `pebblejs://close#`. Скажем, можно сделать примерно так:
```
// Получаем переменные запроса
function getQueryParam(variable, default_) {
var query = location.search.substring(1);
var vars = query.split('&');
for (var i = 0; i < vars.length; i++) {
var pair = vars[i].split('=');
if (pair[0] == variable)
return decodeURIComponent(pair[1]);
}
return default_ || false;
}
var return_to = getQueryParam('return_to', 'pebblejs://close#');
document.location = return_to + encodeURIComponent(JSON.stringify(some_settings));
```
Честно говоря, интересно следить за развитием сервисов Pebble. Эмулятор часов прямо просился в неплохую облачную среду разработки, коей оказалась PebbleCloud, и наконец он, после довольно долгого процесса разработки, появился в публичной версии облака. Попробуем?
P.S. Писалось на [информации из блога Pebble](https://developer.getpebble.com/blog/2015/01/22/cloudpebble-pebble-emulator/), из рассылки, из общения с образами Pebble на сайте [QEMU Advent Calendar](http://www.qemu-advent-calendar.org/?mc_cid=655f1238e9&mc_eid=6966490e30), посему «переводом» пост решено не помечать. | https://habr.com/ru/post/365013/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.